add small hdr test file

.config/dotnet-tools.json

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

.editorconfig

@@ -1,8 +1,9 @@
+
 [*]
 charset=utf-8
 end_of_line=lf
 trim_trailing_whitespace=true
-insert_final_newline=true
+insert_final_newline=false
 indent_style=space
 indent_size=4
 
@@ -14,7 +15,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:none
+csharp_style_var_for_built_in_types=false:suggestion
 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
@@ -41,8 +42,6 @@ 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
@@ -67,7 +66,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=none
+resharper_suggest_var_or_type_simple_types_highlighting=hint
 resharper_web_config_module_not_resolved_highlighting=warning
 resharper_web_config_type_not_resolved_highlighting=warning
 resharper_web_config_wrong_module_highlighting=warning
@@ -85,22 +84,7 @@ 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

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Feature Requests
-    url: https://features.ersatztv.org
-    about: Features
-  - name: Discord
-    url: https://discord.ersatztv.org
-    about: Chat
-  - name: Community
-    url: https://discuss.ersatztv.org
-    about: Forum
-  - name: Discussions
-    url: https://github.com/ErsatzTV/ErsatzTV/discussions
-    about: Discuss

.github/ISSUE_TEMPLATE/issue.yml

@@ -1,77 +0,0 @@
-name: Issue Report
-description: Report an issue
-type: Bug
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this form! Please make sure to fill all fields, including the Title above.
-  - type: checkboxes
-    id: before-posting
-    attributes:
-      label: "This issue respects the following points:"
-      description: All conditions are **required**. Failure to comply with any of these conditions may cause your issue to be closed without comment.
-      options:
-        - label: This is a **bug**, not a question or a configuration issue; Please visit our [forum](https://discuss.ersatztv.org) or [chat](https://discord.ersatztv.org) first to troubleshoot with volunteers before creating a report.
-          required: true
-        - label: This issue is **not** already reported on [GitHub](https://github.com/ErsatzTV/ErsatzTV/issues?q=is%3Aopen+is%3Aissue) _(I've searched it)_.
-          required: true
-        - label: I'm using an up to date version of ErsatzTV (full release or develop release); We generally do not support previous older versions. If possible, please update to the latest version before opening an issue.
-          required: true
-        - label: This report addresses only a single issue; If you encounter multiple issues, please create separate reports for each one.
-          required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: |
-        Description of the problem or issue here.
-    validations:
-      required: true
-  - type: textarea
-    id: repro-steps
-    attributes:
-      label: Steps to reproduce the problem.
-      description: |
-        1. Step 1
-        2. Step 2
-        3. Step 3
-
-        If this is a playback issue, follow these steps and post the resulting zip:
-          1. Search for the required content using the search bar.
-          2. Use the overflow/three dots menu on the content and select Troubleshoot Playback.
-          3. Select the appropriate Playback Settings that trigger the undesired behavior.
-          4. Click Play to start playback.
-          5. Repeat steps 3 and 4 until the undesired behavior is reproduced.
-          6. Click Download Results to have ErsatzTV collect relevant troubleshooting logs (ffmpeg log, ffmpeg profile, hardware capabilities, media info, etc) and compress them in a zip file.
-          7. Attach the zip to this field.
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: What is the current _bug_ behavior?
-      description: Write down the incorrect behavior that currently happens after following the reproduction steps.
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: What is the expected _correct_ behavior?
-      description: Write down the correct expected behavior that is supposed to happen after following the reproduction steps.
-    validations:
-      required: true
-  - type: input
-    id: version
-    attributes:
-      label: Specify full version
-      description: Provide the full version of ErsatzTV, which can be found below the left menu.
-      placeholder: |
-        25.5.0-bd695412-docker-amd64
-    validations:
-      required: true
-  - type: textarea
-    id: additional-information
-    attributes:
-      label: Additional information
-      description: Any additional information that might be useful to this issue.

.github/workflows/artifacts.yml

@@ -25,26 +25,18 @@ on:
         required: true
       gh_token:
         required: true
-      azure_client_id:
-        required: true
-      azure_tenant_id:
-        required: true
-      azure_subscription_id:
-        required: true
-permissions:
-  id-token: write
-  contents: write
 jobs:
   build_and_upload_mac:
     name: Mac Build & Upload
     runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - os: macos-14
+          - os: macos-13
             kind: macOS
             target: osx-x64
-          - os: macos-14
+          - os: macos-13
             kind: macOS
             target: osx-arm64
     steps:
@@ -54,10 +46,8 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -81,8 +71,8 @@ jobs:
         shell: bash
         run: |
           sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=false -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          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
 
       - name: Bundle
         shell: bash
@@ -134,20 +124,22 @@ 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: 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_linux:
-    name: Build & Upload Linux
+  build_and_upload:
+    name: Build & Upload
     runs-on: ${{ matrix.os }}
+    if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
@@ -160,19 +152,20 @@ jobs:
           - os: ubuntu-latest
             kind: linux
             target: linux-arm
-          - os: ubuntu-24.04-arm
+          - os: ubuntu-latest
             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 dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -180,6 +173,14 @@ 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/BtbN/FFmpeg-Builds/releases/download/autobuild-2025-06-12-14-05/ffmpeg-n7.1.1-22-g0f1fe3d153-win64-gpl-7.1.zip"
+          target: ffmpeg/
+
       - name: Build
         shell: bash
         run: |
@@ -189,12 +190,31 @@ jobs:
 
           # Build everything
           sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "${{ matrix.target }}" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net8.0 --runtime "${{ matrix.target }}" -c Release -o "scanner" -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 "main" -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"
+
+          # 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
 
           # Delete output directory
           rm -r "$release_name"
@@ -206,131 +226,17 @@ jobs:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}
           fail-if-no-assets: false
-          assets: "*${{ matrix.target }}.tar.gz"
+          assets: |
+            *${{ matrix.target }}.zip
+            *${{ matrix.target }}.tar.gz
 
       - name: Publish
         uses: softprops/action-gh-release@v1
         with:
           prerelease: false
           tag_name: ${{ inputs.release_tag }}
-          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: '10.0.x'
-
-      - 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 net10.0 --runtime "win-x64" -c Release -o "scanner" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net10.0 --runtime "win-x64" -c Release -o "main" -p:RestoreEnablePackagePruning=true -p:InformationalVersion="${{ inputs.release_version }}-win-x64" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-      - name: Upload .NET Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: dotnet-windows-build
-          path: |
-            scanner/
-            main/
-          retention-days: 1
-
-  package_and_upload_windows:
-    name: Package & Upload Windows
-    runs-on: windows-latest
-    needs: build_dotnet_windows
-    steps:
-      - name: Download dotnet artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: dotnet-windows-build
-          path: dotnet-build
-
-      - name: Azure login
-        uses: azure/login@v2
-        with:
-          client-id: ${{ secrets.azure_client_id }}
-          tenant-id: ${{ secrets.azure_tenant_id }}
-          subscription-id: ${{ secrets.azure_subscription_id }}
-          enable-AzPSSession: true
-
-      - name: Sign dotnet artifacts
-        uses: azure/trusted-signing-action@v0
-        with:
-          endpoint: https://eus.codesigning.azure.net/
-          trusted-signing-account-name: ArtifactSigning
-          certificate-profile-name: ErsatzTV
-          files-folder: ${{ github.workspace }}/dotnet-build
-          files-folder-recurse: true
-          files-folder-filter: ErsatzTV.exe,ErsatzTV.Scanner.exe
-          file-digest: SHA256
-          timestamp-rfc3161: http://timestamp.acs.microsoft.com
-          timestamp-digest: SHA256
-
-      - name: Download rust launcher
-        uses: suisei-cn/actions-download-file@v1.3.0
-        with:
-          url: "https://github.com/ErsatzTV/ErsatzTV-Windows/releases/download/v1.0.0/ErsatzTV-Windows.exe"
-          target: rust-build/
-
-      - name: Download ffmpeg
-        uses: suisei-cn/actions-download-file@v1.3.0
-        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"
-
-          (cd "${release_name}" && 7z a "../${release_name}.zip" .)
-
-      - 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"
+          files: |
+            ${{ env.RELEASE_NAME }}.zip
+            ${{ env.RELEASE_NAME }}.tar.gz
         env:
           GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

@@ -46,11 +46,7 @@ jobs:
       ac_username: ${{ secrets.AC_USERNAME }}
       ac_password: ${{ secrets.AC_PASSWORD }}
       gh_token: ${{ secrets.GITHUB_TOKEN }}
-      azure_client_id: ${{ secrets.AZURE_CLIENT_ID }}
-      azure_tenant_id: ${{ secrets.AZURE_TENANT_ID }}
-      azure_subscription_id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-
-  build_images:
+  build_and_push:
     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,28 +20,33 @@ on:
       docker_hub_access_token:
         required: true
 jobs:
-  build_images:
-    name: Build ${{ matrix.name }} image
-    runs-on: ${{ matrix.os }}
+  build_and_push:
+    name: Build & Publish
+    runs-on: ubuntu-latest
     if: contains(github.event.head_commit.message, '[no build]') == false
     strategy:
       matrix:
         include:
-          - name: amd64
-            os: ubuntu-latest
+          - name: base
             path: ''
-            suffix: '-amd64'
-            platform: 'linux/amd64'
+            suffix: ''
+            qemu: false
+          - name: nvidia
+            path: 'nvidia/'
+            suffix: '-nvidia'
+            qemu: false
+          - name: vaapi
+            path: 'vaapi/'
+            suffix: '-vaapi'
+            qemu: false
           - name: arm32v7
-            os: ubuntu-latest
             path: 'arm32v7/'
             suffix: '-arm'
-            platform: 'linux/arm/v7'
+            qemu: true
           - name: arm64
-            os: ubuntu-24.04-arm
             path: 'arm64/'
             suffix: '-arm64'
-            platform: 'linux/arm64'
+            qemu: true
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -49,11 +54,12 @@ 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
@@ -68,74 +74,52 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push by digest
-        id: build
+      - name: Build and push
         uses: docker/build-push-action@v5
         with:
+          builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
           file: ./docker/${{ matrix.path }}Dockerfile
           push: true
-          provenance: false
-          platforms: ${{ matrix.platform }}
           build-args: |
             INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
-          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
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name != 'arm64' && matrix.name != 'arm32v7' }}
 
-      - name: Save digest to artifact
-        run: echo ${{ steps.build.outputs.digest }} > digest.txt
-
-      - name: Upload digest artifact
-        uses: actions/upload-artifact@v4
+      - name: Build and push
+        uses: docker/build-push-action@v5
         with:
-          name: digest-${{ matrix.name }}
-          path: digest.txt
+          builder: ${{ steps.docker-buildx.outputs.name }}
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          platforms: 'linux/arm64'
+          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 }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm64' }}
 
-  merge_manifests:
-    name: Merge Manifests
-    runs-on: ubuntu-latest
-    needs: build_images
-    steps:
-      - name: Login to DockerHub
-        uses: docker/login-action@v3
+      - name: Build and push
+        uses: docker/build-push-action@v5
         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 }}
+          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 }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            ghcr.io/ersatztv/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm32v7' }}

.github/workflows/pr.yml

@@ -2,41 +2,14 @@
 on:
   pull_request:
 jobs:
-  build_and_analyze:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup dotnet
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Prep project file
-        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore /p:EnableThreadingAnalyzers=true
   build_and_test_windows:
     runs-on: windows-latest
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -52,44 +25,36 @@ jobs:
 
       - name: Test
         run: dotnet test --blame-hang-timeout "2m" --no-restore --verbosity normal
+
+      - name: Build Windows
+        run: |
+          cd ErsatzTV-Windows
+          cargo build --release --all-features
   build_and_test_linux:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      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
+    runs-on: ubuntu-latest
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
 
       - name: Install dependencies
-        run: dotnet restore -p:RestoreEnablePackagePruning=true -r "${{ matrix.target }}"
+        run: dotnet restore
 
       - name: Prep project file
         run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
 
       - name: Build
-        run: dotnet build ErsatzTV/ErsatzTV.csproj --runtime "${{ matrix.target }}" --configuration Release --no-restore && dotnet build --configuration Release --no-restore
+        run: 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-14
+    runs-on: macos-13
     steps:
       - name: Get the sources
         uses: actions/checkout@v4
@@ -97,10 +62,8 @@ jobs:
           fetch-depth: 0
           submodules: true
 
-      - name: Setup dotnet
+      - name: Setup .NET Core
         uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: '10.0.x'
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear

.github/workflows/release.yml

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

.gitignore

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

CHANGELOG.md

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

Directory.Build.props

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

Directory.Build.targets

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

ErsatzTV-Windows/.gitignore

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

ErsatzTV-Windows/Cargo.toml

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

ErsatzTV-Windows/build.rs

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

ErsatzTV-Windows/ersatztv_windows.rc

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

ErsatzTV-Windows/src/main.rs

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

ErsatzTV.Application/Artists/Mapper.cs

@@ -29,10 +29,9 @@ 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

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

ErsatzTV.Application/Artworks/ArtworkContentTypeModel.cs

@@ -1,17 +0,0 @@
-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/GetArtworkHandler.cs

@@ -6,25 +6,24 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Artworks;
 
-public class GetArtworkHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetArtwork, Either<BaseError, Artwork>>
+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,
+        GetArtwork request, 
         CancellationToken cancellationToken)
     {
-        try
-        {
+        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)
+                .SelectOneAsync(a => a.Id, a => a.Id == request.Id)
                 .MapT(Project);
-
+            
             return artwork.ToEither(BaseError.New("Artwork not found"));
+        
         }
         catch (Exception ex)
         {
@@ -32,11 +31,12 @@ public class GetArtworkHandler(IDbContextFactory<TvContext> dbContextFactory)
         }
     }
 
-    private static Artwork Project(Artwork artwork) =>
-        new()
-        {
+    private static Artwork Project(Artwork artwork)
+    {
+        return new Artwork {
             Id = artwork.Id,
             Path = artwork.Path,
             ArtworkKind = artwork.ArtworkKind
         };
+    }
 }

ErsatzTV.Application/Channels/ChannelSortViewModel.cs

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

ErsatzTV.Application/Channels/ChannelStreamingSpecsViewModel.cs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -1,6 +1,5 @@
-using System.Net;
-using ErsatzTV.Application.Artworks;
 using ErsatzTV.Core.Domain;
+using System.Net;
 
 namespace ErsatzTV.Application.Channels;
 
@@ -11,15 +10,10 @@ public record ChannelViewModel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    ArtworkContentTypeModel Logo,
-    ChannelStreamSelectorMode StreamSelectorMode,
-    string StreamSelector,
+    string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
-    ChannelPlayoutSource PlayoutSource,
-    ChannelPlayoutMode PlayoutMode,
-    int? MirrorSourceChannelId,
-    TimeSpan? PlayoutOffset,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -28,11 +22,7 @@ public record ChannelViewModel(
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
     string MusicVideoCreditsTemplate,
-    ChannelSongVideoMode SongVideoMode,
-    ChannelTranscodeMode TranscodeMode,
-    ChannelIdleBehavior IdleBehavior,
-    bool IsEnabled,
-    bool ShowInEpg)
+    ChannelSongVideoMode SongVideoMode)
 {
     public string WebEncodedName => WebUtility.UrlEncode(Name);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -1,5 +1,4 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
@@ -10,15 +9,10 @@ public record CreateChannel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    ArtworkContentTypeModel Logo,
-    ChannelStreamSelectorMode StreamSelectorMode,
-    string StreamSelector,
+    string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
-    ChannelPlayoutSource PlayoutSource,
-    ChannelPlayoutMode PlayoutMode,
-    int? MirrorSourceChannelId,
-    TimeSpan? PlayoutOffset,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -26,8 +20,4 @@ public record CreateChannel(
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
     string MusicVideoCreditsTemplate,
-    ChannelSongVideoMode SongVideoMode,
-    ChannelTranscodeMode TranscodeMode,
-    ChannelIdleBehavior IdleBehavior,
-    bool IsEnabled,
-    bool ShowInEpg) : IRequest<Either<BaseError, CreateChannelResult>>;
+    ChannelSongVideoMode SongVideoMode) : 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, cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
         return await validation.Apply(c => PersistChannel(dbContext, c));
     }
 
@@ -36,93 +35,63 @@ public class CreateChannelHandler(
         return new CreateChannelResult(channel.Id);
     }
 
-    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),
-            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
-        .Apply((
-            name,
-            number,
-            ffmpegProfileId,
-            watermarkId,
-            fillerPresetId,
-            _) =>
-        {
-            var artwork = new List<Artwork>();
-            if (!string.IsNullOrWhiteSpace(request.Logo?.Path))
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request),
+            await FFmpegProfileMustExist(dbContext, request),
+            await WatermarkMustExist(dbContext, request),
+            await FillerPresetMustExist(dbContext, request))
+        .Apply(
+            (
+                name,
+                number,
+                ffmpegProfileId,
+                watermarkId,
+                fillerPresetId) =>
             {
-                string logo = request.Logo.Path;
-                if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
+                var artwork = new List<Artwork>();
+                if (!string.IsNullOrWhiteSpace(request.Logo))
                 {
-                    logo = logo.Replace("iptv/logos/", string.Empty);
+                    artwork.Add(
+                        new Artwork
+                        {
+                            Path = request.Logo,
+                            ArtworkKind = ArtworkKind.Logo,
+                            DateAdded = DateTime.UtcNow,
+                            DateUpdated = DateTime.UtcNow
+                        });
                 }
 
-                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
-                    });
-            }
+                var channel = new Channel(Guid.NewGuid())
+                {
+                    Name = name,
+                    Number = number,
+                    Group = request.Group,
+                    Categories = request.Categories,
+                    FFmpegProfileId = ffmpegProfileId,
+                    ProgressMode = request.ProgressMode,
+                    StreamingMode = request.StreamingMode,
+                    Artwork = artwork,
+                    PreferredAudioLanguageCode = request.PreferredAudioLanguageCode,
+                    PreferredAudioTitle = request.PreferredAudioTitle,
+                    PreferredSubtitleLanguageCode = request.PreferredSubtitleLanguageCode,
+                    SubtitleMode = request.SubtitleMode,
+                    MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate,
+                    SongVideoMode = request.SongVideoMode
+                };
 
-            var channel = new Channel(Guid.NewGuid())
-            {
-                Name = name,
-                Number = number,
-                SortNumber = double.Parse(number, CultureInfo.InvariantCulture),
-                Group = request.Group,
-                Categories = request.Categories,
-                FFmpegProfileId = ffmpegProfileId,
-                PlayoutSource = request.PlayoutSource,
-                PlayoutMode = request.PlayoutMode,
-                MirrorSourceChannelId = request.MirrorSourceChannelId,
-                PlayoutOffset = request.PlayoutOffset,
-                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 watermarkId)
+                {
+                    channel.WatermarkId = id;
+                }
 
-            if (channel.PlayoutSource is ChannelPlayoutSource.Mirror)
-            {
-                channel.PlayoutMode = ChannelPlayoutMode.Continuous;
-            }
-            else
-            {
-                channel.MirrorSourceChannelId = null;
-                channel.PlayoutOffset = null;
-            }
+                foreach (int id in fillerPresetId)
+                {
+                    channel.FallbackFillerId = id;
+                }
 
-            foreach (int id in watermarkId)
-            {
-                channel.WatermarkId = id;
-            }
-
-            foreach (int id in fillerPresetId)
-            {
-                channel.FallbackFillerId = id;
-            }
-
-            return channel;
-        });
+                return channel;
+            });
 
     private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
         createChannel.NotEmpty(c => c.Name)
@@ -130,11 +99,10 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
+        CreateChannel createChannel)
     {
         Option<Channel> maybeExistingChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number, cancellationToken);
+            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
         return maybeExistingChannel.Match<Validation<BaseError, string>>(
             _ => BaseError.New("Channel number must be unique"),
             () =>
@@ -150,10 +118,9 @@ public class CreateChannelHandler(
 
     private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken) =>
+        CreateChannel createChannel) =>
         dbContext.FFmpegProfiles
-            .CountAsync(p => p.Id == createChannel.FFmpegProfileId, cancellationToken)
+            .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => createChannel.FFmpegProfileId)
@@ -161,8 +128,7 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
+        CreateChannel createChannel)
     {
         if (createChannel.WatermarkId is null)
         {
@@ -170,7 +136,7 @@ public class CreateChannelHandler(
         }
 
         return await dbContext.ChannelWatermarks
-            .CountAsync(w => w.Id == createChannel.WatermarkId, cancellationToken)
+            .CountAsync(w => w.Id == createChannel.WatermarkId)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.WatermarkId))
@@ -179,8 +145,7 @@ public class CreateChannelHandler(
 
     private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
         TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
+        CreateChannel createChannel)
     {
         if (createChannel.FallbackFillerId is null)
         {
@@ -189,53 +154,12 @@ public class CreateChannelHandler(
 
         return await dbContext.FillerPresets
             .Filter(fp => fp.FillerKind == FillerKind.Fallback)
-            .CountAsync(w => w.Id == createChannel.FallbackFillerId, cancellationToken)
+            .CountAsync(w => w.Id == createChannel.FallbackFillerId)
             .Map(Optional)
             .Filter(c => c > 0)
             .MapT(_ => Optional(createChannel.FallbackFillerId))
-            .Map(o => o.ToValidation<BaseError>(
-                $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
-    }
-
-    private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
-        TvContext dbContext,
-        CreateChannel createChannel,
-        CancellationToken cancellationToken)
-    {
-        if (createChannel.PlayoutSource is not ChannelPlayoutSource.Mirror)
-        {
-            return Unit.Default;
-        }
-
-        Option<Channel> maybeMirrorSource = await dbContext.Channels
-            .AsNoTracking()
-            .SelectOneAsync(
-                c => c.Id == createChannel.MirrorSourceChannelId,
-                c => c.Id == createChannel.MirrorSourceChannelId,
-                cancellationToken);
-
-        if (maybeMirrorSource.IsNone)
-        {
-            return BaseError.New("Mirror source channel does not exist.");
-        }
-
-        foreach (var mirrorSource in maybeMirrorSource)
-        {
-            if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
-            {
-                return BaseError.New(
-                    $"Mirror source channel {mirrorSource.Name} must use generated playout source");
-            }
-        }
-
-        foreach (TimeSpan playoutOffset in Optional(createChannel.PlayoutOffset))
-        {
-            if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
-            {
-                return BaseError.New("Playout offset must not be greater than 12 hours");
-            }
-        }
-
-        return Unit.Default;
+            .Map(
+                o => o.ToValidation<BaseError>(
+                    $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
     }
 }

ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs

@@ -1,6 +1,6 @@
-using System.IO.Abstractions;
 using System.Threading.Channels;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -12,26 +12,26 @@ namespace ErsatzTV.Application.Channels;
 public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Unit>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly IFileSystem _fileSystem;
+    private readonly ILocalFileSystem _localFileSystem;
     private readonly ISearchTargets _searchTargets;
     private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
     public DeleteChannelHandler(
         ChannelWriter<IBackgroundServiceRequest> workerChannel,
         IDbContextFactory<TvContext> dbContextFactory,
-        IFileSystem fileSystem,
+        ILocalFileSystem localFileSystem,
         ISearchTargets searchTargets)
     {
         _workerChannel = workerChannel;
         _dbContextFactory = dbContextFactory;
-        _fileSystem = fileSystem;
+        _localFileSystem = localFileSystem;
         _searchTargets = searchTargets;
     }
 
     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, cancellationToken);
+        Validation<BaseError, Channel> validation = await ChannelMustExist(dbContext, request);
         return await validation.Apply(c => DoDeletion(dbContext, c, cancellationToken));
     }
 
@@ -44,7 +44,7 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
         // delete channel data from channel guide cache
         string cacheFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channel.Number}.xml");
-        if (_fileSystem.File.Exists(cacheFile))
+        if (_localFileSystem.FileExists(cacheFile))
         {
             File.Delete(cacheFile);
         }
@@ -57,11 +57,10 @@ public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseEr
 
     private static async Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
-        DeleteChannel deleteChannel,
-        CancellationToken cancellationToken)
+        DeleteChannel deleteChannel)
     {
         Option<Channel> maybeChannel = await dbContext.Channels
-            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId, cancellationToken);
+            .SelectOneAsync(c => c.Id, c => c.Id == deleteChannel.ChannelId);
         return maybeChannel.ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.");
     }
 }

ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs

@@ -1,5 +1,4 @@
 using System.Globalization;
-using System.IO.Abstractions;
 using System.Xml;
 using ErsatzTV.Application.Configuration;
 using ErsatzTV.Core;
@@ -12,7 +11,6 @@ using ErsatzTV.Core.Iptv;
 using ErsatzTV.Core.Jellyfin;
 using ErsatzTV.Core.Streaming;
 using ErsatzTV.Infrastructure.Data;
-using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Microsoft.IO;
@@ -27,7 +25,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly IFileSystem _fileSystem;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RefreshChannelDataHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
@@ -35,14 +32,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
     public RefreshChannelDataHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
-        IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         IConfigElementRepository configElementRepository,
         ILogger<RefreshChannelDataHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
-        _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _configElementRepository = configElementRepository;
         _logger = logger;
@@ -50,278 +45,207 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     public async Task Handle(RefreshChannelData request, CancellationToken cancellationToken)
     {
-        try
+        _logger.LogDebug("Refreshing channel data (XMLTV) for channel {Channel}", request.ChannelNumber);
+
+        _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
+
+        string movieTemplateFileName = GetMovieTemplateFileName();
+        string episodeTemplateFileName = GetEpisodeTemplateFileName();
+        string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
+        string songTemplateFileName = GetSongTemplateFileName();
+        string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
+        if (movieTemplateFileName is null || episodeTemplateFileName is null || musicVideoTemplateFileName is null ||
+            songTemplateFileName is null || otherVideoTemplateFileName is null)
         {
-            _logger.LogDebug("Refreshing channel data (XMLTV) for channel {Channel}", request.ChannelNumber);
-
-            _localFileSystem.EnsureFolderExists(FileSystemLayout.ChannelGuideCacheFolder);
-
-            string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            int hiddenCount = await dbContext.Channels
-                .Where(c => c.Number == request.ChannelNumber && c.ShowInEpg == false)
-                .CountAsync(cancellationToken);
-            if (hiddenCount > 0)
-            {
-                File.Delete(targetFile);
-                return;
-            }
-
-            string movieTemplateFileName = GetMovieTemplateFileName();
-            string episodeTemplateFileName = GetEpisodeTemplateFileName();
-            string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
-            string songTemplateFileName = GetSongTemplateFileName();
-            string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
-            string remoteStreamTemplateFileName = GetRemoteStreamTemplateFileName();
-            if (movieTemplateFileName is null || episodeTemplateFileName is null ||
-                musicVideoTemplateFileName is null ||
-                songTemplateFileName is null || otherVideoTemplateFileName is null ||
-                remoteStreamTemplateFileName is null)
-            {
-                return;
-            }
-
-            var minifier = new XmlMinifier(
-                new XmlMinificationSettings
-                {
-                    MinifyWhitespace = true,
-                    RemoveXmlComments = true,
-                    CollapseTagsWithoutContent = true
-                });
-
-            var templateContext = new XmlTemplateContext();
-
-            string movieText = await File.ReadAllTextAsync(movieTemplateFileName, cancellationToken);
-            var movieTemplate = Template.Parse(movieText, movieTemplateFileName);
-
-            string episodeText = await File.ReadAllTextAsync(episodeTemplateFileName, cancellationToken);
-            var episodeTemplate = Template.Parse(episodeText, episodeTemplateFileName);
-
-            string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
-            var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
-
-            string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
-            var songTemplate = Template.Parse(songText, songTemplateFileName);
-
-            string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
-            var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
-
-            string remoteStreamText = await File.ReadAllTextAsync(remoteStreamTemplateFileName, cancellationToken);
-            var remoteStreamTemplate = Template.Parse(remoteStreamText, remoteStreamTemplateFileName);
-
-            TimeSpan playoutOffset = TimeSpan.Zero;
-            string mirrorChannelNumber = null;
-            Option<Channel> maybeChannel = await dbContext.Channels
-                .AsNoTracking()
-                .Include(c => c.MirrorSourceChannel)
-                .Filter(c => c.PlayoutSource == ChannelPlayoutSource.Mirror && c.MirrorSourceChannelId != null)
-                .SelectOneAsync(
-                    c => c.Number == request.ChannelNumber,
-                    c => c.Number == request.ChannelNumber,
-                    cancellationToken);
-            foreach (Channel channel in maybeChannel)
-            {
-                mirrorChannelNumber = channel.MirrorSourceChannel.Number;
-                playoutOffset = channel.PlayoutOffset ?? TimeSpan.Zero;
-            }
-
-            List<Playout> playouts = await dbContext.Playouts
-                .AsNoTracking()
-                .Filter(pi => pi.Channel.Number == (mirrorChannelNumber ?? request.ChannelNumber))
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Studios)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Directors)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Artists)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .ThenInclude(am => am.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as RemoteStream).RemoteStreamMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Studios)
-                .AsSplitQuery()
-                .ToListAsync(cancellationToken);
-
-            await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
-            await using var xml = XmlWriter.Create(
-                ms,
-                new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
-
-            int daysToBuild = await _configElementRepository
-                .GetValue<int>(ConfigElementKey.XmltvDaysToBuild, cancellationToken)
-                .IfNoneAsync(2);
-
-            DateTimeOffset finish = DateTimeOffset.UtcNow.AddDays(daysToBuild);
-
-            foreach (Playout playout in playouts)
-            {
-                switch (playout.ScheduleKind)
-                {
-                    case PlayoutScheduleKind.Classic:
-                    case PlayoutScheduleKind.Sequential:
-                    case PlayoutScheduleKind.Scripted:
-                        var floodSorted = playouts
-                            .Collect(p => p.Items)
-                            .OrderBy(pi => pi.Start)
-                            .Filter(pi => pi.StartOffset <= finish)
-                            .ToList();
-                        foreach (var item in floodSorted)
-                        {
-                            item.Start += playoutOffset;
-                            item.Finish += playoutOffset;
-                        }
-
-                        await WritePlayoutXml(
-                            request,
-                            floodSorted,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml,
-                            cancellationToken);
-                        break;
-                    case PlayoutScheduleKind.Block:
-                        var blockSorted = playouts
-                            .Collect(p => p.Items)
-                            .OrderBy(pi => pi.Start)
-                            .Filter(pi => pi.StartOffset <= finish)
-                            .ToList();
-                        foreach (var item in blockSorted)
-                        {
-                            item.Start += playoutOffset;
-                            item.Finish += playoutOffset;
-                        }
-
-                        await WriteBlockPlayoutXml(
-                            request,
-                            blockSorted,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml,
-                            cancellationToken);
-                        break;
-                    case PlayoutScheduleKind.ExternalJson:
-                        var externalJsonSorted = (await CollectExternalJsonItems(playout.ScheduleFile))
-                            .Filter(pi => pi.StartOffset <= finish)
-                            .ToList();
-                        foreach (var item in externalJsonSorted)
-                        {
-                            item.Start += playoutOffset;
-                            item.Finish += playoutOffset;
-                        }
-
-                        await WritePlayoutXml(
-                            request,
-                            externalJsonSorted,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml,
-                            cancellationToken);
-                        break;
-                }
-            }
-
-            await xml.FlushAsync();
-
-            string tempFile = Path.GetTempFileName();
-            await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
-
-            File.Move(tempFile, targetFile, true);
+            return;
         }
-        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
+
+        var minifier = new XmlMinifier(
+            new XmlMinificationSettings
+            {
+                MinifyWhitespace = true,
+                RemoveXmlComments = true,
+                CollapseTagsWithoutContent = true
+            });
+
+        var templateContext = new XmlTemplateContext();
+
+        string movieText = await File.ReadAllTextAsync(movieTemplateFileName, cancellationToken);
+        var movieTemplate = Template.Parse(movieText, movieTemplateFileName);
+
+        string episodeText = await File.ReadAllTextAsync(episodeTemplateFileName, cancellationToken);
+        var episodeTemplate = Template.Parse(episodeText, episodeTemplateFileName);
+
+        string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
+        var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
+
+        string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
+        var songTemplate = Template.Parse(songText, songTemplateFileName);
+
+        string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
+        var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
+
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<Playout> playouts = await dbContext.Playouts
+            .AsNoTracking()
+            .Filter(pi => pi.Channel.Number == request.ChannelNumber)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Studios)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Directors)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Artists)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .ThenInclude(am => am.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Studios)
+            .ToListAsync(cancellationToken);
+
+        await using RecyclableMemoryStream ms = _recyclableMemoryStreamManager.GetStream();
+        await using var xml = XmlWriter.Create(
+            ms,
+            new XmlWriterSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment });
+
+        int daysToBuild = await _configElementRepository
+            .GetValue<int>(ConfigElementKey.XmltvDaysToBuild)
+            .IfNoneAsync(2);
+
+        DateTimeOffset finish = DateTimeOffset.UtcNow.AddDays(daysToBuild);
+
+        foreach (Playout playout in playouts)
         {
-            // do nothing
+            switch (playout.ProgramSchedulePlayoutType)
+            {
+                case ProgramSchedulePlayoutType.Flood:
+                case ProgramSchedulePlayoutType.Yaml:
+                    var floodSorted = playouts
+                        .Collect(p => p.Items)
+                        .OrderBy(pi => pi.Start)
+                        .Filter(pi => pi.StartOffset <= finish)
+                        .ToList();
+                    await WritePlayoutXml(
+                        request,
+                        floodSorted,
+                        templateContext,
+                        movieTemplate,
+                        episodeTemplate,
+                        musicVideoTemplate,
+                        songTemplate,
+                        otherVideoTemplate,
+                        minifier,
+                        xml);
+                    break;
+                case ProgramSchedulePlayoutType.Block:
+                    var blockSorted = playouts
+                        .Collect(p => p.Items)
+                        .OrderBy(pi => pi.Start)
+                        .Filter(pi => pi.StartOffset <= finish)
+                        .ToList();
+                    await WriteBlockPlayoutXml(
+                        request,
+                        blockSorted,
+                        templateContext,
+                        movieTemplate,
+                        episodeTemplate,
+                        musicVideoTemplate,
+                        songTemplate,
+                        otherVideoTemplate,
+                        minifier,
+                        xml);
+                    break;
+                case ProgramSchedulePlayoutType.ExternalJson:
+                    var externalJsonSorted = (await CollectExternalJsonItems(playout.ExternalJsonFile))
+                        .Filter(pi => pi.StartOffset <= finish)
+                        .ToList();
+
+                    await WritePlayoutXml(
+                        request,
+                        externalJsonSorted,
+                        templateContext,
+                        movieTemplate,
+                        episodeTemplate,
+                        musicVideoTemplate,
+                        songTemplate,
+                        otherVideoTemplate,
+                        minifier,
+                        xml);
+                    break;
+            }
         }
+
+        await xml.FlushAsync();
+
+        string tempFile = Path.GetTempFileName();
+        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+
+        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
+        File.Move(tempFile, targetFile, true);
     }
 
     private async Task WritePlayoutXml(
@@ -333,13 +257,11 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
-        Template remoteStreamTemplate,
         XmlMinifier minifier,
-        XmlWriter xml,
-        CancellationToken cancellationToken)
+        XmlWriter xml)
     {
         XmltvTimeZone xmltvTimeZone = await _configElementRepository
-            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
+            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone)
             .IfNoneAsync(XmltvTimeZone.Local);
 
         // skip all filler that isn't pre-roll
@@ -365,12 +287,24 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             int finishIndex = j;
             while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
                                                       || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
-                                                          or FillerKind.PostRoll or FillerKind.Tail
-                                                          or FillerKind.Fallback or FillerKind.DecoDefault))
+                                                          or FillerKind.Tail or FillerKind.Fallback or FillerKind.DecoDefault))
             {
                 finishIndex++;
             }
 
+            int customShowId = -1;
+            if (displayItem.MediaItem is Episode ep)
+            {
+                customShowId = ep.Season.ShowId;
+            }
+
+            bool isSameCustomShow = hasCustomTitle;
+            for (int x = j; x <= finishIndex; x++)
+            {
+                isSameCustomShow = isSameCustomShow && sorted[x].MediaItem is Episode e &&
+                                   customShowId == e.Season.ShowId;
+            }
+
             PlayoutItem finishItem = sorted[finishIndex];
             i = finishIndex;
 
@@ -408,7 +342,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 musicVideoTemplate,
                 songTemplate,
                 otherVideoTemplate,
-                remoteStreamTemplate,
                 minifier,
                 xml);
 
@@ -416,7 +349,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         }
     }
 
-    private async Task WriteBlockPlayoutXml(
+    private static async Task WriteBlockPlayoutXml(
         RefreshChannelData request,
         List<PlayoutItem> sorted,
         XmlTemplateContext templateContext,
@@ -425,110 +358,51 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
-        Template remoteStreamTemplate,
         XmlMinifier minifier,
-        XmlWriter xml,
-        CancellationToken cancellationToken)
+        XmlWriter xml)
     {
-        XmltvTimeZone xmltvTimeZone = await _configElementRepository
-            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
-            .IfNoneAsync(XmltvTimeZone.Local);
-
-        XmltvBlockBehavior xmltvBlockBehavior = await _configElementRepository
-            .GetValue<XmltvBlockBehavior>(ConfigElementKey.XmltvBlockBehavior, cancellationToken)
-            .IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly);
-
         var groups = sorted.GroupBy(s => new { s.GuideStart, s.GuideFinish, s.GuideGroup });
         foreach (var group in groups)
         {
+            DateTime groupStart = group.Key.GuideStart!.Value;
+            DateTime groupFinish = group.Key.GuideFinish!.Value;
+            TimeSpan groupDuration = groupFinish - groupStart;
+
             var itemsToInclude = group.Filter(g => g.FillerKind is FillerKind.None).ToList();
             if (itemsToInclude.Count == 0)
             {
                 continue;
             }
 
-            switch (xmltvBlockBehavior)
+            TimeSpan perItem = groupDuration / itemsToInclude.Count;
+
+            DateTimeOffset currentStart = new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime();
+            DateTimeOffset currentFinish = currentStart + perItem;
+
+            foreach (PlayoutItem item in itemsToInclude)
             {
-                case XmltvBlockBehavior.UseActualTimes:
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        DateTimeOffset actualStart = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Start, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Start, TimeSpan.Zero).ToLocalTime()
-                        };
+                string start = currentStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                    .Replace(":", string.Empty);
+                string stop = currentFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                    .Replace(":", string.Empty);
 
-                        DateTimeOffset actualFinish = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Finish, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Finish, TimeSpan.Zero).ToLocalTime()
-                        };
+                await WriteItemToXml(
+                    request,
+                    item,
+                    start,
+                    stop,
+                    false,
+                    templateContext,
+                    movieTemplate,
+                    episodeTemplate,
+                    musicVideoTemplate,
+                    songTemplate,
+                    otherVideoTemplate,
+                    minifier,
+                    xml);
 
-                        string start = actualStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = actualFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-                    }
-                    break;
-                case XmltvBlockBehavior.SplitTimeEvenly:
-                default:
-                    DateTime groupStart = group.Key.GuideStart!.Value;
-                    DateTime groupFinish = group.Key.GuideFinish!.Value;
-                    TimeSpan groupDuration = groupFinish - groupStart;
-
-                    TimeSpan perItem = groupDuration / itemsToInclude.Count;
-
-                    DateTimeOffset currentStart = xmltvTimeZone switch
-                    {
-                        XmltvTimeZone.Utc => new DateTimeOffset(groupStart, TimeSpan.Zero),
-                        _ => new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime()
-                    };
-
-                    DateTimeOffset currentFinish = currentStart + perItem;
-
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        string start = currentStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = currentFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-
-                        currentStart = currentFinish;
-                        currentFinish += perItem;
-                    }
-                    break;
+                currentStart = currentFinish;
+                currentFinish += perItem;
             }
         }
     }
@@ -545,7 +419,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         Template musicVideoTemplate,
         Template songTemplate,
         Template otherVideoTemplate,
-        Template remoteStreamTemplate,
         XmlMinifier minifier,
         XmlWriter xml)
     {
@@ -607,16 +480,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 title,
                 templateContext,
                 otherVideoTemplate),
-            RemoteStream templateRemoteStream => await ProcessRemoteStreamTemplate(
-                request,
-                templateRemoteStream,
-                start,
-                stop,
-                hasCustomTitle,
-                displayItem,
-                title,
-                templateContext,
-                remoteStreamTemplate),
             _ => Option<string>.None
         };
 
@@ -704,7 +567,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 showMetadata.Guids ??= [];
 
                 string artworkPath = GetPrioritizedArtworkPath(showMetadata);
-                string thumbnailPath = GetPrioritizedArtworkPath(metadata);
 
                 var data = new
                 {
@@ -725,8 +587,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                     ShowGenres = showMetadata.Genres.Map(g => g.Name).OrderBy(n => n),
                     EpisodeHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
                     EpisodeArtworkUrl = artworkPath,
-                    EpisodeHasThumbnail = !string.IsNullOrWhiteSpace(thumbnailPath),
-                    EpisodeThumbnailUrl = thumbnailPath,
                     SeasonNumber = templateEpisode.Season?.SeasonNumber ?? 0,
                     metadata.EpisodeNumber,
                     ShowHasContentRating = !string.IsNullOrWhiteSpace(showMetadata.ContentRating),
@@ -883,8 +743,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             metadata.Genres ??= [];
             metadata.Guids ??= [];
 
-            string artworkPath = GetPrioritizedArtworkPath(metadata);
-
             var data = new
             {
                 ProgrammeStart = start,
@@ -899,8 +757,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 OtherVideoPlot = metadata.Plot,
                 OtherVideoHasYear = metadata.Year.HasValue,
                 OtherVideoYear = metadata.Year,
-                OtherVideoHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
-                OtherVideoArtworkUrl = artworkPath,
                 OtherVideoGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
                 OtherVideoHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
                 OtherVideoContentRating = metadata.ContentRating
@@ -916,63 +772,18 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return Option<string>.None;
     }
 
-    private static async Task<Option<string>> ProcessRemoteStreamTemplate(
-        RefreshChannelData request,
-        RemoteStream templateRemoteStream,
-        string start,
-        string stop,
-        bool hasCustomTitle,
-        PlayoutItem displayItem,
-        string title,
-        XmlTemplateContext templateContext,
-        Template remoteStreamTemplate)
-    {
-        foreach (RemoteStreamMetadata metadata in templateRemoteStream.RemoteStreamMetadata.HeadOrNone())
-        {
-            metadata.Genres ??= [];
-            metadata.Guids ??= [];
-
-            string artworkPath = GetPrioritizedArtworkPath(metadata);
-
-            var data = new
-            {
-                ProgrammeStart = start,
-                ProgrammeStop = stop,
-                ChannelId = ChannelIdentifier.FromNumber(request.ChannelNumber),
-                ChannelIdLegacy = ChannelIdentifier.LegacyFromNumber(request.ChannelNumber),
-                request.ChannelNumber,
-                HasCustomTitle = hasCustomTitle,
-                displayItem.CustomTitle,
-                RemoteStreamTitle = title,
-                RemoteStreamHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
-                RemoteStreamPlot = metadata.Plot,
-                RemoteStreamHasYear = metadata.Year.HasValue,
-                RemoteStreamYear = metadata.Year,
-                RemoteStreamHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
-                RemoteStreamArtworkUrl = artworkPath,
-                RemoteStreamGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
-                RemoteStreamHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
-                RemoteStreamContentRating = metadata.ContentRating
-            };
-
-            var scriptObject = new ScriptObject();
-            scriptObject.Import(data);
-            templateContext.PushGlobal(scriptObject);
-
-            return await remoteStreamTemplate.RenderAsync(templateContext);
-        }
-
-        return Option<string>.None;
-    }
-
     private string GetMovieTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "movie.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "movie.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_movie.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate movie XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -986,12 +797,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetEpisodeTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "episode.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "episode.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_episode.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate episode XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1005,12 +820,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetMusicVideoTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "musicVideo.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "musicVideo.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_musicVideo.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate music video XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1024,12 +843,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetSongTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "song.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "song.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_song.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate song XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1043,12 +866,16 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
     private string GetOtherVideoTemplateFileName()
     {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "otherVideo.sbntxt");
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "otherVideo.sbntxt");
+
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_otherVideo.sbntxt");
+        }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate other video XMLTV fragment without template file {File}; please restart ErsatzTV",
@@ -1060,25 +887,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return templateFileName;
     }
 
-    private string GetRemoteStreamTemplateFileName()
-    {
-        string templateFileName = _localFileSystem.GetCustomOrDefaultFile(
-            FileSystemLayout.ChannelGuideTemplatesFolder,
-            "remoteStream.sbntxt");
-
-        // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
-        {
-            _logger.LogError(
-                "Unable to generate remote stream XMLTV fragment without template file {File}; please restart ErsatzTV",
-                templateFileName);
-
-            return null;
-        }
-
-        return templateFileName;
-    }
-
     private static string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
     {
         string artworkPath = artwork.Path;
@@ -1134,8 +942,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 .IfNone("[unknown artist]"),
             OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
                 .IfNone("[unknown video]"),
-            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
-                .IfNone("[unknown remote stream]"),
             _ => "[unknown]"
         };
     }
@@ -1184,7 +990,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
     {
         var result = new List<PlayoutItem>();
 
-        if (_fileSystem.File.Exists(path))
+        if (_localFileSystem.FileExists(path))
         {
             Option<ExternalJsonChannel> maybeChannel = JsonConvert.DeserializeObject<ExternalJsonChannel>(
                 await File.ReadAllTextAsync(path));

ErsatzTV.Application/Channels/Commands/RefreshChannelListHandler.cs

@@ -1,10 +1,8 @@
 using System.Data.Common;
-using System.IO.Abstractions;
 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;
@@ -20,7 +18,6 @@ namespace ErsatzTV.Application.Channels;
 public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly IFileSystem _fileSystem;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RefreshChannelListHandler> _logger;
     private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
@@ -28,13 +25,11 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
     public RefreshChannelListHandler(
         RecyclableMemoryStreamManager recyclableMemoryStreamManager,
         IDbContextFactory<TvContext> dbContextFactory,
-        IFileSystem fileSystem,
         ILocalFileSystem localFileSystem,
         ILogger<RefreshChannelListHandler> logger)
     {
         _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
         _dbContextFactory = dbContextFactory;
-        _fileSystem = fileSystem;
         _localFileSystem = localFileSystem;
         _logger = logger;
     }
@@ -48,13 +43,13 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
         string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "channel.sbntxt");
 
         // fall back to default template
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_channel.sbntxt");
         }
 
         // fail if file doesn't exist
-        if (!_fileSystem.File.Exists(templateFileName))
+        if (!_localFileSystem.FileExists(templateFileName))
         {
             _logger.LogError(
                 "Unable to generate channel list without template file {File}; please restart ErsatzTV",
@@ -82,9 +77,6 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
 
         await foreach (ChannelResult channel in GetChannels(dbContext).WithCancellation(cancellationToken))
         {
-            bool hasLogo = !string.IsNullOrWhiteSpace(channel.ArtworkPath);
-            bool hasExternalLogo = hasLogo && Artwork.IsExternalUrl(channel.ArtworkPath);
-
             var data = new
             {
                 ChannelId = ChannelIdentifier.FromNumber(channel.Number),
@@ -92,8 +84,7 @@ public class RefreshChannelListHandler : IRequestHandler<RefreshChannelList>
                 ChannelNumber = channel.Number,
                 ChannelName = channel.Name,
                 ChannelCategories = GetCategories(channel.Categories),
-                ChannelHasExternalArtwork = hasExternalLogo,
-                ChannelHasArtwork = hasLogo,
+                ChannelHasArtwork = !string.IsNullOrWhiteSpace(channel.ArtworkPath),
                 ChannelArtworkPath = channel.ArtworkPath,
                 ChannelNameEncoded = WebUtility.UrlEncode(channel.Name)
             };
@@ -122,7 +113,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) or C.MirrorSourceChannelId in (select ChannelId from Playout)) and C.IsEnabled = 1 and C.ShowInEPG = 1
+                               where C.Id in (select ChannelId from Playout)
                                order by CAST(C.Number as double)";
         // TODO: this needs to be fixed for sqlite/mariadb
 

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -1,5 +1,4 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
@@ -11,15 +10,10 @@ public record UpdateChannel(
     string Group,
     string Categories,
     int FFmpegProfileId,
-    ArtworkContentTypeModel Logo,
-    ChannelStreamSelectorMode StreamSelectorMode,
-    string StreamSelector,
+    string Logo,
     string PreferredAudioLanguageCode,
     string PreferredAudioTitle,
-    ChannelPlayoutSource PlayoutSource,
-    ChannelPlayoutMode PlayoutMode,
-    int? MirrorSourceChannelId,
-    TimeSpan? PlayoutOffset,
+    ChannelProgressMode ProgressMode,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
@@ -27,8 +21,4 @@ public record UpdateChannel(
     ChannelSubtitleMode SubtitleMode,
     ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
     string MusicVideoCreditsTemplate,
-    ChannelSongVideoMode SongVideoMode,
-    ChannelTranscodeMode TranscodeMode,
-    ChannelIdleBehavior IdleBehavior,
-    bool IsEnabled,
-    bool ShowInEpg) : IRequest<Either<BaseError, ChannelViewModel>>;
+    ChannelSongVideoMode SongVideoMode) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -24,36 +24,17 @@ public class UpdateChannelHandler(
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Channel> validation = await Validate(dbContext, request, cancellationToken);
-        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request, cancellationToken));
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
-    private async Task<ChannelViewModel> ApplyUpdateRequest(
-        TvContext dbContext,
-        Channel c,
-        UpdateChannel update,
-        CancellationToken cancellationToken)
+    private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
     {
-        // don't save mirror when playout exists
-        if (c.Playouts.Count > 0)
-        {
-            update = update with
-            {
-                PlayoutSource = ChannelPlayoutSource.Generated,
-                MirrorSourceChannelId = null
-            };
-        }
-
-        bool hasEpgChange = c.PlayoutSource != update.PlayoutSource || c.ShowInEpg != update.ShowInEpg;
-
         c.Name = update.Name;
         c.Number = update.Number;
-        c.SortNumber = double.Parse(update.Number, CultureInfo.InvariantCulture);
         c.Group = update.Group;
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
-        c.StreamSelectorMode = update.StreamSelectorMode;
-        c.StreamSelector = update.StreamSelector;
         c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
         c.PreferredAudioTitle = update.PreferredAudioTitle;
         c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
@@ -61,177 +42,80 @@ public class UpdateChannelHandler(
         c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
         c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
         c.SongVideoMode = update.SongVideoMode;
-        c.TranscodeMode = update.TranscodeMode;
-        c.IdleBehavior = update.IdleBehavior;
-        c.IsEnabled = update.IsEnabled;
-        c.ShowInEpg = update.IsEnabled && update.ShowInEpg;
-        c.Artwork ??= [];
+        c.Artwork ??= new List<Artwork>();
 
-        if (!string.IsNullOrWhiteSpace(update.Logo?.Path))
+        if (!string.IsNullOrWhiteSpace(update.Logo))
         {
-            string logo = update.Logo.Path;
-            if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
-            {
-                logo = logo.Replace("iptv/logos/", string.Empty);
-            }
+            Option<Artwork> maybeLogo =
+                Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
 
-            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
+            maybeLogo.Match(
+                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);
-            }
+                    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);
+                });
         }
 
-        c.PlayoutSource = update.PlayoutSource;
-        c.PlayoutMode = update.PlayoutMode;
-
-        if (c.PlayoutSource is ChannelPlayoutSource.Mirror)
-        {
-            c.PlayoutMode = ChannelPlayoutMode.Continuous;
-            hasEpgChange |= c.MirrorSourceChannelId != update.MirrorSourceChannelId;
-            hasEpgChange |= c.PlayoutOffset != update.PlayoutOffset;
-        }
-        else
-        {
-            c.MirrorSourceChannelId = null;
-            c.PlayoutOffset = null;
-        }
-
-        c.MirrorSourceChannelId = update.MirrorSourceChannelId;
-        c.PlayoutOffset = update.PlayoutOffset;
+        c.ProgressMode = update.ProgressMode;
         c.StreamingMode = update.StreamingMode;
         c.WatermarkId = update.WatermarkId;
         c.FallbackFillerId = update.FallbackFillerId;
-
-        await dbContext.SaveChangesAsync(cancellationToken);
+        await dbContext.SaveChangesAsync();
 
         searchTargets.SearchTargetsChanged();
 
         if (c.SubtitleMode != ChannelSubtitleMode.None)
         {
             Option<Playout> maybePlayout = await dbContext.Playouts
-                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id, cancellationToken);
+                .SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id);
 
             foreach (Playout playout in maybePlayout)
             {
-                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id), cancellationToken);
+                await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id));
             }
         }
 
-        await workerChannel.WriteAsync(new RefreshChannelList(), cancellationToken);
-        if (hasEpgChange)
-        {
-            await workerChannel.WriteAsync(new RefreshChannelData(c.Number), cancellationToken);
-        }
+        await workerChannel.WriteAsync(new RefreshChannelList());
 
-        return ProjectToViewModel(c, c.Playouts?.Count ?? 0);
+        return ProjectToViewModel(c);
     }
 
-    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),
-            await MirrorSourceMustBeValid(dbContext, request, cancellationToken))
-        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+        (await ChannelMustExist(dbContext, request), ValidateName(request),
+            await ValidateNumber(dbContext, request))
+        .Apply((channelToUpdate, _, _) => channelToUpdate);
 
     private static Task<Validation<BaseError, Channel>> ChannelMustExist(
         TvContext dbContext,
-        UpdateChannel updateChannel,
-        CancellationToken cancellationToken) =>
+        UpdateChannel updateChannel) =>
         dbContext.Channels
             .Include(c => c.Artwork)
             .Include(c => c.Watermark)
-            .Include(c => c.Playouts)
-            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId, cancellationToken)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
             .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
 
-    private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
-        TvContext dbContext,
-        UpdateChannel request,
-        CancellationToken cancellationToken)
-    {
-        if (request.PlayoutSource is not ChannelPlayoutSource.Mirror)
-        {
-            return Unit.Default;
-        }
-
-        Option<Channel> maybeMirrorSource = await dbContext.Channels
-            .AsNoTracking()
-            .SelectOneAsync(
-                c => c.Id == request.MirrorSourceChannelId,
-                c => c.Id == request.MirrorSourceChannelId,
-                cancellationToken);
-
-        if (maybeMirrorSource.IsNone)
-        {
-            return BaseError.New("Mirror source channel does not exist.");
-        }
-
-        foreach (var mirrorSource in maybeMirrorSource)
-        {
-            if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
-            {
-                return BaseError.New(
-                    $"Mirror source channel {mirrorSource.Name} must use generated playout source");
-            }
-        }
-
-        foreach (TimeSpan playoutOffset in Optional(request.PlayoutOffset))
-        {
-            if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
-            {
-                return BaseError.New("Playout offset must not be greater than 12 hours");
-            }
-        }
-
-        return Unit.Default;
-    }
-
     private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
         updateChannel.NotEmpty(c => c.Name)
             .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
 
     private static async Task<Validation<BaseError, string>> ValidateNumber(
         TvContext dbContext,
-        UpdateChannel updateChannel,
-        CancellationToken cancellationToken)
+        UpdateChannel updateChannel)
     {
         int matchId = await dbContext.Channels
-            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number, cancellationToken)
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
             .Match(c => c.Id, () => updateChannel.ChannelId);
 
         if (matchId == updateChannel.ChannelId)

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbers.cs

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

ErsatzTV.Application/Channels/Commands/UpdateChannelNumbersHandler.cs

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

ErsatzTV.Application/Channels/Mapper.cs

@@ -1,12 +1,11 @@
-using ErsatzTV.Application.Artworks;
-using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Channels;
 
 internal static class Mapper
 {
-    internal static ChannelViewModel ProjectToViewModel(Channel channel, int playoutCount) =>
+    internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
         new(
             channel.Id,
             channel.Number,
@@ -15,27 +14,18 @@ internal static class Mapper
             channel.Categories,
             channel.FFmpegProfileId,
             GetLogo(channel),
-            channel.StreamSelectorMode,
-            channel.StreamSelector,
             channel.PreferredAudioLanguageCode,
             channel.PreferredAudioTitle,
-            channel.PlayoutSource,
-            channel.PlayoutMode,
-            channel.MirrorSourceChannelId,
-            channel.PlayoutOffset,
+            channel.ProgressMode,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
-            playoutCount,
+            channel.Playouts?.Count ?? 0,
             channel.PreferredSubtitleLanguageCode,
             channel.SubtitleMode,
             channel.MusicVideoCreditsMode,
             channel.MusicVideoCreditsTemplate,
-            channel.SongVideoMode,
-            channel.TranscodeMode,
-            channel.IdleBehavior,
-            channel.IsEnabled,
-            channel.ShowInEpg);
+            channel.SongVideoMode);
 
     internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
         new(
@@ -49,30 +39,12 @@ internal static class Mapper
     internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
         new(resolution.Height, resolution.Width);
 
-    internal static ChannelStreamingSpecsViewModel ProjectToSpecsViewModel(Channel channel) =>
-        new(
-            channel.FFmpegProfile.Resolution.Height,
-            channel.FFmpegProfile.Resolution.Width,
-            (int)((channel.FFmpegProfile.VideoBitrate * 1000 + channel.FFmpegProfile.AudioBitrate * 1000) * 1.2),
-            channel.FFmpegProfile.VideoFormat,
-            channel.FFmpegProfile.VideoProfile,
-            channel.FFmpegProfile.AudioFormat);
+    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 GetLogo(Channel channel) =>
+        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+            .Match(a => a.Path, string.Empty);
 
     private static string GetStreamingMode(Channel channel) =>
         channel.StreamingMode switch
@@ -81,6 +53,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/GetAllChannels.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForApiHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSort.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsForSortHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs

@@ -1,31 +1,14 @@
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Channels.Mapper;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetAllChannelsHandler(IChannelRepository channelRepository)
-    : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
+public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
 {
+    private readonly IChannelRepository _channelRepository;
+
+    public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+
     public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-        await channelRepository.GetAll(cancellationToken)
-            .Map(list => list.Where(c => c.IsEnabled || request.ShowDisabled)
-                .Map(c => ProjectToViewModel(c, GetPlayoutsCount(c))).ToList());
-
-    private static int GetPlayoutsCount(Channel channel)
-    {
-        var result = 0;
-
-        if (channel.Playouts != null)
-        {
-            result += channel.Playouts.Count;
-        }
-
-        if (channel.PlayoutSource is ChannelPlayoutSource.Mirror && channel.MirrorSourceChannel?.Playouts != null)
-        {
-            result += channel.MirrorSourceChannel.Playouts.Count;
-        }
-
-        return result;
-    }
+        Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
 }

ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs

@@ -3,10 +3,13 @@ using static ErsatzTV.Application.Channels.Mapper;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelByIdHandler(IChannelRepository channelRepository)
-    : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
+public class GetChannelByIdHandler : 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)
-            .MapT(c => ProjectToViewModel(c, 0));
+        _channelRepository.GetChannel(request.Id)
+            .MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Channels/Queries/GetChannelByNumberHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutId.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelByPlayoutIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -1,118 +1,123 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
-using ErsatzTV.FFmpeg;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelFramerateHandler(
-    IDbContextFactory<TvContext> dbContextFactory,
-    ILogger<GetChannelFramerateHandler> logger)
-    : IRequestHandler<GetChannelFramerate, Option<FrameRate>>
+public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, Option<int>>
 {
-    public async Task<Option<FrameRate>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ILogger<GetChannelFramerateHandler> _logger;
+
+    public GetChannelFramerateHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILogger<GetChannelFramerateHandler> logger)
     {
-        try
+        _dbContextFactory = dbContextFactory;
+        _logger = logger;
+    }
+
+    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)
         {
-            await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+            return Option<int>.None;
+        }
 
-            FFmpegProfile ffmpegProfile = await dbContext.Channels
-                .AsNoTracking()
-                .Filter(c => c.Number == request.ChannelNumber)
-                .Include(c => c.FFmpegProfile)
-                .Map(c => c.FFmpegProfile)
-                .SingleAsync(cancellationToken);
+        // TODO: expand to check everything in collection rather than what's scheduled?
+        _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
 
-            if (!ffmpegProfile.NormalizeFramerate)
+        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)
             {
-                return Option<FrameRate>.None;
-            }
-
-            // TODO: expand to check everything in collection rather than what's scheduled?
-            logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
-
-            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 => new FrameRate(mv.RFrameRate))
-                .ToList();
-
-            var distinct = frameRates.Distinct().ToList();
-            if (distinct.Count > 1)
-            {
-                // TODO: something more intelligent than minimum framerate?
-                var validFrameRates = frameRates.Where(fr => fr.ParsedFrameRate > 23).ToList();
-                if (validFrameRates.Count > 0)
-                {
-                    FrameRate result = validFrameRates.MinBy(fr => fr.ParsedFrameRate);
-                    logger.LogInformation(
-                        "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
-                        request.ChannelNumber,
-                        distinct.Map(fr => fr.RFrameRate),
-                        result.RFrameRate);
-                    return result;
-                }
-
-                FrameRate minFrameRate = frameRates.MinBy(fr => fr.ParsedFrameRate);
-                logger.LogInformation(
+                _logger.LogInformation(
                     "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate} instead of min value {MinFrameRate}",
                     request.ChannelNumber,
-                    distinct.Map(fr => fr.RFrameRate),
-                    FrameRate.DefaultFrameRate.RFrameRate,
-                    minFrameRate.RFrameRate);
+                    distinct,
+                    24,
+                    result);
 
-                return FrameRate.DefaultFrameRate;
+                return 24;
             }
 
-            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].RFrameRate);
-            }
-            else
-            {
-                logger.LogInformation(
-                    "No content on channel {ChannelNumber} has frame rate information; will not normalize",
-                    request.ChannelNumber);
-            }
+            _logger.LogInformation(
+                "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
+                request.ChannelNumber,
+                distinct,
+                result);
+            return result;
         }
-        catch (Exception ex)
+
+        if (distinct.Count != 0)
         {
-            logger.LogWarning(
-                ex,
-                "Unexpected error checking frame rates on channel {ChannelNumber}",
+            _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);
         }
 
         return None;
     }
+
+    private int ParseFrameRate(string frameRate)
+    {
+        if (!int.TryParse(frameRate, out int fr))
+        {
+            string[] split = (frameRate ?? string.Empty).Split("/");
+            if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
+            {
+                fr = (int)Math.Round(left / (double)right);
+            }
+            else
+            {
+                fr = 24;
+            }
+        }
+
+        return fr;
+    }
 }

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelNameByPlayoutIdHandler.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -4,36 +4,40 @@ using ErsatzTV.Core.Iptv;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelPlaylistHandler(IChannelRepository channelRepository)
-    : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
+public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
 {
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
+        _channelRepository = channelRepository;
+
     public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
-        channelRepository.GetAll(cancellationToken)
+        _channelRepository.GetAll()
             .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

@@ -5,11 +5,11 @@ using Microsoft.EntityFrameworkCore;
 
 namespace ErsatzTV.Application.Channels;
 
-public class GetChannelStreamingSpecsHandler(IDbContextFactory<TvContext> dbContextFactory)
-    : IRequestHandler<GetChannelStreamingSpecs, Option<ChannelStreamingSpecsViewModel>>
+public class GetChannelResolutionAndBitrateHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetChannelResolutionAndBitrate, Option<ResolutionAndBitrateViewModel>>
 {
-    public async Task<Option<ChannelStreamingSpecsViewModel>> Handle(
-        GetChannelStreamingSpecs request,
+    public async Task<Option<ResolutionAndBitrateViewModel>> Handle(
+        GetChannelResolutionAndBitrate request,
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
@@ -18,8 +18,10 @@ public class GetChannelStreamingSpecsHandler(IDbContextFactory<TvContext> dbCont
             .AsNoTracking()
             .Include(c => c.FFmpegProfile)
             .ThenInclude(ff => ff.Resolution)
-            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber, cancellationToken);
+            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber);
 
-        return maybeChannel.Map(Mapper.ProjectToSpecsViewModel);
+        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

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

ErsatzTV.Application/Channels/Queries/GetChannelStreamSelectorsHandler.cs

@@ -1,14 +0,0 @@
-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/Queries/GetChannelStreamingSpecs.cs

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

ErsatzTV.Application/Channels/ResolutionAndBitrateViewModel.cs

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

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, cancellationToken);
+        await _configElementRepository.Upsert(request.Key, request.Value);
 }

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -4,12 +4,12 @@ using ErsatzTV.Core.Interfaces.Repositories;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class UpdateLoggingSettingsHandler : IRequestHandler<UpdateLoggingSettings, Either<BaseError, Unit>>
+public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSettings, Either<BaseError, Unit>>
 {
     private readonly IConfigElementRepository _configElementRepository;
     private readonly LoggingLevelSwitches _loggingLevelSwitches;
 
-    public UpdateLoggingSettingsHandler(
+    public UpdateGeneralSettingsHandler(
         LoggingLevelSwitches loggingLevelSwitches,
         IConfigElementRepository configElementRepository)
     {
@@ -18,38 +18,33 @@ public class UpdateLoggingSettingsHandler : IRequestHandler<UpdateLoggingSetting
     }
 
     public async Task<Either<BaseError, Unit>> Handle(
-        UpdateLoggingSettings request,
-        CancellationToken cancellationToken) => await ApplyUpdate(request.LoggingSettings, cancellationToken);
+        UpdateGeneralSettings request,
+        CancellationToken cancellationToken) => await ApplyUpdate(request.GeneralSettings);
 
-    private async Task<Unit> ApplyUpdate(LoggingSettingsViewModel loggingSettings, CancellationToken cancellationToken)
+    private async Task<Unit> ApplyUpdate(GeneralSettingsViewModel generalSettings)
     {
-        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, loggingSettings.DefaultMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = loggingSettings.DefaultMinimumLogLevel;
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.DefaultMinimumLogLevel);
+        _loggingLevelSwitches.DefaultLevelSwitch.MinimumLevel = generalSettings.DefaultMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelScanning,
-            loggingSettings.ScanningMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = loggingSettings.ScanningMinimumLogLevel;
+            generalSettings.ScanningMinimumLogLevel);
+        _loggingLevelSwitches.ScanningLevelSwitch.MinimumLevel = generalSettings.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;
+            generalSettings.SchedulingMinimumLogLevel);
+        _loggingLevelSwitches.SchedulingLevelSwitch.MinimumLevel = generalSettings.SchedulingMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelStreaming,
-            loggingSettings.StreamingMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = loggingSettings.StreamingMinimumLogLevel;
+            generalSettings.StreamingMinimumLogLevel);
+        _loggingLevelSwitches.StreamingLevelSwitch.MinimumLevel = generalSettings.StreamingMinimumLogLevel;
 
         await _configElementRepository.Upsert(
             ConfigElementKey.MinimumLogLevelHttp,
-            loggingSettings.HttpMinimumLogLevel, cancellationToken);
-        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = loggingSettings.HttpMinimumLogLevel;
+            generalSettings.HttpMinimumLogLevel);
+        _loggingLevelSwitches.HttpLevelSwitch.MinimumLevel = generalSettings.HttpMinimumLogLevel;
 
         return Unit.Default;
     }

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -16,16 +16,16 @@ public class UpdateLibraryRefreshIntervalHandler :
         UpdateLibraryRefreshInterval request,
         CancellationToken cancellationToken) =>
         Validate(request)
-            .MapT(_ => _configElementRepository.Upsert(
-                ConfigElementKey.LibraryRefreshInterval,
-                request.LibraryRefreshInterval,
-                cancellationToken))
+            .MapT(
+                _ => _configElementRepository.Upsert(
+                    ConfigElementKey.LibraryRefreshInterval,
+                    request.LibraryRefreshInterval))
             .Bind(v => v.ToEitherAsync());
 
     private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
         Optional(request.LibraryRefreshInterval)
             .Where(lri => lri is >= 0 and < 1_000_000)
             .Map(_ => Unit.Default)
-            .ToValidation<BaseError>("Library refresh interval must be zero or greater")
+            .ToValidation<BaseError>("Library refresh interval must be zero or greated")
             .AsTask();
 }

ErsatzTV.Application/Configuration/Commands/UpdateLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdatePlayoutSettingsHandler.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateXmltvSettingsHandler.cs

@@ -20,7 +20,7 @@ public class UpdateXmltvSettingsHandler(
     {
         int playoutDaysToBuild =
             await configElementRepository
-                .GetValue<int>(ConfigElementKey.PlayoutDaysToBuild, cancellationToken)
+                .GetValue<int>(ConfigElementKey.PlayoutDaysToBuild)
                 .IfNoneAsync(2);
 
         if (playoutDaysToBuild < request.XmltvSettings.DaysToBuild)
@@ -29,20 +29,19 @@ public class UpdateXmltvSettingsHandler(
                 $"XMLTV days to build ({request.XmltvSettings.DaysToBuild}) cannot be greater than Playout days to build ({playoutDaysToBuild})");
         }
 
-        return await ApplyUpdate(request.XmltvSettings, cancellationToken);
+        return await ApplyUpdate(request.XmltvSettings);
     }
 
-    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings, CancellationToken cancellationToken)
+    private async Task<Unit> ApplyUpdate(XmltvSettingsViewModel xmltvSettings)
     {
-        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 configElementRepository.Upsert(ConfigElementKey.XmltvTimeZone, xmltvSettings.TimeZone);
+        await configElementRepository.Upsert(ConfigElementKey.XmltvDaysToBuild, xmltvSettings.DaysToBuild);
 
-        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync();
 
-        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync(cancellationToken))
+        foreach (string channelNumber in await dbContext.Channels.Map(c => c.Number).ToListAsync())
         {
-            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber), cancellationToken);
+            await workerChannel.WriteAsync(new RefreshChannelData(channelNumber));
         }
 
         return Unit.Default;

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

@@ -2,12 +2,11 @@ using Serilog.Events;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class LoggingSettingsViewModel
+public class GeneralSettingsViewModel
 {
     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/PlayoutSettingsViewModel.cs

@@ -4,5 +4,4 @@ public class PlayoutSettingsViewModel
 {
     public int DaysToBuild { get; set; }
     public bool SkipMissingItems { get; set; }
-    public int ScriptedScheduleTimeoutSeconds { 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, cancellationToken).MapT(ProjectToViewModel);
+        _configElementRepository.GetConfigElement(request.Key).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -4,49 +4,35 @@ using Serilog.Events;
 
 namespace ErsatzTV.Application.Configuration;
 
-public class GetLoggingSettingsHandler : IRequestHandler<GetLoggingSettings, LoggingSettingsViewModel>
+public class GetGeneralSettingsHandler : IRequestHandler<GetGeneralSettings, GeneralSettingsViewModel>
 {
     private readonly IConfigElementRepository _configElementRepository;
 
-    public GetLoggingSettingsHandler(IConfigElementRepository configElementRepository) =>
+    public GetGeneralSettingsHandler(IConfigElementRepository configElementRepository) =>
         _configElementRepository = configElementRepository;
 
-    public async Task<LoggingSettingsViewModel> Handle(GetLoggingSettings request, CancellationToken cancellationToken)
+    public async Task<GeneralSettingsViewModel> Handle(GetGeneralSettings request, CancellationToken cancellationToken)
     {
         Option<LogEventLevel> maybeDefaultLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel, cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
 
         Option<LogEventLevel> maybeScanningLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelScanning,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScanning);
 
         Option<LogEventLevel> maybeSchedulingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelScheduling,
-                cancellationToken);
-
-        Option<LogEventLevel> maybeSearchingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelSearching,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelScheduling);
 
         Option<LogEventLevel> maybeStreamingLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelStreaming,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelStreaming);
 
         Option<LogEventLevel> maybeHttpLevel =
-            await _configElementRepository.GetValue<LogEventLevel>(
-                ConfigElementKey.MinimumLogLevelHttp,
-                cancellationToken);
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevelHttp);
 
-        return new LoggingSettingsViewModel
+        return new GeneralSettingsViewModel
         {
             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/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, cancellationToken)
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
             .Map(result => result.IfNone(6));
 }

ErsatzTV.Application/Configuration/Queries/GetLoggingSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetMpegTsScripts.cs

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

ErsatzTV.Application/Configuration/Queries/GetMpegTsScriptsHandler.cs

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

ErsatzTV.Application/Configuration/Queries/GetPlayoutSettingsHandler.cs

@@ -12,23 +12,15 @@ public class GetPlayoutSettingsHandler : IRequestHandler<GetPlayoutSettings, Pla
 
     public async Task<PlayoutSettingsViewModel> Handle(GetPlayoutSettings request, CancellationToken cancellationToken)
     {
-        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(
-            ConfigElementKey.PlayoutDaysToBuild,
-            cancellationToken);
+        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild);
 
         Option<bool> skipMissingItems =
-            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems, cancellationToken);
-
-        Option<int> scriptedScheduleTimeoutSeconds =
-            await _configElementRepository.GetValue<int>(
-                ConfigElementKey.PlayoutScriptedScheduleTimeoutSeconds,
-                cancellationToken);
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.PlayoutSkipMissingItems);
 
         return new PlayoutSettingsViewModel
         {
             DaysToBuild = await daysToBuild.IfNoneAsync(2),
-            SkipMissingItems = await skipMissingItems.IfNoneAsync(false),
-            ScriptedScheduleTimeoutSeconds = await scriptedScheduleTimeoutSeconds.IfNoneAsync(30)
+            SkipMissingItems = await skipMissingItems.IfNoneAsync(false)
         };
     }
 }

ErsatzTV.Application/Configuration/Queries/GetXmltvSettingsHandler.cs

@@ -8,23 +8,15 @@ public class GetXmltvSettingsHandler(IConfigElementRepository configElementRepos
 {
     public async Task<XmltvSettingsViewModel> Handle(GetXmltvSettings request, CancellationToken cancellationToken)
     {
-        Option<int> daysToBuild = await configElementRepository.GetValue<int>(
-            ConfigElementKey.XmltvDaysToBuild,
-            cancellationToken);
+        Option<int> daysToBuild = await configElementRepository.GetValue<int>(ConfigElementKey.XmltvDaysToBuild);
 
         Option<XmltvTimeZone> maybeTimeZone =
-            await configElementRepository.GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken);
-
-        Option<XmltvBlockBehavior> maybeBlockBehavior =
-            await configElementRepository.GetValue<XmltvBlockBehavior>(
-                ConfigElementKey.XmltvBlockBehavior,
-                cancellationToken);
+            await configElementRepository.GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone);
 
         return new XmltvSettingsViewModel
         {
             DaysToBuild = await daysToBuild.IfNoneAsync(2),
-            TimeZone = await maybeTimeZone.IfNoneAsync(XmltvTimeZone.Local),
-            BlockBehavior = await maybeBlockBehavior.IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly)
+            TimeZone = await maybeTimeZone.IfNoneAsync(XmltvTimeZone.Local)
         };
     }
 }

ErsatzTV.Application/Configuration/XmltvBlockBehavior.cs

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

ErsatzTV.Application/Configuration/XmltvSettingsViewModel.cs

@@ -4,5 +4,4 @@ public class XmltvSettingsViewModel
 {
     public int DaysToBuild { get; set; }
     public XmltvTimeZone TimeZone { get; set; }
-    public XmltvBlockBehavior BlockBehavior { get; set; }
 }

ErsatzTV.Application/Emby/Commands/CallEmbyCollectionScannerHandler.cs

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

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

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

ErsatzTV.Application/Emby/Commands/CallEmbyShowScannerHandler.cs

@@ -1,97 +0,0 @@
-using System.Globalization;
-using ErsatzTV.Application.Libraries;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.FFmpeg.Runtime;
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-
-namespace ErsatzTV.Application.Emby;
-
-public class CallEmbyShowScannerHandler : CallLibraryScannerHandler<SynchronizeEmbyShowById>,
-    IRequestHandler<SynchronizeEmbyShowById, Either<BaseError, string>>
-{
-    private readonly IScannerProxyService _scannerProxyService;
-
-    public CallEmbyShowScannerHandler(
-        IDbContextFactory<TvContext> dbContextFactory,
-        IConfigElementRepository configElementRepository,
-        IScannerProxyService scannerProxyService,
-        IRuntimeInfo runtimeInfo,
-        ILogger<CallEmbyShowScannerHandler> logger)
-        : base(dbContextFactory, configElementRepository, runtimeInfo, logger)
-    {
-        _scannerProxyService = scannerProxyService;
-    }
-
-    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, ScanParameters> validation = await Validate(request, cancellationToken);
-        return await validation.Match(
-            parameters => PerformScan(parameters, 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(
-        ScanParameters parameters,
-        SynchronizeEmbyShowById request,
-        CancellationToken cancellationToken)
-    {
-        Option<Guid> maybeScanId = _scannerProxyService.StartScan(request.EmbyLibraryId);
-        foreach (var scanId in maybeScanId)
-        {
-            try
-            {
-                var arguments = new List<string>
-                {
-                    "scan-emby-show",
-                    request.EmbyLibraryId.ToString(CultureInfo.InvariantCulture),
-                    request.ShowId.ToString(CultureInfo.InvariantCulture),
-                    GetBaseUrl(scanId)
-                };
-
-                if (request.DeepScan)
-                {
-                    arguments.Add("--deep");
-                }
-
-                return await base.PerformScan(parameters, arguments, cancellationToken);
-            }
-            finally
-            {
-                _scannerProxyService.EndScan(scanId);
-            }
-        }
-
-        return BaseError.New($"Library {request.EmbyLibraryId} is already scanning");
-    }
-
-    protected override Task<Tuple<string, DateTimeOffset>> GetLastScan(
-        TvContext dbContext,
-        SynchronizeEmbyShowById request,
-        CancellationToken cancellationToken) =>
-        Task.FromResult(new Tuple<string, DateTimeOffset>(string.Empty, DateTimeOffset.MinValue));
-
-    protected override bool ScanIsRequired(
-        DateTimeOffset lastScan,
-        int libraryRefreshInterval,
-        SynchronizeEmbyShowById request) =>
-        true;
-}

ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs

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

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyShowById.cs

@@ -1,6 +0,0 @@
-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/UpdateEmbyLibraryPreferencesHandler.cs

@@ -23,7 +23,7 @@ public class
         UpdateEmbyLibraryPreferences request,
         CancellationToken cancellationToken)
     {
-        var toDisable = request.Preferences.Filter(p => !p.ShouldSyncItems).Map(p => p.Id).ToList();
+        var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).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, cancellationToken)
+        Validate(request)
             .MapT(pms => MergePathReplacements(request, pms))
             .Bind(v => v.ToEitherAsync());
 
@@ -37,12 +37,13 @@ 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, CancellationToken cancellationToken) =>
-        EmbyMediaSourceMustExist(request, cancellationToken);
+    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
+        EmbyMediaSourceMustExist(request);
 
     private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-        UpdateEmbyPathReplacements request, CancellationToken cancellationToken) =>
-        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId, cancellationToken)
-            .Map(v => v.ToValidation<BaseError>(
-                $"Emby media source {request.EmbyMediaSourceId} does not exist."));
+        UpdateEmbyPathReplacements request) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Emby media source {request.EmbyMediaSourceId} does not exist."));
 }

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(cancellationToken).Map(list => list.Map(ProjectToViewModel).ToList());
+        _mediaSourceRepository.GetAllEmby().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(cancellationToken)
+            await Validate()
                 .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(CancellationToken cancellationToken) =>
-        EmbyMediaSourceMustExist(cancellationToken)
+    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+        EmbyMediaSourceMustExist()
             .BindT(MediaSourceMustHaveActiveConnection)
             .BindT(MediaSourceMustHaveApiKey);
 
-    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 Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
+        _mediaSourceRepository.GetAllEmby().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, cancellationToken).MapT(ProjectToViewModel);
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
 }

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,30 +1,33 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net10.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
         <AnalysisLevel>latest-Recommended</AnalysisLevel>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-        <Configurations>Debug;Release;Debug No Sync</Configurations>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Bugsnag" Version="4.1.0" />
-        <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="Humanizer.Core" Version="3.0.1" />
-        <PackageReference Include="MediatR" Version="[12.5.0]" />
-        <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.2" />
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
-        <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="4.0.0" />
-        <PackageReference Include="WebMarkupMin.Core" Version="2.20.1" />
-        <PackageReference Include="Winista.MimeDetect" Version="1.1.0" />
+      <PackageReference Include="Bugsnag" Version="4.0.0" />
+      <PackageReference Include="CliWrap" Version="3.8.2" />
+      <PackageReference Include="Humanizer.Core" Version="2.14.1" />
+      <PackageReference Include="MediatR" Version="12.5.0" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.4" />
+      <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.1" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.13.61">
+        <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.17.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,6 +1,5 @@
 <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>
@@ -9,11 +8,8 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=emby_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Cqueries/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpeg_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Cqueries/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=graphics_005Ccommands/@EntryIndexedValue">True</s:Boolean>
-	<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>
@@ -48,7 +44,5 @@
 	<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/FFmpeg/Commands/RefreshFFmpegCapabilities.cs

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

ErsatzTV.Application/FFmpeg/Commands/RefreshFFmpegCapabilitiesHandler.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -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, cancellationToken);
+        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
         return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
     }
 
@@ -40,68 +40,35 @@ public class CreateFFmpegProfileHandler :
 
     private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
         TvContext dbContext,
-        CreateFFmpegProfile request,
-        CancellationToken cancellationToken) =>
-        (ValidateName(request), ValidateThreadCount(request),
-            await ResolutionMustExist(dbContext, request, cancellationToken))
-        .Apply((name, threadCount, resolutionId) =>
-        {
-            var hwAccel = request.NormalizeVideo
-                ? request.HardwareAcceleration
-                : HardwareAccelerationKind.None;
-
-            return new FFmpegProfile
+        CreateFFmpegProfile request) =>
+        (ValidateName(request), ValidateThreadCount(request), await ResolutionMustExist(dbContext, request))
+        .Apply(
+            (name, threadCount, resolutionId) => new FFmpegProfile
             {
                 Name = name,
                 ThreadCount = threadCount,
-
-                NormalizeAudio = request.NormalizeAudio,
-                NormalizeVideo = request.NormalizeVideo,
-
-                HardwareAcceleration = hwAccel,
+                HardwareAcceleration = request.HardwareAcceleration,
                 VaapiDriver = request.VaapiDriver,
                 VaapiDevice = request.VaapiDevice,
                 QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
                 ResolutionId = resolutionId,
                 ScalingBehavior = request.ScalingBehavior,
-
-                // only allow customization with VAAPI accel
-                PadMode = hwAccel switch
-                {
-                    HardwareAccelerationKind.None => FilterMode.Software,
-                    HardwareAccelerationKind.Vaapi => request.PadMode,
-                    _ => FilterMode.HardwareIfPossible
-                },
-
-                VideoFormat = request.NormalizeVideo ? request.VideoFormat : FFmpegProfileVideoFormat.Copy,
+                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,
-
+                BitDepth = request.BitDepth,
                 VideoBitrate = request.VideoBitrate,
                 VideoBufferSize = request.VideoBufferSize,
-                TonemapAlgorithm = request.TonemapAlgorithm,
-                AudioFormat = request.NormalizeAudio ? request.AudioFormat : FFmpegProfileAudioFormat.Copy,
+                AudioFormat = request.AudioFormat,
                 AudioBitrate = request.AudioBitrate,
                 AudioBufferSize = request.AudioBufferSize,
-
                 NormalizeLoudnessMode = request.NormalizeLoudnessMode,
-                TargetLoudness = request.NormalizeLoudnessMode is NormalizeLoudnessMode.LoudNorm
-                    ? request.TargetLoudness
-                    : null,
-
                 AudioChannels = request.AudioChannels,
                 AudioSampleRate = request.AudioSampleRate,
                 NormalizeFramerate = request.NormalizeFramerate,
-                NormalizeColors = request.NormalizeColors,
                 DeinterlaceVideo = request.DeinterlaceVideo
-            };
-        });
+            });
 
     private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
         createFFmpegProfile.NotEmpty(x => x.Name)
@@ -112,10 +79,9 @@ public class CreateFFmpegProfileHandler :
 
     private static Task<Validation<BaseError, int>> ResolutionMustExist(
         TvContext dbContext,
-        CreateFFmpegProfile createFFmpegProfile,
-        CancellationToken cancellationToken) =>
+        CreateFFmpegProfile createFFmpegProfile) =>
         dbContext.Resolutions
-            .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId, cancellationToken)
+            .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId)
             .MapT(r => r.Id)
             .Map(o => o.ToValidation<BaseError>($"[Resolution] {createFFmpegProfile.ResolutionId} does not exist"));
 }

ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/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, cancellationToken)
+            .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId)
             .IfNoneAsync(0);
 
         List<Resolution> allResolutions = await dbContext.Resolutions