update changelog for release v0.3.1-alpha [no ci]

.github/dependabot.yml

@@ -6,21 +6,3 @@ updates:
       interval: daily
     assignees:
       - jasongdove
-  - package-ecosystem: docker
-    directory: "/docker"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove
-  - package-ecosystem: docker
-    directory: "/docker/nvidia"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove
-  - package-ecosystem: docker
-    directory: "/docker/vaapi"
-    schedule:
-      interval: daily
-    assignees:
-      - jasongdove

.github/workflows/artifacts.yml

@@ -1,235 +0,0 @@
-name: Build Artifacts
-on:
-  workflow_call:
-    inputs:
-      release_tag:
-        description: 'Release tag'
-        required: true
-        type: string
-      release_version:
-        description: 'Release version number (e.g. v0.3.7-alpha)'
-        required: true
-        type: string
-      info_version:
-        description: 'Informational version number (e.g. 0.3.7-alpha)'
-        required: true
-        type: string
-    secrets:
-      apple_developer_certificate_p12_base64:
-        required: true
-      apple_developer_certificate_password:
-        required: true
-      ac_username:
-        required: true
-      ac_password:
-        required: true
-      gh_token:
-        required: true
-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-latest
-            kind: macOS
-            target: osx-x64
-          - os: macos-latest
-            kind: macOS
-            target: osx-arm64
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-          submodules: true
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 6.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "${{ matrix.target}}"
-
-      - name: Import Code-Signing Certificates
-        uses: Apple-Actions/import-codesign-certs@v1
-        with:
-          p12-file-base64: ${{ secrets.apple_developer_certificate_p12_base64 }}
-          p12-password: ${{ secrets.apple_developer_certificate_password }}
-
-      - name: Calculate Release Name
-        shell: bash
-        run: |
-          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-
-      - name: Build
-        shell: bash
-        run: dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o publish -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-      - name: Bundle
-        shell: bash
-        run: |
-          brew install coreutils
-          plutil -replace CFBundleShortVersionString -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
-          plutil -replace CFBundleVersion -string "${{ inputs.info_version }}" ErsatzTV-macOS/ErsatzTV-macOS/Info.plist
-          scripts/macOS/bundle.sh
-
-      - name: Sign
-        shell: bash
-        run: scripts/macOS/sign.sh
-      
-      - name: Create DMG
-        shell: bash
-        run: |
-          brew install create-dmg
-          create-dmg \
-            --volname "ErsatzTV" \
-            --volicon "artwork/ErsatzTV.icns" \
-            --window-pos 200 120 \
-            --window-size 800 400 \
-            --icon-size 100 \
-            --icon "ErsatzTV.app" 200 190 \
-            --hide-extension "ErsatzTV.app" \
-            --app-drop-link 600 185 \
-            "ErsatzTV.dmg" \
-            "ErsatzTV.app/"
-
-      - name: Notarize
-        shell: bash
-        run: |
-          brew tap mitchellh/gon
-          brew install mitchellh/gon/gon
-          gon -log-level=debug -log-json ./gon.json
-        env:
-          AC_USERNAME: ${{ secrets.ac_username }}
-          AC_PASSWORD: ${{ secrets.ac_password }}
-
-      - name: Cleanup
-        shell: bash
-        run: |
-          mv ErsatzTV.dmg "${{ env.RELEASE_NAME }}.dmg"
-          rm -r publish
-          rm -r ErsatzTV.app
-
-      - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
-        with:
-          token: ${{ secrets.gh_token }}
-          tag: ${{ inputs.release_tag }}
-          fail-if-no-assets: false
-          assets: |
-            *${{ matrix.target }}.dmg
-
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: true
-          tag_name: ${{ inputs.release_tag }}
-          files: |
-            ${{ env.RELEASE_NAME }}.dmg
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}
-  build_and_upload:
-    name: Build & Upload
-    runs-on: ${{ matrix.os }}
-    if: contains(github.event.head_commit.message, '[no build]') == false
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-x64
-          - os: ubuntu-latest
-            kind: linux
-            target: linux-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@v2
-        with:
-          fetch-depth: 0
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 6.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore -r "${{ matrix.target}}"
-
-      - uses: suisei-cn/actions-download-file@v1
-        if: ${{ matrix.kind }} == "windows"
-        id: downloadffmpeg
-        name: Download ffmpeg
-        with:
-          url: "https://github.com/GyanD/codexffmpeg/releases/download/5.0/ffmpeg-5.0-full_build.7z"
-          target: ffmpeg/
-
-      - name: Build
-        shell: bash
-        run: |
-          # Define some variables for things we need
-          release_name="ErsatzTV-${{ inputs.release_version }}-${{ matrix.target }}"
-          echo "RELEASE_NAME=${release_name}" >> $GITHUB_ENV
-
-          # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-
-          # Build Windows launcher
-          if [ "${{ matrix.kind }}" == "windows" ]; then
-            dotnet publish ErsatzTV-Windows/ErsatzTV-Windows.csproj --framework net6.0-windows --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
-          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"
-        env:
-          AC_USERNAME: ${{ secrets.ac_username }}
-          AC_PASSWORD: ${{ secrets.ac_password }}
-
-      - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
-        with:
-          token: ${{ secrets.gh_token }}
-          tag: ${{ inputs.release_tag }}
-          fail-if-no-assets: false
-          assets: |
-            *${{ matrix.target }}.zip
-            *${{ matrix.target }}.tar.gz
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        with:
-          prerelease: true
-          tag_name: ${{ inputs.release_tag }}
-          files: |
-            ${{ env.RELEASE_NAME }}.zip
-            ${{ env.RELEASE_NAME }}.tar.gz
-        env:
-          GITHUB_TOKEN: ${{ secrets.gh_token }}

.github/workflows/ci.yml

@@ -1,19 +1,49 @@
 name: Build
 on:
   workflow_dispatch:
+  pull_request:
   push:
     branches:
       - main
 jobs:
-  calculate_version:
-    name: Calculate version information
-    runs-on: ubuntu-latest
+  build_and_test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ windows-latest, ubuntu-latest, macos-latest ]
     steps:
       - name: Get the sources
         uses: actions/checkout@v2
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+  build_and_push:
+    name: Build & Publish to Docker Hub
+    needs: build_and_test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && !contains(github.event.head_commit.message, '[no docker]')
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Extract Docker Tag
+
+      - name: Extract Git Tag
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
@@ -21,38 +51,60 @@ jobs:
           short=$(git rev-parse --short HEAD)
           final="${tag2/alpha/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
-      - name: Extract Artifacts Version
-        shell: bash
-        run: |
-          tag=$(git describe --tags --abbrev=0)
-          short=$(git rev-parse --short HEAD)
-          final="${tag/alpha/$short}"
-          echo "ARTIFACTS_VERSION=${final}" >> $GITHUB_ENV
-          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
-    outputs:
-      git_tag: ${{ env.GIT_TAG }}
-      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
-      info_version: ${{ env.INFO_VERSION }}
-  build_and_upload:
-    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
-    needs: calculate_version
-    with:
-      release_tag: develop
-      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
-      info_version: ${{ needs.calculate_version.outputs.info_version }}
-    secrets:
-      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
-      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
-      ac_username: ${{ secrets.AC_USERNAME }}
-      ac_password: ${{ secrets.AC_PASSWORD }}
-      gh_token: ${{ secrets.GITHUB_TOKEN }}
-  build_and_push:
-    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
-    needs: calculate_version
-    with:
-      base_version: develop
-      info_version: ${{ needs.calculate_version.outputs.git_tag }}
-      tag_version: ${{ github.sha }}
-    secrets:
-      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Set up Docker Buildx Base
+        uses: docker/setup-buildx-action@v1
+        id: builder-base
+
+      - name: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Build and push base
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-base.outputs.name }}
+          context: .
+          file: ./docker/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker
+          tags: |
+            jasongdove/ersatztv:develop
+            jasongdove/ersatztv:${{ github.sha }}
+
+      - name: Build and push nvidia
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
+          context: .
+          file: ./docker/nvidia/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-nvidia
+          tags: |
+            jasongdove/ersatztv:develop-nvidia
+            jasongdove/ersatztv:${{ github.sha }}-nvidia
+
+      - name: Build and push vaapi
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
+          context: .
+          file: ./docker/vaapi/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-vaapi
+          tags: |
+            jasongdove/ersatztv:develop-vaapi
+            jasongdove/ersatztv:${{ github.sha }}-vaapi

.github/workflows/docker.yml

@@ -1,88 +0,0 @@
-name: Build & Publish to Docker Hub
-on:
-  workflow_call:
-    inputs:
-      base_version:
-        description: 'Base version (latest or develop)'
-        required: true
-        type: string
-      info_version:
-        description: 'Informational version number (e.g. 0.3.7-alpha)'
-        required: true
-        type: string
-      tag_version:
-        description: 'Docker tag version (e.g. v0.3.7)'
-        required: true
-        type: string
-    secrets:
-      docker_hub_username:
-        required: true
-      docker_hub_access_token:
-        required: true
-jobs:
-  build_and_push:
-    name: Build & Publish
-    runs-on: ubuntu-latest
-    if: contains(github.event.head_commit.message, '[no build]') == false
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-
-      - name: Set up Docker Buildx Base
-        uses: docker/setup-buildx-action@v1
-        id: builder-base
-
-      - name: Set up Docker Buildx NVIDIA
-        uses: docker/setup-buildx-action@v1
-        id: builder-nvidia
-
-      - name: Set up Docker Buildx VAAPI
-        uses: docker/setup-buildx-action@v1
-        id: builder-vaapi
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.docker_hub_username }}
-          password: ${{ secrets.docker_hub_access_token }}
-
-      - name: Build and push base
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-base.outputs.name }}
-          context: .
-          file: ./docker/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ inputs.info_version }}-docker
-          tags: |
-            jasongdove/ersatztv:${{ inputs.base_version }}
-            jasongdove/ersatztv:${{ inputs.tag_version }}
-
-      - name: Build and push nvidia
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-nvidia.outputs.name }}
-          context: .
-          file: ./docker/nvidia/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ inputs.info_version }}-docker-nvidia
-          tags: |
-            jasongdove/ersatztv:${{ inputs.base_version }}-nvidia
-            jasongdove/ersatztv:${{ inputs.tag_version }}-nvidia
-
-      - name: Build and push vaapi
-        uses: docker/build-push-action@v2
-        with:
-          builder: ${{ steps.builder-vaapi.outputs.name }}
-          context: .
-          file: ./docker/vaapi/Dockerfile
-          push: true
-          build-args: |
-            INFO_VERSION=${{ inputs.info_version }}-docker-vaapi
-          tags: |
-            jasongdove/ersatztv:${{ inputs.base_version }}-vaapi
-            jasongdove/ersatztv:${{ inputs.tag_version }}-vaapi

.github/workflows/docs.yml

@@ -3,13 +3,14 @@ on:
   push:
     branches:
       - main
+
 jobs:
   build:
     name: Deploy docs
     runs-on: ubuntu-latest
     steps:
       - name: Checkout master
-        uses: actions/checkout@v2
+        uses: actions/checkout@v1
 
       - name: Deploy docs
         uses: mhausenblas/mkdocs-deploy-gh-pages@master

.github/workflows/pr.yml

@@ -1,30 +0,0 @@
-name: Pull Request
-on:
-  pull_request:
-jobs:
-  build_and_test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, ubuntu-latest, macos-latest ]
-    steps:
-      - name: Get the sources
-        uses: actions/checkout@v2
-
-      - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: 6.0.x
-
-      - name: Clean
-        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
-
-      - name: Install dependencies
-        run: dotnet restore
-
-      - name: Build
-        run: dotnet build --configuration Release --no-restore
-
-      - name: Test
-        run: dotnet test --no-restore --verbosity normal

.github/workflows/release.yml

@@ -1,53 +1,145 @@
-name: Release
+name: Publish
 on:
   release:
     types: [ published ]
 jobs:
-  calculate_version:
-    name: Calculate version information
-    runs-on: ubuntu-latest
+  release:
+    name: Release
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-x64
+          - os: ubuntu-latest
+            kind: linux
+            target: linux-arm
+          - os: windows-latest
+            kind: windows
+            target: win-x64
+          - os: macos-latest
+            kind: macOS
+            target: osx-x64
+          - os: macos-latest
+            kind: macOS
+            target: osx-arm64
+    runs-on: ${{ matrix.os }}
     steps:
       - name: Get the sources
         uses: actions/checkout@v2
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Build
+        shell: bash
+        run: |
+          # Define some variables for things we need
+          tag=$(git describe --tags --abbrev=0)
+          release_name="ErsatzTV-$tag-${{ matrix.target }}"
+
+          # Build everything
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:EnableCompressionInSingleFile=true /property:PublishSingleFile=true --self-contained true
+
+          # Pack files
+          if [ "${{ matrix.target }}" == "win-x64" ]; then
+            7z a -tzip "${release_name}.zip" "./${release_name}/*"
+          elif [ "${{ matrix.target }}" == "linux-arm" ]; then
+            cp lib/linux-arm/* "$release_name/"
+            tar czvf "${release_name}.tar.gz" "$release_name"
+          else
+            tar czvf "${release_name}.tar.gz" "$release_name"
+          fi
+
+          # Delete output directory
+          rm -r "$release_name"
+
+      - name: Publish
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: true
+          files: |
+            ErsatzTV*.zip
+            ErsatzTV*.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  build_and_push:
+    name: Build & Publish to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Extract Docker Tag
+
+      - name: Extract Git Tag
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
           echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
           echo "DOCKER_TAG=${tag/-alpha/}" >> $GITHUB_ENV
-      - name: Extract Artifacts Version
-        shell: bash
-        run: |
-          tag=$(git describe --tags --abbrev=0)
-          echo "ARTIFACTS_VERSION=${tag}" >> $GITHUB_ENV
-          echo "INFO_VERSION=${tag:1}" >> $GITHUB_ENV
-    outputs:
-      git_tag: ${{ env.GIT_TAG }}
-      docker_tag: ${{ env.DOCKER_TAG }}
-      artifacts_version: ${{ env.ARTIFACTS_VERSION }}
-      info_version: ${{ env.INFO_VERSION }}
-  build_and_upload:
-    uses: jasongdove/ersatztv/.github/workflows/artifacts.yml@main
-    needs: calculate_version
-    with:
-      release_tag: ${{ needs.calculate_version.outputs.artifacts_version }}
-      release_version: ${{ needs.calculate_version.outputs.artifacts_version }}
-      info_version: ${{ needs.calculate_version.outputs.info_version }}
-    secrets:
-      apple_developer_certificate_p12_base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
-      apple_developer_certificate_password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
-      ac_username: ${{ secrets.AC_USERNAME }}
-      ac_password: ${{ secrets.AC_PASSWORD }}
-      gh_token: ${{ secrets.GITHUB_TOKEN }}
-  build_and_push:
-    uses: jasongdove/ersatztv/.github/workflows/docker.yml@main
-    needs: calculate_version
-    with:
-      base_version: latest
-      info_version: ${{ needs.calculate_version.outputs.git_tag }}
-      tag_version: ${{ needs.calculate_version.outputs.docker_tag }}
-    secrets:
-      docker_hub_username: ${{ secrets.DOCKER_HUB_USERNAME }}
-      docker_hub_access_token: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Set up Docker Buildx Base
+        uses: docker/setup-buildx-action@v1
+        id: builder-base
+
+      - name: Set up Docker Buildx NVIDIA
+        uses: docker/setup-buildx-action@v1
+        id: builder-nvidia
+
+      - name: Set up Docker Buildx VAAPI
+        uses: docker/setup-buildx-action@v1
+        id: builder-vaapi
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Build and push base
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-base.outputs.name }}
+          context: .
+          file: ./docker/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker
+          tags: |
+            jasongdove/ersatztv:latest
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}
+
+      - name: Build and push nvidia
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-nvidia.outputs.name }}
+          context: .
+          file: ./docker/nvidia/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-nvidia
+          tags: |
+            jasongdove/ersatztv:latest-nvidia
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}-nvidia
+
+      - name: Build and push vaapi
+        uses: docker/build-push-action@v2
+        with:
+          builder: ${{ steps.builder-vaapi.outputs.name }}
+          context: .
+          file: ./docker/vaapi/Dockerfile
+          push: true
+          build-args: |
+            INFO_VERSION=${{ env.GIT_TAG }}-docker-vaapi
+          tags: |
+            jasongdove/ersatztv:latest-vaapi
+            jasongdove/ersatztv:${{ env.DOCKER_TAG }}-vaapi

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "ErsatzTV-macOS"]
-	path = ErsatzTV-macOS
-	url = git@github.com:jasongdove/ErsatzTV-macOS.git

CHANGELOG.md

@@ -5,154 +5,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
-## [0.4.2-alpha] - 2022-02-26
-### Fixed
-- Add improved but experimental transcoder logic, which can be toggled on and off in `Settings`
-- Fix `HLS Segmenter` bug when source video packet contains no duration (`N/A`)
-- Fix green line at the bottom of some content scaled using QSV acceleration
-
-### Added
-- Add configurable channel group (M3U) and categories (XMLTV)
-- Add `Shuffle Schedule Items` option to schedule configuration
-  - When this is enabled, schedule items will be shuffled rather than looped in order
-  - **To support this, all playouts will be rebuilt (one time) after upgrading to this version**
-
-### Changed
-- Disable framerate normalization by default and on all ffmpeg profiles
-  - If framerate normalization is desired (not typically needed), it can be re-enabled manually
-- Show watermarks over songs
-- Hide unused local libraries
-
-## [0.4.1-alpha] - 2022-02-10
-### Fixed
-- Normalize smart quotes in search queries as they are unsupported by the search library
-- Fix incorrect watermark time calculations caused by working ahead in `HLS Segmenter`
-- Fix ui crash adding empty path to local library
-- Fix ui crash loading collection editor
-- Properly flag items as `File Not Found` when local library path (folder) is missing from disk
-- Fix playback bug with unknown pixel format
-- Fix playback of interlaced mpeg2video on NVIDIA, VAAPI
-
-### Added
-- Include `Series` category tag for all episodes in XMLTV
-- Include movie, episode (show), music video (artist) genres as `category` tags in XMLTV
-- Add framerate normalization to `HLS Segmenter` and `MPEG-TS` streaming modes
-- Add `HLS Segmenter Initial Segment Count` setting to allow segmenter to work ahead before allowing client playback
-
-### Changed
-- Intermittent watermarks will now fade in and out
-- Show collection name in some playout build error messages
-- Use hardware-accelerated filter for watermarks on NVIDIA
-- Use hardware-accelerated deinterlace for some content on NVIDIA
-
-## [0.4.0-alpha] - 2022-01-29
-### Fixed
-- Fix m3u `mode` query param to properly override streaming mode for all channels
-  - `segmenter` for `HLS Segmenter`
-  - `hls-direct` for `HLS Direct`
-  - `ts` for `MPEG-TS`
-  - `ts-legacy` for `MPEG-TS (Legacy)`
-  - omitting the `mode` parameter returns each channel as configured
-- Link `File Not Found` health check to `Trash` page to allow deletion
-- Fix `HLS Segmenter` streaming mode with multiple ffmpeg-based clients
-  - Jellyfin (web) and TiviMate (Android) were specifically tested
-
-### Added
-- Hide console window on macOS and Windows; tray menu can be used to access UI, logs and to stop the app
-- Also write logs to text files in the `logs` config subfolder
-- Add `added_date` to search index
-    - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
-- Add `added_inthelast`, `added_notinthelast` search field for relative added date queries
-    - Syntax is a number and a unit (days, weeks, months, years) like `1 week` or `2 years`
-
-## [0.3.8-alpha] - 2022-01-23
-### Fixed
-- Fix issue preventing some versions of ffmpeg (usually 4.4.x) from streaming MPEG-TS (Legacy) channels at all
-  - The issue appears to be caused by using a thread count other than `1`
-  - Thread count is now forced to `1` for all streaming modes other than HLS Segmenter
-- Fix bug with HLS Segmenter in cultures where `.` is a group/thousands separator
-- Fix search results page crashing with some media kinds
-- Always use MPEG-TS or MPEG-TS (Legacy) streaming mode with HDHR (Plex)
-  - Other configured modes will fall back to MPEG-TS when accessed by Plex
-
-### Changed
-- Upgrade ffmpeg from 4.4 to 5.0 in all docker images
-    - Upgrading from 4.4 to 5.0 is recommended for all installations
-
-## [0.3.7-alpha] - 2022-01-17
-### Fixed
-- Fix local folder scanners to properly detect removed/re-added folders with unchanged contents
-- Fix double-click startup on mac
-- Fix trakt list sync when show does not contain a year
-- Properly unlock libraries when a scan is unable to be performed because ffmpeg or ffprobe have not been found
-
-### Added
-- Add trash system for local libraries to maintain collection and schedule integrity through media share outages
-  - When items are missing from disk, they will be flagged and present in the `Media` > `Trash` page
-  - The trash page can be used to permanently remove missing items from the database
-  - When items reappear at the expected location on disk, they will be unflagged and removed from the trash
-- Add basic Mac hardware acceleration using VideoToolbox
-
-### Changed
-- Local libraries only: when items are missing from disk, they will be added to the trash and no longer removed from collections, etc.
-- Show song thumbnail in song list
-
-## [0.3.6-alpha] - 2022-01-10
-### Fixed
-- Properly index `minutes` field when adding new items during scan (vs when rebuilding index)
-- Fix some nvenc edge cases where only padding is needed for normalization
-- Properly overwrite environment variables for ffmpeg processes (`LIBVA_DRIVER_NAME`, `FFREPORT`)
-
-### Added
-- Add music video `artist` to search index
-  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
-
-### Changed
-- Remove `HLS Hybrid` streaming mode; all channels have been reconfigured to use the superior `HLS Segmenter` streaming mode
-- Update `MPEG-TS` streaming mode to internally use the HLS segmenter
-  - This improves compatibility with many clients and also improves performance at program boundaries
-- Renamed existing `MPEG-TS` mode as `MPEG-TS (Legacy)`
-  - This mode will be removed in a future release
-
-## [0.3.5-alpha] - 2022-01-05
-### Fixed
-- Fix bundled ffmpeg version in base docker image (NOT nvidia or vaapi) which prevented playback since v0.3.0-alpha
-- Use software decoding for mpeg4 content when VAAPI acceleration is enabled
-- Fix hardware acceleration health check to recognize QSV on non-Windows platforms
-
-### Changed
-- Treat `setsar` as a hardware filter, avoiding unneeded `hwdownload` and `hwupload` steps when padding isn't required
-
-## [0.3.4-alpha] - 2021-12-21
-### Fixed
-- Fix other video and song scanners to include videos contained directly in top-level folders that are added to a library
-- Allow saving ffmpeg troubleshooting reports on Windows
-
-## [0.3.3-alpha] - 2021-12-12
-### Fixed
-- Fix bug with saving multiple blurhash versions for cover art; all cover art will be automatically rescanned
-- Fix song detail margin when no cover art exists and no watermark exists
-- Fix synchronizing virtual shows and seasons from Jellyfin
-- Properly sort channels in M3U
-
-### Changed
-- Use blurhash of ErsatzTV colors instead of solid colors for default song backgrounds
-- Use select control instead of autocomplete control in many places
-    - The autocomplete control is not intuitive to use and has focus bugs
-
-## [0.3.2-alpha] - 2021-12-03
-### Fixed
-- Fix artwork upload on Windows
-- Fix unicode song metadata on Windows
-- Fix unicode console output on Windows
-- Fix TV Show NFO metadata processing when `year` is missing
-- Fix song detail outline to help legibility on white backgrounds
-- Optimize song artwork scanning to prevent re-processing album artwork for each song
-
-### Changed
-- Use custom log database backend which should be more portable (i.e. work in osx-arm64)
-- Use cover art blurhashes for song backgrounds instead of solid colors or box blur
-
 ## [0.3.1-alpha] - 2021-11-30
 ### Fixed
 - Fix song page links in UI
@@ -985,17 +837,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/jasongdove/ErsatzTV/compare/v0.4.2-alpha...HEAD
-[0.4.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.1-alpha...v0.4.2-alpha
-[0.4.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.4.0-alpha...v0.4.1-alpha
-[0.4.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.8-alpha...v0.4.0-alpha
-[0.3.8-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.7-alpha...v0.3.8-alpha
-[0.3.7-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.6-alpha...v0.3.7-alpha
-[0.3.6-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.5-alpha...v0.3.6-alpha
-[0.3.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.4-alpha...v0.3.5-alpha
-[0.3.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.3-alpha...v0.3.4-alpha
-[0.3.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.2-alpha...v0.3.3-alpha
-[0.3.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.1-alpha...v0.3.2-alpha
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.1-alpha...HEAD
 [0.3.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.0-alpha...v0.3.1-alpha
 [0.3.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.5-alpha...v0.3.0-alpha
 [0.2.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.4-alpha...v0.2.5-alpha

ErsatzTV-Windows/ErsatzTV-Windows.csproj

@@ -1,33 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <OutputType>WinExe</OutputType>
-        <TargetFramework>net6.0-windows</TargetFramework>
-        <RootNamespace>ErsatzTV_Windows</RootNamespace>
-        <Nullable>enable</Nullable>
-        <UseWindowsForms>true</UseWindowsForms>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <ApplicationIcon>Ersatztv.ico</ApplicationIcon>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <Content Include="Ersatztv.ico">
-        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      </Content>
-    </ItemGroup>
-
-    <ItemGroup>
-      <PackageReference Include="Asmichi.ChildProcess" Version="0.11.0" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\ErsatzTV.Core\ErsatzTV.Core.csproj" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <Compile Update="Program.cs">
-        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      </Compile>
-    </ItemGroup>
-
-</Project>

ErsatzTV-Windows/Program.cs

@@ -1,14 +0,0 @@
-namespace ErsatzTV_Windows;
-
-public static class Program
-{
-    /// <summary>
-    ///  The main entry point for the application.
-    /// </summary>
-    [STAThread]
-    public static void Main()
-    {
-        ApplicationConfiguration.Initialize();
-        Application.Run(new TrayApplicationContext());
-    }
-}

ErsatzTV-Windows/TrayApplicationContext.cs

@@ -1,77 +0,0 @@
-using ErsatzTV.Core;
-using System.Diagnostics;
-using Asmichi.ProcessManagement;
-using System.Reflection;
-
-namespace ErsatzTV_Windows;
-
-public class TrayApplicationContext : ApplicationContext
-{
-    private readonly NotifyIcon _trayIcon;
-    private readonly IChildProcess? _childProcess;
-
-    public TrayApplicationContext()
-    {
-        _trayIcon = new NotifyIcon
-        {
-            Icon = new Icon("./Ersatztv.ico"),
-            ContextMenuStrip = new ContextMenuStrip(),
-            Visible = true
-        };
-
-        AddMenuItem("Launch Web UI", LaunchWebUI);
-        AddMenuItem("Show Logs", ShowLogs);
-        _trayIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());
-        AddMenuItem("Exit", Exit);
-
-        string folder = AppContext.BaseDirectory;
-        string exe = Path.Combine(folder, "ErsatzTV.exe");
-
-        if (File.Exists(exe))
-        {
-            var si = new ChildProcessStartInfo(exe);
-            _childProcess = ChildProcess.Start(si);
-        }
-    }
-
-    private void AddMenuItem(string name, EventHandler action)
-    {
-        var item = new ToolStripMenuItem(name);
-        item.Click += action;
-        _trayIcon.ContextMenuStrip.Items.Add(item);
-    }
-
-    private void LaunchWebUI(object? sender, EventArgs e)
-    {
-        var process = new Process();
-        process.StartInfo.UseShellExecute = true;
-        process.StartInfo.FileName = "http://localhost:8409";
-        process.Start();
-    }
-
-    private void ShowLogs(object? sender, EventArgs e)
-    {
-        if (!Directory.Exists(FileSystemLayout.LogsFolder))
-        {
-            Directory.CreateDirectory(FileSystemLayout.LogsFolder);
-        }
-
-        var process = new Process();
-        process.StartInfo.UseShellExecute = true;
-        process.StartInfo.FileName = FileSystemLayout.LogsFolder;
-        process.Start();
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        _childProcess?.Dispose();
-        base.Dispose(disposing);
-    }
-
-    private void Exit(object? sender, EventArgs e)
-    {
-        // Hide tray icon, otherwise it will remain shown until user mouses over it
-        _trayIcon.Visible = false;
-        Application.Exit();
-    }
-}

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -6,13 +6,10 @@ namespace ErsatzTV.Application.Channels
         int Id,
         string Number,
         string Name,
-        string Group,
-        string Categories,
         int FFmpegProfileId,
         string Logo,
         string PreferredLanguageCode,
         StreamingMode StreamingMode,
         int? WatermarkId,
-        int? FallbackFillerId,
-        int PlayoutCount);
+        int? FallbackFillerId);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -9,8 +9,6 @@ namespace ErsatzTV.Application.Channels.Commands
     (
         string Name,
         string Number,
-        string Group,
-        string Categories,
         int FFmpegProfileId,
         string Logo,
         string PreferredLanguageCode,

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -27,7 +27,7 @@ namespace ErsatzTV.Application.Channels.Commands
             CreateChannel request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             Validation<BaseError, Channel> validation = await Validate(dbContext, request);
             return await validation.Apply(c => PersistChannel(dbContext, c));
         }
@@ -65,8 +65,6 @@ namespace ErsatzTV.Application.Channels.Commands
                     {
                         Name = name,
                         Number = number,
-                        Group = request.Group,
-                        Categories = request.Categories,
                         FFmpegProfileId = ffmpegProfileId,
                         StreamingMode = request.StreamingMode,
                         Artwork = artwork,

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -10,8 +10,6 @@ namespace ErsatzTV.Application.Channels.Commands
         int ChannelId,
         string Name,
         string Number,
-        string Group,
-        string Categories,
         int FFmpegProfileId,
         string Logo,
         string PreferredLanguageCode,

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -28,7 +28,7 @@ namespace ErsatzTV.Application.Channels.Commands
             UpdateChannel request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             Validation<BaseError, Channel> validation = await Validate(dbContext, request);
             return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
         }
@@ -37,8 +37,6 @@ namespace ErsatzTV.Application.Channels.Commands
         {
             c.Name = update.Name;
             c.Number = update.Number;
-            c.Group = update.Group;
-            c.Categories = update.Categories;
             c.FFmpegProfileId = update.FFmpegProfileId;
             c.PreferredLanguageCode = update.PreferredLanguageCode;
             c.Artwork ??= new List<Artwork>();

ErsatzTV.Application/Channels/Mapper.cs

@@ -11,15 +11,12 @@ namespace ErsatzTV.Application.Channels
                 channel.Id,
                 channel.Number,
                 channel.Name,
-                channel.Group,
-                channel.Categories,
                 channel.FFmpegProfileId,
                 GetLogo(channel),
                 channel.PreferredLanguageCode,
                 channel.StreamingMode,
                 channel.WatermarkId,
-                channel.FallbackFillerId,
-                channel.Playouts?.Count ?? 0);
+                channel.FallbackFillerId);
 
         private static string GetLogo(Channel channel) =>
             Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

@@ -1,6 +0,0 @@
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.Channels.Queries;
-
-public record GetChannelFramerate(string ChannelNumber) : IRequest<Option<int>>;

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -1,99 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Extensions;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.Application.Channels.Queries;
-
-public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, Option<int>>
-{
-    private readonly IDbContextFactory<TvContext> _dbContextFactory;
-    private readonly ILogger<GetChannelFramerateHandler> _logger;
-
-    public GetChannelFramerateHandler(
-        IDbContextFactory<TvContext> dbContextFactory,
-        ILogger<GetChannelFramerateHandler> logger)
-    {
-        _dbContextFactory = dbContextFactory;
-        _logger = logger;
-    }
-
-    public async Task<Option<int>> Handle(GetChannelFramerate request, CancellationToken cancellationToken)
-    {
-        // TODO: expand to check everything in collection rather than what's scheduled?
-        _logger.LogDebug("Checking frame rates for channel {ChannelNumber}", request.ChannelNumber);
-        
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-        List<Playout> playouts = await dbContext.Playouts
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as Movie).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as Episode).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as Song).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
-            .Include(p => p.Items)
-            .ThenInclude(pi => pi.MediaItem)
-            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
-            .Filter(p => p.Channel.Number == request.ChannelNumber)
-            .ToListAsync(cancellationToken);
-
-        var frameRates = playouts.Map(p => p.Items.Map(i => i.MediaItem.GetHeadVersion()))
-            .Flatten()
-            .Map(mv => mv.RFrameRate)
-            .ToList();
-
-
-        var distinct = frameRates.Distinct().ToList();
-        if (distinct.Count > 1)
-        {
-            // TODO: something more intelligent than minimum framerate?
-            int result = frameRates.Map(ParseFrameRate).Min();
-            _logger.LogInformation(
-                "Normalizing frame rate for channel {ChannelNumber} from {Distinct} to {FrameRate}",
-                request.ChannelNumber,
-                distinct,
-                result);
-            return result;
-        }
-
-        _logger.LogInformation(
-            "All content on channel {ChannelNumber} has the same frame rate of {FrameRate}; will not normalize",
-            request.ChannelNumber,
-            distinct[0]);
-        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/GetChannelPlaylistHandler.cs

@@ -36,12 +36,8 @@ namespace ErsatzTV.Application.Channels.Queries
                         channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                         result.Add(channel);
                         break;
-                    case "ts-legacy":
-                        channel.StreamingMode = StreamingMode.TransportStream;
-                        result.Add(channel);
-                        break;
                     case "ts":
-                        channel.StreamingMode = StreamingMode.TransportStreamHybrid;
+                        channel.StreamingMode = StreamingMode.TransportStream;
                         result.Add(channel);
                         break;
                     default:

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -3,10 +3,11 @@
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
+        <DebugType>embedded</DebugType>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="MediatR" Version="10.0.1" />
+      <PackageReference Include="MediatR" Version="9.0.0" />
       <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.64">
         <PrivateAssets>all</PrivateAssets>

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -24,6 +24,5 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio,
-        bool NormalizeFramerate) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
+        bool NormalizeAudio) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -58,8 +58,7 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                     NormalizeLoudness = request.NormalizeLoudness,
                     AudioChannels = request.AudioChannels,
                     AudioSampleRate = request.AudioSampleRate,
-                    NormalizeAudio = request.NormalizeAudio,
-                    NormalizeFramerate = request.NormalizeFramerate
+                    NormalizeAudio = request.NormalizeAudio
                 });
 
         private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -25,6 +25,5 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio,
-        bool NormalizeFramerate) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;
+        bool NormalizeAudio) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -50,7 +50,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
             p.AudioChannels = update.AudioChannels;
             p.AudioSampleRate = update.AudioSampleRate;
             p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
-            p.NormalizeFramerate = update.Transcode && update.NormalizeFramerate;
             await dbContext.SaveChangesAsync();
             return new UpdateFFmpegProfileResult(p.Id);
         }

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs

@@ -1,11 +1,13 @@
 using System.Diagnostics;
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
 using LanguageExt;
 
 namespace ErsatzTV.Application.FFmpegProfiles.Commands
@@ -14,13 +16,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
     {
         private readonly IConfigElementRepository _configElementRepository;
         private readonly ILocalFileSystem _localFileSystem;
+        private readonly IRuntimeInfo _runtimeInfo;
 
         public UpdateFFmpegSettingsHandler(
             IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem)
+            ILocalFileSystem localFileSystem,
+            IRuntimeInfo runtimeInfo)
         {
             _configElementRepository = configElementRepository;
             _localFileSystem = localFileSystem;
+            _runtimeInfo = runtimeInfo;
         }
 
         public Task<Either<BaseError, Unit>> Handle(
@@ -31,8 +36,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 .Bind(v => v.ToEitherAsync());
 
         private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
-            (await FFmpegMustExist(request), await FFprobeMustExist(request))
-            .Apply((_, _) => Unit.Default);
+            (await FFmpegMustExist(request), await FFprobeMustExist(request), ReportsAreNotSupportedOnWindows(request))
+            .Apply((_, _, _) => Unit.Default);
 
         private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
@@ -40,6 +45,16 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
 
+        private Validation<BaseError, Unit> ReportsAreNotSupportedOnWindows(UpdateFFmpegSettings request)
+        {
+            if (request.Settings.SaveReports && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+            {
+                return BaseError.New("FFmpeg reports are not supported on Windows");
+            }
+
+            return Unit.Default;
+        }
+
         private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
         {
             if (!_localFileSystem.FileExists(path))
@@ -85,10 +100,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
             }
 
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegUseExperimentalTranscoder,
-                request.Settings.UseExperimentalTranscoder.ToString());
-
             await _configElementRepository.Upsert(
                 ConfigElementKey.FFmpegPreferredLanguageCode,
                 request.Settings.PreferredLanguageCode);
@@ -123,10 +134,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                 ConfigElementKey.FFmpegWorkAheadSegmenters,
                 request.Settings.WorkAheadSegmenterLimit);
 
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegInitialSegmentCount,
-                request.Settings.InitialSegmentCount);
-
             return Unit.Default;
         }
     }

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -23,6 +23,5 @@ namespace ErsatzTV.Application.FFmpegProfiles
         bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio,
-        bool NormalizeFramerate);
+        bool NormalizeAudio);
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

@@ -11,7 +11,5 @@
         public int? GlobalFallbackFillerId { get; set; }
         public int HlsSegmenterIdleTimeout { get; set; }
         public int WorkAheadSegmenterLimit { get; set; }
-        public int InitialSegmentCount { get; set; }
-        public bool UseExperimentalTranscoder { get; set; }
     }
 }

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -25,8 +25,7 @@ namespace ErsatzTV.Application.FFmpegProfiles
                 profile.NormalizeLoudness,
                 profile.AudioChannels,
                 profile.AudioSampleRate,
-                profile.NormalizeAudio,
-                profile.NormalizeVideo && profile.NormalizeFramerate);
+                profile.NormalizeAudio);
 
         private static ResolutionViewModel Project(Resolution resolution) =>
             new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -34,10 +34,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                 await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout);
             Option<int> workAheadSegmenterLimit =
                 await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);
-            Option<int> initialSegmentCount =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount);
-            Option<bool> useExperimentalTranscoder =
-                await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseExperimentalTranscoder);
 
             var result = new FFmpegSettingsViewModel
             {
@@ -48,8 +44,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                 PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
                 HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
                 WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
-                InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1),
-                UseExperimentalTranscoder = await useExperimentalTranscoder.IfNoneAsync(false)
             };
 
             foreach (int watermarkId in watermark)

ErsatzTV.Application/Libraries/Queries/GetAllLibraries.cs

@@ -3,5 +3,5 @@ using MediatR;
 
 namespace ErsatzTV.Application.Libraries.Queries
 {
-    public record GetConfiguredLibraries : IRequest<List<LibraryViewModel>>;
+    public record GetAllLibraries : IRequest<List<LibraryViewModel>>;
 }

ErsatzTV.Application/Libraries/Queries/GetAllLibrariesHandler.cs

@@ -10,16 +10,13 @@ using static ErsatzTV.Application.Libraries.Mapper;
 
 namespace ErsatzTV.Application.Libraries.Queries
 {
-    public class GetConfiguredLibrariesHandler : IRequestHandler<GetConfiguredLibraries, List<LibraryViewModel>>
+    public class GetAllLibrariesHandler : IRequestHandler<GetAllLibraries, List<LibraryViewModel>>
     {
         private readonly ILibraryRepository _libraryRepository;
 
-        public GetConfiguredLibrariesHandler(ILibraryRepository libraryRepository) =>
-            _libraryRepository = libraryRepository;
+        public GetAllLibrariesHandler(ILibraryRepository libraryRepository) => _libraryRepository = libraryRepository;
 
-        public Task<List<LibraryViewModel>> Handle(
-            GetConfiguredLibraries request,
-            CancellationToken cancellationToken) =>
+        public Task<List<LibraryViewModel>> Handle(GetAllLibraries request, CancellationToken cancellationToken) =>
             _libraryRepository.GetAll()
                 .Map(
                     list => list.Filter(ShouldIncludeLibrary)
@@ -31,7 +28,7 @@ namespace ErsatzTV.Application.Libraries.Queries
         private static bool ShouldIncludeLibrary(Library library) =>
             library switch
             {
-                LocalLibrary => library.Paths.Count > 0,
+                LocalLibrary => true,
                 PlexLibrary plex => plex.ShouldSyncItems,
                 JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
                 EmbyLibrary emby => emby.ShouldSyncItems,

ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs

@@ -1,9 +0,0 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
-
-namespace ErsatzTV.Application.Maintenance.Commands;
-
-public record DeleteItemsFromDatabase(List<int> MediaItemIds) : IRequest<Either<BaseError, Unit>>;

ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabaseHandler.cs

@@ -1,38 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
-
-namespace ErsatzTV.Application.Maintenance.Commands
-{
-    public class
-        DeleteItemsFromDatabaseHandler : MediatR.IRequestHandler<DeleteItemsFromDatabase, Either<BaseError, Unit>>
-    {
-        private readonly IMediaItemRepository _mediaItemRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public DeleteItemsFromDatabaseHandler(
-            IMediaItemRepository mediaItemRepository,
-            ISearchIndex searchIndex)
-        {
-            _mediaItemRepository = mediaItemRepository;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteItemsFromDatabase request,
-            CancellationToken cancellationToken)
-        {
-            Either<BaseError, Unit> deleteResult = await _mediaItemRepository.DeleteItems(request.MediaItemIds);
-            if (deleteResult.IsRight)
-            {
-                await _searchIndex.RemoveItems(request.MediaItemIds);
-                _searchIndex.Commit();
-            }
-
-            return deleteResult;
-        }
-    }
-}

ErsatzTV.Application/MediaCards/ActorCardViewModel.cs

@@ -1,7 +1,5 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
-    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb, MediaItemState State) :
-        MediaCardViewModel(Id, Name, Role, Name, Thumb, State);
+    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb) :
+        MediaCardViewModel(Id, Name, Role, Name, Thumb);
 }

ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs

@@ -1,19 +1,10 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record ArtistCardViewModel
-    (
-        int ArtistId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        ArtistId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State);
+        (int ArtistId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            ArtistId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster);
 }

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -2,7 +2,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
-using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Jellyfin;
 using LanguageExt;
 using static LanguageExt.Prelude;
@@ -20,8 +19,7 @@ namespace ErsatzTV.Application.MediaCards
                 showMetadata.Title,
                 showMetadata.Year?.ToString(),
                 showMetadata.SortTitle,
-                GetPoster(showMetadata, maybeJellyfin, maybeEmby),
-                showMetadata.Show.State);
+                GetPoster(showMetadata, maybeJellyfin, maybeEmby));
         
         internal static TelevisionSeasonCardViewModel ProjectToViewModel(
             Season season,
@@ -36,8 +34,7 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(season.SeasonNumber),
                 season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin, maybeEmby))
                     .IfNone(string.Empty),
-                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString(),
-                season.State);
+                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());
 
         internal static TelevisionSeasonCardViewModel ProjectToViewModel(
             SeasonMetadata seasonMetadata,
@@ -56,8 +53,7 @@ namespace ErsatzTV.Application.MediaCards
                 GetSeasonName(seasonMetadata.Season.SeasonNumber),
                 $"{showTitle}_{seasonMetadata.Season.SeasonNumber:0000}",
                 GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
-                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString(),
-                seasonMetadata.Season.State);
+                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString());
         }
 
         internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
@@ -84,9 +80,7 @@ namespace ErsatzTV.Application.MediaCards
                     ? GetEpisodePoster(episodeMetadata, maybeJellyfin, maybeEmby)
                     : GetThumbnail(episodeMetadata, maybeJellyfin, maybeEmby),
                 episodeMetadata.Directors.Map(d => d.Name).ToList(),
-                episodeMetadata.Writers.Map(w => w.Name).ToList(),
-                episodeMetadata.Episode.State,
-                episodeMetadata.Episode.GetHeadVersion().MediaFiles.Head().Path);
+                episodeMetadata.Writers.Map(w => w.Name).ToList());
 
         internal static MovieCardViewModel ProjectToViewModel(
             MovieMetadata movieMetadata,
@@ -97,8 +91,7 @@ namespace ErsatzTV.Application.MediaCards
                 movieMetadata.Title,
                 movieMetadata.Year?.ToString(),
                 movieMetadata.SortTitle,
-                GetPoster(movieMetadata, maybeJellyfin, maybeEmby),
-                movieMetadata.Movie.State);
+                GetPoster(movieMetadata, maybeJellyfin, maybeEmby));
 
         internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
             new(
@@ -108,17 +101,14 @@ namespace ErsatzTV.Application.MediaCards
                 musicVideoMetadata.SortTitle,
                 musicVideoMetadata.Plot,
                 musicVideoMetadata.Album,
-                GetThumbnail(musicVideoMetadata, None, None),
-                musicVideoMetadata.MusicVideo.State,
-                musicVideoMetadata.MusicVideo.GetHeadVersion().MediaFiles.Head().Path);
+                GetThumbnail(musicVideoMetadata, None, None));
 
         internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
             new(
                 otherVideoMetadata.OtherVideoId,
                 otherVideoMetadata.Title,
                 otherVideoMetadata.OriginalTitle,
-                otherVideoMetadata.SortTitle,
-                otherVideoMetadata.OtherVideo.State);
+                otherVideoMetadata.SortTitle);
 
         internal static SongCardViewModel ProjectToViewModel(SongMetadata songMetadata)
         {
@@ -127,9 +117,7 @@ namespace ErsatzTV.Application.MediaCards
                 songMetadata.SongId,
                 songMetadata.Title,
                 songMetadata.Artist + album,
-                songMetadata.SortTitle,
-                GetThumbnail(songMetadata, None, None),
-                songMetadata.Song.State);
+                songMetadata.SortTitle);
         }
 
         internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
@@ -138,8 +126,7 @@ namespace ErsatzTV.Application.MediaCards
                 artistMetadata.Title,
                 artistMetadata.Disambiguation,
                 artistMetadata.SortTitle,
-                GetThumbnail(artistMetadata, None, None),
-                artistMetadata.Artist.State);
+                GetThumbnail(artistMetadata, None, None));
 
         internal static CollectionCardResultsViewModel
             ProjectToViewModel(
@@ -187,7 +174,7 @@ namespace ErsatzTV.Application.MediaCards
                     .SetQueryParam("maxHeight", 440);
             }
 
-            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork, MediaItemState.Normal);
+            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork);
         }
 
         private static int GetCustomIndex(Collection collection, int mediaItemId) =>

ErsatzTV.Application/MediaCards/MediaCardViewModel.cs

@@ -1,12 +1,4 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
-    public record MediaCardViewModel(
-        int MediaItemId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State);
+    public record MediaCardViewModel(int MediaItemId, string Title, string Subtitle, string SortTitle, string Poster);
 }

ErsatzTV.Application/MediaCards/MovieCardViewModel.cs

@@ -1,21 +1,12 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record MovieCardViewModel
-    (
-        int MovieId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        MovieId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State)
+        (int MovieId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            MovieId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

@@ -1,6 +1,4 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record MusicVideoCardViewModel
     (
@@ -10,15 +8,12 @@ namespace ErsatzTV.Application.MediaCards
         string SortTitle,
         string Plot,
         string Album,
-        string Poster,
-        MediaItemState State,
-        string Path) : MediaCardViewModel(
+        string Poster) : MediaCardViewModel(
         MusicVideoId,
         Title,
         Subtitle,
         SortTitle,
-        Poster,
-        State)
+        Poster)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs

@@ -1,20 +1,16 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record OtherVideoCardViewModel
     (
         int OtherVideoId,
         string Title,
         string Subtitle,
-        string SortTitle,
-        MediaItemState State) : MediaCardViewModel(
+        string SortTitle) : MediaCardViewModel(
         OtherVideoId,
         Title,
         Subtitle,
         SortTitle,
-        null,
-        State)
+        null)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -47,9 +47,6 @@ namespace ErsatzTV.Application.MediaCards.Queries
                 .ThenInclude(i => (i as Movie).MovieMetadata)
                 .ThenInclude(mm => mm.Artwork)
                 .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Movie).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Artist).ArtistMetadata)
                 .ThenInclude(mvm => mvm.Artwork)
                 .Include(c => c.MediaItems)
@@ -59,9 +56,6 @@ namespace ErsatzTV.Application.MediaCards.Queries
                 .ThenInclude(i => (i as MusicVideo).Artist)
                 .ThenInclude(a => a.ArtistMetadata)
                 .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as MusicVideo).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Show).ShowMetadata)
                 .ThenInclude(sm => sm.Artwork)
                 .Include(c => c.MediaItems)
@@ -87,20 +81,11 @@ namespace ErsatzTV.Application.MediaCards.Queries
                 .ThenInclude(i => (i as Episode).Season)
                 .ThenInclude(s => s.SeasonMetadata)
                 .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
                 .ThenInclude(ovm => ovm.Artwork)
                 .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as OtherVideo).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
                 .ThenInclude(i => (i as Song).SongMetadata)
                 .ThenInclude(ovm => ovm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Song).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
                 .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
                 .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
                 .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));

ErsatzTV.Application/MediaCards/SongCardViewModel.cs

@@ -1,21 +1,16 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record SongCardViewModel
     (
         int SongId,
         string Title,
         string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
+        string SortTitle) : MediaCardViewModel(
         SongId,
         Title,
         Subtitle,
         SortTitle,
-        Poster,
-        State)
+        null)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaCards
 {
@@ -18,13 +17,10 @@ namespace ErsatzTV.Application.MediaCards
         string Plot,
         string Poster,
         List<string> Directors,
-        List<string> Writers,
-        MediaItemState State,
-        string Path) : MediaCardViewModel(
+        List<string> Writers) : MediaCardViewModel(
         EpisodeId,
         Title,
         $"Episode {Episode}",
         SortTitle,
-        Poster,
-        State);
+        Poster);
 }

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

@@ -1,6 +1,4 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record TelevisionSeasonCardViewModel
     (
@@ -11,12 +9,10 @@ namespace ErsatzTV.Application.MediaCards
         string Subtitle,
         string SortTitle,
         string Poster,
-        string Placeholder,
-        MediaItemState State) : MediaCardViewModel(
+        string Placeholder) : MediaCardViewModel(
         TelevisionSeasonId,
         Title,
         Subtitle,
         SortTitle,
-        Poster,
-        State);
+        Poster);
 }

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

@@ -1,19 +1,10 @@
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards
 {
     public record TelevisionShowCardViewModel
-    (
-        int TelevisionShowId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        TelevisionShowId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State);
+        (int TelevisionShowId, string Title, string Subtitle, string SortTitle, string Poster) : MediaCardViewModel(
+            TelevisionShowId,
+            Title,
+            Subtitle,
+            SortTitle,
+            Poster);
 }

ErsatzTV.Application/MediaCollections/Mapper.cs

@@ -7,7 +7,7 @@ namespace ErsatzTV.Application.MediaCollections
     internal static class Mapper
     {
         internal static MediaCollectionViewModel ProjectToViewModel(Collection collection) =>
-            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder, MediaItemState.Normal);
+            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder);
 
         internal static MultiCollectionViewModel ProjectToViewModel(MultiCollection multiCollection) =>
             new(

ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs

@@ -1,17 +1,11 @@
 using ErsatzTV.Application.MediaCards;
-using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.MediaCollections
 {
-    public record MediaCollectionViewModel(
-        int Id,
-        string Name,
-        bool UseCustomPlaybackOrder,
-        MediaItemState State) : MediaCardViewModel(
+    public record MediaCollectionViewModel(int Id, string Name, bool UseCustomPlaybackOrder) : MediaCardViewModel(
         Id,
         Name,
         string.Empty,
         Name,
-        string.Empty,
-        State);
+        string.Empty);
 }

ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs

@@ -21,7 +21,7 @@ namespace ErsatzTV.Application.MediaCollections.Queries
             GetCollectionById request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             return await dbContext.Collections
                 .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
                 .MapT(ProjectToViewModel);

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -160,36 +160,15 @@ namespace ErsatzTV.Application.MediaSources.Commands
             return Unit.Default;
         }
 
-        private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request)
-        {
-            Validation<BaseError, LocalLibrary> libraryResult = await LocalLibraryMustExist(request);
-            Validation<BaseError, string> ffprobePathResult = await ValidateFFprobePath();
-            Validation<BaseError, string> ffmpegPathResult = await ValidateFFmpegPath();
-            Validation<BaseError, int> refreshIntervalResult = await ValidateLibraryRefreshInterval();
-
-            try
-            {
-                return (libraryResult, ffprobePathResult, ffmpegPathResult, refreshIntervalResult)
-                    .Apply(
-                        (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
-                            library,
-                            ffprobePath,
-                            ffmpegPath,
-                            request.ForceScan,
-                            libraryRefreshInterval));
-            }
-            finally
-            {
-                // ensure we unlock the library if any validation is unsuccessful
-                foreach (LocalLibrary library in libraryResult.SuccessToSeq())
-                {
-                    if (ffprobePathResult.IsFail || ffmpegPathResult.IsFail || refreshIntervalResult.IsFail)
-                    {
-                        _entityLocker.UnlockLibrary(library.Id);
-                    }
-                }
-            }
-        }
+        private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request) =>
+            (await LocalLibraryMustExist(request), await ValidateFFprobePath(), await ValidateFFmpegPath(), await ValidateLibraryRefreshInterval())
+            .Apply(
+                (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
+                    library,
+                    ffprobePath,
+                    ffmpegPath,
+                    request.ForceScan,
+                    libraryRefreshInterval));
 
         private Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
             IScanLocalLibrary request) =>

ErsatzTV.Application/Movies/Mapper.cs

@@ -4,7 +4,6 @@ using System.Globalization;
 using System.Linq;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
-using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Jellyfin;
 using Flurl;
 using LanguageExt;
@@ -35,9 +34,7 @@ namespace ErsatzTV.Application.Movies
                     .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
                     .ToList(),
                 metadata.Directors.Map(d => d.Name).ToList(),
-                metadata.Writers.Map(w => w.Name).ToList(),
-                movie.GetHeadVersion().MediaFiles.Head().Path,
-                movie.State)
+                metadata.Writers.Map(w => w.Name).ToList())
             {
                 Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby),
                 FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby)

ErsatzTV.Application/Movies/MovieViewModel.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Globalization;
 using ErsatzTV.Application.MediaCards;
-using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Movies
 {
@@ -16,9 +15,7 @@ namespace ErsatzTV.Application.Movies
         List<CultureInfo> Languages,
         List<ActorCardViewModel> Actors,
         List<string> Directors,
-        List<string> Writers,
-        string Path,
-        MediaItemState MediaItemState)
+        List<string> Writers)
     {
         public string Poster { get; set; }
         public string FanArt { get; set; }

ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs

@@ -33,7 +33,7 @@ namespace ErsatzTV.Application.Movies.Queries
             GetMovieById request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs

@@ -8,6 +8,5 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
     public record CreateProgramSchedule(
         string Name,
         bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows,
-        bool ShuffleScheduleItems) : IRequest<Either<BaseError, CreateProgramScheduleResult>>;
+        bool TreatCollectionsAsShows) : IRequest<Either<BaseError, CreateProgramScheduleResult>>;
 }

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs

@@ -50,8 +50,7 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
                     {
                         Name = name,
                         KeepMultiPartEpisodesTogether = keepMultiPartEpisodesTogether,
-                        TreatCollectionsAsShows = keepMultiPartEpisodesTogether && request.TreatCollectionsAsShows,
-                        ShuffleScheduleItems = request.ShuffleScheduleItems
+                        TreatCollectionsAsShows = keepMultiPartEpisodesTogether && request.TreatCollectionsAsShows
                     };
                 });
 

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs

@@ -10,6 +10,5 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int ProgramScheduleId,
         string Name,
         bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows,
-        bool ShuffleScheduleItems) : IRequest<Either<BaseError, UpdateProgramScheduleResult>>;
+        bool TreatCollectionsAsShows) : IRequest<Either<BaseError, UpdateProgramScheduleResult>>;
 }

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs

@@ -31,7 +31,7 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             UpdateProgramSchedule request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
             Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
             return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
@@ -45,14 +45,12 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             // we need to rebuild playouts if the playback order or keep multi-episodes has been modified
             bool needToRebuildPlayout =
                 programSchedule.KeepMultiPartEpisodesTogether != request.KeepMultiPartEpisodesTogether ||
-                programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows ||
-                programSchedule.ShuffleScheduleItems != request.ShuffleScheduleItems;
+                programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows;
 
             programSchedule.Name = request.Name;
             programSchedule.KeepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
             programSchedule.TreatCollectionsAsShows = programSchedule.KeepMultiPartEpisodesTogether &&
                                                       request.TreatCollectionsAsShows;
-            programSchedule.ShuffleScheduleItems = request.ShuffleScheduleItems;
 
             await dbContext.SaveChangesAsync();
 

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -10,8 +10,7 @@ namespace ErsatzTV.Application.ProgramSchedules
                 programSchedule.Id,
                 programSchedule.Name,
                 programSchedule.KeepMultiPartEpisodesTogether,
-                programSchedule.TreatCollectionsAsShows,
-                programSchedule.ShuffleScheduleItems);
+                programSchedule.TreatCollectionsAsShows);
 
         internal static ProgramScheduleItemViewModel ProjectToViewModel(ProgramScheduleItem programScheduleItem) =>
             programScheduleItem switch

ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs

@@ -4,6 +4,5 @@
         int Id,
         string Name,
         bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows,
-        bool ShuffleScheduleItems);
+        bool TreatCollectionsAsShows);
 }

ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs

@@ -25,8 +25,7 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                         ps.Id,
                         ps.Name,
                         ps.KeepMultiPartEpisodesTogether,
-                        ps.TreatCollectionsAsShows,
-                        ps.ShuffleScheduleItems))
+                        ps.TreatCollectionsAsShows))
                 .ToListAsync(cancellationToken);
         }
     }

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleByIdHandler.cs

@@ -21,7 +21,7 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
             GetProgramScheduleById request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             return await dbContext.ProgramSchedules
                 .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
                 .MapT(ProjectToViewModel);

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs

@@ -4,7 +4,6 @@ using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
@@ -24,11 +23,7 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
             GetProgramScheduleItems request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            Option<ProgramSchedule> maybeProgramSchedule =
-                await dbContext.ProgramSchedules.SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id);
-
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             return await dbContext.ProgramScheduleItems
                 .Filter(psi => psi.ProgramScheduleId == request.Id)
                 .Include(i => i.Collection)
@@ -56,29 +51,7 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                 .Include(i => i.TailFiller)
                 .Include(i => i.FallbackFiller)
                 .ToListAsync(cancellationToken)
-                .Map(
-                    programScheduleItems => programScheduleItems.Map(ProjectToViewModel)
-                        .Map(psi => EnforceProperties(maybeProgramSchedule, psi)).ToList());
-        }
-
-        // shuffled schedule items supports a limited set of properly values
-        private ProgramScheduleItemViewModel EnforceProperties(
-            Option<ProgramSchedule> maybeProgramSchedule,
-            ProgramScheduleItemViewModel item)
-        {
-            foreach (ProgramSchedule programSchedule in maybeProgramSchedule)
-            {
-                if (programSchedule.ShuffleScheduleItems)
-                {
-                    item = item with { StartType = StartType.Dynamic };
-                    if (item.PlayoutMode == PlayoutMode.Flood)
-                    {
-                        item = item with { PlayoutMode = PlayoutMode.One };
-                    }
-                }
-            }
-
-            return item;
+                .Map(programScheduleItems => programScheduleItems.Map(ProjectToViewModel).ToList());
         }
     }
 }

ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs

@@ -5,7 +5,6 @@ using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -22,7 +21,6 @@ namespace ErsatzTV.Application.Streaming.Commands
         private readonly IServiceScopeFactory _serviceScopeFactory;
         private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
         private readonly IConfigElementRepository _configElementRepository;
-        private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
         private readonly ILocalFileSystem _localFileSystem;
 
         public StartFFmpegSessionHandler(
@@ -30,15 +28,13 @@ namespace ErsatzTV.Application.Streaming.Commands
             ILogger<StartFFmpegSessionHandler> logger,
             IServiceScopeFactory serviceScopeFactory,
             IFFmpegSegmenterService ffmpegSegmenterService,
-            IConfigElementRepository configElementRepository,
-            IHlsPlaylistFilter hlsPlaylistFilter)
+            IConfigElementRepository configElementRepository)
         {
             _localFileSystem = localFileSystem;
             _logger = logger;
             _serviceScopeFactory = serviceScopeFactory;
             _ffmpegSegmenterService = ffmpegSegmenterService;
             _configElementRepository = configElementRepository;
-            _hlsPlaylistFilter = hlsPlaylistFilter;
         }
 
         public Task<Either<BaseError, Unit>> Handle(StartFFmpegSession request, CancellationToken cancellationToken) =>
@@ -54,7 +50,7 @@ namespace ErsatzTV.Application.Streaming.Commands
             TimeSpan idleTimeout = await _configElementRepository
                 .GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout)
                 .Map(maybeTimeout => maybeTimeout.Match(i => TimeSpan.FromSeconds(i), () => TimeSpan.FromMinutes(1)));
-
+            
             using IServiceScope scope = _serviceScopeFactory.CreateScope();
             HlsSessionWorker worker = scope.ServiceProvider.GetRequiredService<HlsSessionWorker>();
             _ffmpegSegmenterService.SessionWorkers.AddOrUpdate(request.ChannelNumber, _ => worker, (_, _) => worker);
@@ -72,32 +68,12 @@ namespace ErsatzTV.Application.Streaming.Commands
                 request.ChannelNumber,
                 "live.m3u8");
 
-            IConfigElementRepository repo = scope.ServiceProvider.GetRequiredService<IConfigElementRepository>();
-            int initialSegmentCount = await repo.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount)
-                .Map(maybeCount => maybeCount.Match(identity, () => 1));
-
-            await WaitForPlaylistSegments(playlistFileName, initialSegmentCount, worker);
-
-            return Unit.Default;
-        }
-
-        private async Task WaitForPlaylistSegments(string playlistFileName, int initialSegmentCount, IHlsSessionWorker worker)
-        {
             while (!File.Exists(playlistFileName))
             {
                 await Task.Delay(TimeSpan.FromMilliseconds(100));
             }
 
-            var segmentCount = 0;
-            while (segmentCount < initialSegmentCount)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(200));
-                
-                DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
-                string[] input = await File.ReadAllLinesAsync(playlistFileName);
-                TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(worker.PlaylistStart, now, input);
-                segmentCount = result.SegmentCount;
-            }
+            return Unit.Default;
         }
 
         private Task<Validation<BaseError, Unit>> Validate(StartFFmpegSession request) =>

ErsatzTV.Application/Streaming/HlsSessionWorker.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Diagnostics;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Timers;
-using ErsatzTV.Application.Channels.Queries;
 using ErsatzTV.Application.Streaming.Queries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -24,7 +22,6 @@ namespace ErsatzTV.Application.Streaming
     public class HlsSessionWorker : IHlsSessionWorker
     {
         private static int _workAheadCount;
-        private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
         private readonly IServiceScopeFactory _serviceScopeFactory;
         private readonly ILogger<HlsSessionWorker> _logger;
         private DateTimeOffset _lastAccess;
@@ -32,11 +29,9 @@ namespace ErsatzTV.Application.Streaming
         private Timer _timer;
         private readonly object _sync = new();
         private DateTimeOffset _playlistStart;
-        private Option<int> _targetFramerate;
 
-        public HlsSessionWorker(IHlsPlaylistFilter hlsPlaylistFilter, IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
+        public HlsSessionWorker(IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
         {
-            _hlsPlaylistFilter = hlsPlaylistFilter;
             _serviceScopeFactory = serviceScopeFactory;
             _logger = logger;
         }
@@ -70,13 +65,6 @@ namespace ErsatzTV.Application.Streaming
                 CancellationToken cancellationToken = cts.Token;
 
                 _logger.LogInformation("Starting HLS session for channel {Channel}", channelNumber);
-                
-                using IServiceScope scope = _serviceScopeFactory.CreateScope();
-                IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-                _targetFramerate = await mediator.Send(
-                    new GetChannelFramerate(channelNumber),
-                    cancellationToken);
 
                 Touch();
                 _transcodedUntil = DateTimeOffset.Now;
@@ -125,11 +113,7 @@ namespace ErsatzTV.Application.Streaming
             }
         }
 
-        private async Task<bool> Transcode(
-            string channelNumber,
-            bool firstProcess,
-            bool realtime,
-            CancellationToken cancellationToken)
+        private async Task<bool> Transcode(string channelNumber, bool firstProcess, bool realtime, CancellationToken cancellationToken)
         {
             try
             {
@@ -148,17 +132,12 @@ namespace ErsatzTV.Application.Streaming
                 using IServiceScope scope = _serviceScopeFactory.CreateScope();
                 IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-                long ptsOffset = await GetPtsOffset(mediator, channelNumber, cancellationToken);
-                // _logger.LogInformation("PTS offset: {PtsOffset}", ptsOffset);
-
                 var request = new GetPlayoutItemProcessByChannelNumber(
                     channelNumber,
                     "segmenter",
                     firstProcess ? DateTimeOffset.Now : _transcodedUntil.AddSeconds(1),
                     !firstProcess,
-                    realtime,
-                    ptsOffset,
-                    _targetFramerate);
+                    realtime);
 
                 // _logger.LogInformation("Request {@Request}", request);
 
@@ -218,7 +197,7 @@ namespace ErsatzTV.Application.Streaming
 
             return true;
         }
-
+        
         private async Task TrimAndDelete(string channelNumber, CancellationToken cancellationToken)
         {
             string playlistFileName = Path.Combine(
@@ -230,66 +209,29 @@ namespace ErsatzTV.Application.Streaming
             {
                 // trim playlist and insert discontinuity before appending with new ffmpeg process
                 string[] lines = await File.ReadAllLinesAsync(playlistFileName, cancellationToken);
-                TrimPlaylistResult trimResult = _hlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
+                TrimPlaylistResult trimResult = HlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
                     _playlistStart,
                     DateTimeOffset.Now.AddMinutes(-1),
                     lines);
                 await File.WriteAllTextAsync(playlistFileName, trimResult.Playlist, cancellationToken);
 
                 // delete old segments
-                var allSegments = Directory.GetFiles(
-                        Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber),
-                        "live*.ts")
-                    .Map(
-                        file =>
-                        {
-                            string fileName = Path.GetFileName(file);
-                            var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
-                            return new Segment(file, sequenceNumber);
-                        })
-                    .ToList();
-
-                var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
-                // if (toDelete.Count > 0)
-                // {
-                // _logger.LogInformation(
-                //     "Deleting HLS segments {Min} to {Max} (less than {StartSequence})",
-                //     toDelete.Map(s => s.SequenceNumber).Min(),
-                //     toDelete.Map(s => s.SequenceNumber).Max(),
-                //     trimResult.Sequence);
-                // }
-
-                foreach (Segment segment in toDelete)
+                foreach (string file in Directory.GetFiles(
+                    Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber),
+                    "*.ts"))
                 {
-                    File.Delete(segment.File);
+                    string fileName = Path.GetFileName(file);
+                    if (fileName.StartsWith("live") && int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]) <
+                        trimResult.Sequence)
+                    {
+                        File.Delete(file);
+                    }
                 }
 
                 _playlistStart = trimResult.PlaylistStart;
             }
         }
 
-        private async Task<long> GetPtsOffset(IMediator mediator, string channelNumber, CancellationToken cancellationToken)
-        {
-            var directory = new DirectoryInfo(Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber));
-            Option<FileInfo> lastSegment =
-                Optional(directory.GetFiles("*.ts").OrderByDescending(f => f.Name).FirstOrDefault());
-
-            long result = 0;
-            foreach (FileInfo segment in lastSegment)
-            {
-                Either<BaseError, PtsAndDuration> queryResult = await mediator.Send(
-                    new GetLastPtsDuration(segment.FullName),
-                    cancellationToken);
-
-                foreach (PtsAndDuration ptsAndDuration in queryResult.RightToSeq())
-                {
-                    result = ptsAndDuration.Pts + ptsAndDuration.Duration;
-                }
-            }
-
-            return result;
-        }
-
         private async Task<int> GetWorkAheadLimit()
         {
             using IServiceScope scope = _serviceScopeFactory.CreateScope();
@@ -297,7 +239,5 @@ namespace ErsatzTV.Application.Streaming
             return await repo.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters)
                 .Map(maybeCount => maybeCount.Match(identity, () => 1));
         }
-
-        private record Segment(string File, int SequenceNumber);
     }
 }

ErsatzTV.Application/Streaming/PtsAndDuration.cs

@@ -1,16 +0,0 @@
-namespace ErsatzTV.Application.Streaming;
-
-public record PtsAndDuration(long Pts, long Duration)
-{
-    public static PtsAndDuration From(string ffprobeLine)
-    {
-        string[] split = ffprobeLine.Split("|");
-        var left = long.Parse(split[0]);
-        if (!long.TryParse(split[1], out long right))
-        {
-            // some durations are N/A, so we have to guess at something
-            right = 10_000;
-        }
-        return new PtsAndDuration(left, right);
-    }
-}

ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs

@@ -23,7 +23,7 @@ namespace ErsatzTV.Application.Streaming.Queries
 
         public async Task<Either<BaseError, PlayoutItemProcessModel>> Handle(T request, CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
             return await validation.Match(
                 tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
@@ -56,8 +56,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                         {
                             "hls-direct" => StreamingMode.HttpLiveStreamingDirect,
                             "segmenter" => StreamingMode.HttpLiveStreamingSegmenter,
-                            "ts" => StreamingMode.TransportStreamHybrid,
-                            "ts-legacy" => StreamingMode.TransportStream,
+                            "ts" => StreamingMode.TransportStream,
                             _ => channel.StreamingMode
                         };
 

ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs

@@ -11,6 +11,5 @@ namespace ErsatzTV.Application.Streaming.Queries
         string Mode,
         DateTimeOffset Now,
         bool StartAtZero,
-        bool HlsRealtime,
-        long PtsOffset) : IRequest<Either<BaseError, PlayoutItemProcessModel>>;
+        bool HlsRealtime) : IRequest<Either<BaseError, PlayoutItemProcessModel>>;
 }

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs

@@ -6,11 +6,10 @@ namespace ErsatzTV.Application.Streaming.Queries
     {
         public GetConcatProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
             channelNumber,
-            "ts-legacy",
+            "ts",
             DateTimeOffset.Now,
             false,
-            true,
-            0)
+            true)
         {
             Scheme = scheme;
             Host = host;

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
@@ -14,14 +15,17 @@ namespace ErsatzTV.Application.Streaming.Queries
 {
     public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
     {
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+        private readonly IFFmpegProcessService _ffmpegProcessService;
+        private readonly IRuntimeInfo _runtimeInfo;
 
         public GetConcatProcessByChannelNumberHandler(
             IDbContextFactory<TvContext> dbContextFactory,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+            IFFmpegProcessService ffmpegProcessService,
+            IRuntimeInfo runtimeInfo)
             : base(dbContextFactory)
         {
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+            _ffmpegProcessService = ffmpegProcessService;
+            _runtimeInfo = runtimeInfo;
         }
 
         protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
@@ -30,12 +34,11 @@ namespace ErsatzTV.Application.Streaming.Queries
             Channel channel,
             string ffmpegPath)
         {
-            bool saveReports = await dbContext.ConfigElements
+            bool saveReports = !_runtimeInfo.IsOSPlatform(OSPlatform.Windows) && await dbContext.ConfigElements
                 .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
                 .Map(result => result.IfNone(false));
 
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-            Process process = ffmpegProcessService.ConcatChannel(
+            Process process = _ffmpegProcessService.ConcatChannel(
                 ffmpegPath,
                 saveReports,
                 channel,

ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs

@@ -1,7 +0,0 @@
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.Streaming.Queries;
-
-public record GetLastPtsDuration(string FileName) : IRequest<Either<BaseError, PtsAndDuration>>;

ErsatzTV.Application/Streaming/Queries/GetLastPtsDurationHandler.cs

@@ -1,87 +0,0 @@
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.Streaming.Queries;
-
-public class GetLastPtsDurationHandler : IRequestHandler<GetLastPtsDuration, Either<BaseError, PtsAndDuration>>
-{
-    private readonly IConfigElementRepository _configElementRepository;
-
-    public GetLastPtsDurationHandler(IConfigElementRepository configElementRepository)
-    {
-        _configElementRepository = configElementRepository;
-    }
-
-    public async Task<Either<BaseError, PtsAndDuration>> Handle(
-        GetLastPtsDuration request,
-        CancellationToken cancellationToken)
-    {
-        Validation<BaseError, RequestParameters> validation = await Validate(request);
-        return await validation.Match(
-            Handle,
-            error => Task.FromResult<Either<BaseError, PtsAndDuration>>(error.Join()));
-    }
-
-    private async Task<Validation<BaseError, RequestParameters>> Validate(GetLastPtsDuration request) =>
-        await ValidateFFprobePath()
-            .MapT(
-                ffprobePath => new RequestParameters(
-                    request.FileName,
-                    ffprobePath));
-
-    private async Task<Either<BaseError, PtsAndDuration>> Handle(RequestParameters parameters)
-    {
-        var startInfo = new ProcessStartInfo
-        {
-            FileName = parameters.FFprobePath,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            UseShellExecute = false,
-            StandardOutputEncoding = Encoding.UTF8,
-            StandardErrorEncoding = Encoding.UTF8
-        };
-
-        startInfo.ArgumentList.Add("-v");
-        startInfo.ArgumentList.Add("0");
-        startInfo.ArgumentList.Add("-show_entries");
-        startInfo.ArgumentList.Add("packet=pts,duration");
-        startInfo.ArgumentList.Add("-of");
-        startInfo.ArgumentList.Add("compact=p=0:nk=1");
-        startInfo.ArgumentList.Add("-read_intervals");
-        startInfo.ArgumentList.Add("-999999");
-        startInfo.ArgumentList.Add(parameters.FileName);
-
-        var probe = new Process
-        {
-            StartInfo = startInfo
-        };
-
-        probe.Start();
-        return await probe.StandardOutput.ReadToEndAsync().MapAsync<string, Either<BaseError, PtsAndDuration>>(
-            async output =>
-            {
-                await probe.WaitForExitAsync();
-                return probe.ExitCode == 0
-                    ? PtsAndDuration.From(output.Split("\n").Filter(s => !string.IsNullOrWhiteSpace(s)).Last().Trim())
-                    : BaseError.New($"FFprobe at {parameters.FFprobePath} exited with code {probe.ExitCode}");
-            });
-    }
-
-    private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-        _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-            .FilterT(File.Exists)
-            .Map(
-                ffprobePath =>
-                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-    private record RequestParameters(string FileName, string FFprobePath);
-}

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs

@@ -1,18 +1,21 @@
 using System;
-using LanguageExt;
 
 namespace ErsatzTV.Application.Streaming.Queries
 {
-    public record GetPlayoutItemProcessByChannelNumber(string ChannelNumber,
-        string Mode,
-        DateTimeOffset Now,
-        bool StartAtZero,
-        bool HlsRealtime,
-        long PtsOffset,
-        Option<int> TargetFramerate) : FFmpegProcessRequest(ChannelNumber,
-        Mode,
-        Now,
-        StartAtZero,
-        HlsRealtime,
-        PtsOffset);
+    public record GetPlayoutItemProcessByChannelNumber : FFmpegProcessRequest
+    {
+        public GetPlayoutItemProcessByChannelNumber(
+            string channelNumber,
+            string mode,
+            DateTimeOffset now,
+            bool startAtZero,
+            bool hlsRealtime) : base(
+            channelNumber,
+            mode,
+            now,
+            startAtZero,
+            hlsRealtime)
+        {
+        }
+    }
 }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -2,19 +2,20 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Extensions;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -31,15 +32,16 @@ namespace ErsatzTV.Application.Streaming.Queries
         private readonly IMediaCollectionRepository _mediaCollectionRepository;
         private readonly ITelevisionRepository _televisionRepository;
         private readonly IArtistRepository _artistRepository;
+        private readonly IFFmpegProcessService _ffmpegProcessService;
         private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
         private readonly ILocalFileSystem _localFileSystem;
         private readonly IPlexPathReplacementService _plexPathReplacementService;
+        private readonly IRuntimeInfo _runtimeInfo;
         private readonly ISongVideoGenerator _songVideoGenerator;
 
         public GetPlayoutItemProcessByChannelNumberHandler(
             IDbContextFactory<TvContext> dbContextFactory,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+            IFFmpegProcessService ffmpegProcessService,
             ILocalFileSystem localFileSystem,
             IPlexPathReplacementService plexPathReplacementService,
             IJellyfinPathReplacementService jellyfinPathReplacementService,
@@ -47,10 +49,11 @@ namespace ErsatzTV.Application.Streaming.Queries
             IMediaCollectionRepository mediaCollectionRepository,
             ITelevisionRepository televisionRepository,
             IArtistRepository artistRepository,
+            IRuntimeInfo runtimeInfo,
             ISongVideoGenerator songVideoGenerator)
             : base(dbContextFactory)
         {
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+            _ffmpegProcessService = ffmpegProcessService;
             _localFileSystem = localFileSystem;
             _plexPathReplacementService = plexPathReplacementService;
             _jellyfinPathReplacementService = jellyfinPathReplacementService;
@@ -58,6 +61,7 @@ namespace ErsatzTV.Application.Streaming.Queries
             _mediaCollectionRepository = mediaCollectionRepository;
             _televisionRepository = televisionRepository;
             _artistRepository = artistRepository;
+            _runtimeInfo = runtimeInfo;
             _songVideoGenerator = songVideoGenerator;
         }
 
@@ -112,8 +116,6 @@ namespace ErsatzTV.Application.Streaming.Queries
                 maybePlayoutItem = await CheckForFallbackFiller(dbContext, channel, now);
             }
 
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-
             return await maybePlayoutItem.Match(
                 async playoutItemWithPath =>
                 {
@@ -140,11 +142,11 @@ namespace ErsatzTV.Application.Streaming.Queries
                             ffmpegPath);
                     }
 
-                    bool saveReports = await dbContext.ConfigElements
+                    bool saveReports = !_runtimeInfo.IsOSPlatform(OSPlatform.Windows) && await dbContext.ConfigElements
                         .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
                         .Map(result => result.IfNone(false));
 
-                    Process process = await ffmpegProcessService.ForPlayoutItem(
+                    Process process = await _ffmpegProcessService.ForPlayoutItem(
                         ffmpegPath,
                         saveReports,
                         channel,
@@ -161,9 +163,7 @@ namespace ErsatzTV.Application.Streaming.Queries
                         request.HlsRealtime,
                         playoutItemWithPath.PlayoutItem.FillerKind,
                         playoutItemWithPath.PlayoutItem.InPoint,
-                        playoutItemWithPath.PlayoutItem.OutPoint,
-                        request.PtsOffset,
-                        request.TargetFramerate);
+                        playoutItemWithPath.PlayoutItem.OutPoint);
 
                     var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
 
@@ -193,13 +193,12 @@ namespace ErsatzTV.Application.Streaming.Queries
                         case UnableToLocatePlayoutItem:
                             if (channel.FFmpegProfile.Transcode)
                             {
-                                Process errorProcess = await ffmpegProcessService.ForError(
+                                Process errorProcess = await _ffmpegProcessService.ForError(
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
                                     "Channel is Offline",
-                                    request.HlsRealtime,
-                                    request.PtsOffset);
+                                    request.HlsRealtime);
                                 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }
@@ -213,13 +212,12 @@ namespace ErsatzTV.Application.Streaming.Queries
                         case PlayoutItemDoesNotExistOnDisk:
                             if (channel.FFmpegProfile.Transcode)
                             {
-                                Process errorProcess = await ffmpegProcessService.ForError(
+                                Process errorProcess = await _ffmpegProcessService.ForError(
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
                                     error.Value,
-                                    request.HlsRealtime,
-                                    request.PtsOffset);
+                                    request.HlsRealtime);
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }
@@ -233,13 +231,12 @@ namespace ErsatzTV.Application.Streaming.Queries
                         default:
                             if (channel.FFmpegProfile.Transcode)
                             {
-                                Process errorProcess = await ffmpegProcessService.ForError(
+                                Process errorProcess = await _ffmpegProcessService.ForError(
                                     ffmpegPath,
                                     channel,
                                     maybeDuration,
                                     "Channel is Offline",
-                                    request.HlsRealtime,
-                                    request.PtsOffset);
+                                    request.HlsRealtime);
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs

@@ -1,22 +0,0 @@
-using System;
-
-namespace ErsatzTV.Application.Streaming.Queries
-{
-    public record GetWrappedProcessByChannelNumber : FFmpegProcessRequest
-    {
-        public GetWrappedProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
-            channelNumber,
-            "ts",
-            DateTimeOffset.Now,
-            false,
-            true,
-            0)
-        {
-            Scheme = scheme;
-            Host = host;
-        }
-
-        public string Scheme { get; }
-        public string Host { get; }
-    }
-}

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs

@@ -1,48 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.FFmpeg;
-using ErsatzTV.Core.Interfaces.FFmpeg;
-using ErsatzTV.Infrastructure.Data;
-using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using Microsoft.EntityFrameworkCore;
-
-namespace ErsatzTV.Application.Streaming.Queries
-{
-    public class GetWrappedProcessByChannelNumberHandler : FFmpegProcessHandler<GetWrappedProcessByChannelNumber>
-    {
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
-
-        public GetWrappedProcessByChannelNumberHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
-            : base(dbContextFactory)
-        {
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
-        }
-
-        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
-            TvContext dbContext,
-            GetWrappedProcessByChannelNumber request,
-            Channel channel,
-            string ffmpegPath)
-        {
-            bool saveReports = await dbContext.ConfigElements
-                .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
-                .Map(result => result.IfNone(false));
-
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-            Process process = ffmpegProcessService.WrapSegmenter(
-                ffmpegPath,
-                saveReports,
-                channel,
-                request.Scheme,
-                request.Host);
-
-            return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
-        }
-    }
-}

ErsatzTV.Application/Watermarks/Commands/CreateWatermark.cs

@@ -1,6 +1,5 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.FFmpeg.State;
 using LanguageExt;
 using MediatR;
 
@@ -11,8 +10,8 @@ namespace ErsatzTV.Application.Watermarks.Commands
         string Image,
         ChannelWatermarkMode Mode,
         ChannelWatermarkImageSource ImageSource,
-        WatermarkLocation Location,
-        WatermarkSize Size,
+        ChannelWatermarkLocation Location,
+        ChannelWatermarkSize Size,
         int Width,
         int HorizontalMargin,
         int VerticalMargin,

ErsatzTV.Application/Watermarks/Commands/UpdateWatermark.cs

@@ -1,6 +1,5 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.FFmpeg.State;
 using LanguageExt;
 using MediatR;
 
@@ -12,8 +11,8 @@ namespace ErsatzTV.Application.Watermarks.Commands
         string Image,
         ChannelWatermarkMode Mode,
         ChannelWatermarkImageSource ImageSource,
-        WatermarkLocation Location,
-        WatermarkSize Size,
+        ChannelWatermarkLocation Location,
+        ChannelWatermarkSize Size,
         int Width,
         int HorizontalMargin,
         int VerticalMargin,

ErsatzTV.Application/Watermarks/Commands/UpdateWatermarkHandler.cs

@@ -21,7 +21,7 @@ namespace ErsatzTV.Application.Watermarks.Commands
             UpdateWatermark request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             Validation<BaseError, ChannelWatermark> validation = await Validate(dbContext, request);
             return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
         }

ErsatzTV.Application/Watermarks/WatermarkViewModel.cs

@@ -1,5 +1,4 @@
 using ErsatzTV.Core.Domain;
-using ErsatzTV.FFmpeg.State;
 
 namespace ErsatzTV.Application.Watermarks
 {
@@ -9,8 +8,8 @@ namespace ErsatzTV.Application.Watermarks
         string Name,
         ChannelWatermarkMode Mode,
         ChannelWatermarkImageSource ImageSource,
-        WatermarkLocation Location,
-        WatermarkSize Size,
+        ChannelWatermarkLocation Location,
+        ChannelWatermarkSize Size,
         int Width,
         int HorizontalMargin,
         int VerticalMargin,

ErsatzTV.CommandLine/Commands/ChannelCommand.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.CommandLine.Commands
+{
+    [Command("channel", Description = "Create or rename a channel")]
+    public class ChannelCommand : ICommand
+    {
+        private readonly ChannelsApi _channelsApi;
+        private readonly FFmpegProfileApi _ffmpegProfileApi;
+        private readonly ILogger<ChannelCommand> _logger;
+
+        public ChannelCommand(IConfiguration configuration, ILogger<ChannelCommand> logger)
+        {
+            _logger = logger;
+            _channelsApi = new ChannelsApi(configuration["ServerUrl"]);
+            _ffmpegProfileApi = new FFmpegProfileApi(configuration["ServerUrl"]);
+        }
+
+        [CommandParameter(0, Name = "channel-number", Description = "The channel number")]
+        public int Number { get; set; }
+
+        [CommandParameter(1, Name = "channel-name", Description = "The channel name")]
+        public string Name { get; set; }
+
+        [CommandParameter(2, Name = "streaming-mode", Description = "The streaming mode")]
+        public StreamingMode StreamingMode { get; set; }
+
+        [CommandOption("ffmpeg-profile", Description = "The ffmpeg profile name")]
+        public string FFmpegProfileName { get; set; }
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                Option<ChannelViewModel> maybeChannel = await _channelsApi.ApiChannelsGetAsync()
+                    .Map(list => Optional(list.SingleOrDefault(c => c.Number == Number)));
+
+                FFmpegProfileViewModel ffmpegProfile = await _ffmpegProfileApi.ApiFfmpegProfilesGetAsync()
+                    .Map(
+                        list => Optional(list.SingleOrDefault(p => p.Name == FFmpegProfileName))
+                            .IfNone(new FFmpegProfileViewModel { Id = 1 }));
+
+                await maybeChannel.Match(
+                    channel => RenameChannel(channel, ffmpegProfile),
+                    () => AddChannel(ffmpegProfile));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to synchronize channel: {Message}", ex.Message);
+            }
+        }
+
+        private async ValueTask RenameChannel(ChannelViewModel existing, FFmpegProfileViewModel ffmpegProfile)
+        {
+            int newFFmpegProfileId = string.IsNullOrWhiteSpace(FFmpegProfileName)
+                ? existing.FfmpegProfileId
+                : ffmpegProfile.Id;
+
+            if (existing.Name != Name || existing.FfmpegProfileId != newFFmpegProfileId ||
+                existing.StreamingMode != StreamingMode)
+            {
+                var updateChannel = new UpdateChannel(
+                    existing.Id,
+                    Name,
+                    existing.Number,
+                    newFFmpegProfileId,
+                    existing.Logo,
+                    StreamingMode);
+
+                await _channelsApi.ApiChannelsPatchAsync(updateChannel);
+            }
+
+            _logger.LogInformation(
+                "Successfully synchronized channel {ChannelNumber} - {ChannelName}",
+                Number,
+                Name);
+        }
+
+        private async ValueTask AddChannel(FFmpegProfileViewModel ffmpegProfile)
+        {
+            var createChannel = new CreateChannel(
+                Name,
+                Number,
+                ffmpegProfile.Id,
+                null,
+                StreamingMode);
+
+            await _channelsApi.ApiChannelsPostAsync(createChannel);
+
+            _logger.LogInformation(
+                "Successfully created channel {ChannelNumber} - {ChannelName}",
+                Number,
+                Name);
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/ConfigCommand.cs

@@ -0,0 +1,31 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+
+namespace ErsatzTV.CommandLine.Commands
+{
+    [Command("config", Description = "Configure ErsatzTV server url")]
+    public class ConfigCommand : ICommand
+    {
+        [CommandParameter(0, Name = "server-url", Description = "The url of the ErsatzTV server")]
+        public string ServerUrl { get; set; }
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            // TODO: validate URL
+
+            string configFolder = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                "ersatztv");
+
+            string configFile = Path.Combine(configFolder, "cli.json");
+
+            var config = new Config { ServerUrl = ServerUrl };
+            string contents = JsonSerializer.Serialize(config);
+            await File.WriteAllTextAsync(configFile, contents);
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/FFmpegProfileCommand.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.CommandLine.Commands
+{
+    [Command("ffmpeg-profile", Description = "Synchronize an ffmpeg profile")]
+    public class FFmpegProfileCommand : ICommand
+    {
+        private readonly FFmpegProfileApi _ffmpegProfileApi;
+        private readonly ILogger<FFmpegProfileCommand> _logger;
+
+        public FFmpegProfileCommand(IConfiguration configuration, ILogger<FFmpegProfileCommand> logger)
+        {
+            _logger = logger;
+            _ffmpegProfileApi = new FFmpegProfileApi(configuration["ServerUrl"]);
+        }
+
+        [CommandParameter(0, Name = "profile-name", Description = "The ffmpeg profile name")]
+        public string Name { get; set; }
+
+        [CommandOption("thread-count", Description = "The number of threads")]
+        public int ThreadCount { get; set; } = 0;
+
+        [CommandOption("transcode", Description = "Whether to transcode all media")]
+        public bool Transcode { get; set; } = true;
+
+        // public int ResolutionId { get; set; } = resolution.Id;
+        // Resolution { get; set; } = resolution;
+        [CommandOption("resolution", Description = "The resolution")]
+        public DesiredResolution Resolution { get; set; } = DesiredResolution.W1920H1080;
+
+        [CommandOption("video-codec", Description = "The video codec")]
+        public string VideoCodec { get; set; } = "libx264";
+
+        [CommandOption("audio-codec", Description = "The audio codec")]
+        public string AudioCodec { get; set; } = "ac3";
+
+        [CommandOption("video-bitrate", Description = "The video bitrate in kBit/s")]
+        public int VideoBitrate { get; set; } = 2000;
+
+        [CommandOption("video-buffer-size", Description = "The video buffer size in kBit")]
+        public int VideoBufferSize { get; set; } = 2000;
+
+        [CommandOption("audio-bitrate", Description = "The audio bitrate in kBit/s")]
+        public int AudioBitrate { get; set; } = 192;
+
+        [CommandOption("audio-buffer-size", Description = "The audio buffer size in kBits")]
+        public int AudioBufferSize { get; set; } = 50;
+
+        [CommandOption("audio-volume", Description = "The audio volume as a whole number percent")]
+        public int AudioVolume { get; set; } = 100;
+
+        [CommandOption("audio-channels", Description = "The number of audio channels")]
+        public int AudioChannels { get; set; } = 2;
+
+        [CommandOption("audio-sample-rate", Description = "The audio sample rate in kHz")]
+        public int AudioSampleRate { get; set; } = 48;
+
+        [CommandOption("normalize-resolution", Description = "Whether to normalize the resolution of all media")]
+        public bool NormalizeResolution { get; set; } = true;
+
+        [CommandOption("normalize-video-codec", Description = "Whether to normalize the video codec of all media")]
+        public bool NormalizeVideoCodec { get; set; } = true;
+
+        [CommandOption("normalize-audio-codec", Description = "Whether to normalize the audio codec of all media")]
+        public bool NormalizeAudioCodec { get; set; } = true;
+
+        [CommandOption(
+            "normalize-audio",
+            Description = "Whether to normalize audio channels and sample rate of all media")]
+        public bool NormalizeAudio { get; set; } = true;
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                Option<FFmpegProfileViewModel> maybeFFmpegProfile = await _ffmpegProfileApi.ApiFfmpegProfilesGetAsync()
+                    .Map(list => Optional(list.SingleOrDefault(p => p.Name == Name)));
+
+                await maybeFFmpegProfile.Match(UpdateProfile, AddProfile);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to synchronize ffmpeg profile: {Message}", ex.Message);
+            }
+        }
+
+        private async ValueTask UpdateProfile(FFmpegProfileViewModel existing)
+        {
+            var updateFFmpegProfile = new UpdateFFmpegProfile(
+                existing.Id,
+                Name,
+                ThreadCount,
+                Transcode,
+                (int) Resolution,
+                NormalizeResolution,
+                VideoCodec,
+                NormalizeVideoCodec,
+                VideoBitrate,
+                VideoBufferSize,
+                AudioCodec,
+                NormalizeAudioCodec,
+                AudioBitrate,
+                AudioBufferSize,
+                AudioVolume,
+                AudioChannels,
+                AudioSampleRate,
+                NormalizeAudio);
+
+            await _ffmpegProfileApi.ApiFfmpegProfilesPatchAsync(updateFFmpegProfile);
+
+            _logger.LogInformation("Successfully synchronized ffmpeg profile {ProfileName}", Name);
+        }
+
+        private async ValueTask AddProfile()
+        {
+            var createFFmpegProfile = new CreateFFmpegProfile(
+                Name,
+                ThreadCount,
+                Transcode,
+                (int) Resolution,
+                NormalizeResolution,
+                VideoCodec,
+                NormalizeVideoCodec,
+                VideoBitrate,
+                VideoBufferSize,
+                AudioCodec,
+                NormalizeAudioCodec,
+                AudioBitrate,
+                AudioBufferSize,
+                AudioVolume,
+                AudioChannels,
+                AudioSampleRate,
+                NormalizeAudio);
+
+
+            await _ffmpegProfileApi.ApiFfmpegProfilesPostAsync(createFFmpegProfile);
+
+            _logger.LogInformation("Successfully created ffmpeg profile {ProfileName}", Name);
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/MediaCollections/MediaCollectionClearCommand.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using LanguageExt.Common;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.CommandLine.Commands.MediaCollections
+{
+    [Command("collection clear", Description = "Removes all items from a media collection")]
+    public class MediaCollectionClearCommand : ICommand
+    {
+        private readonly ILogger<MediaCollectionClearCommand> _logger;
+        private readonly string _serverUrl;
+
+        public MediaCollectionClearCommand(IConfiguration configuration, ILogger<MediaCollectionClearCommand> logger)
+        {
+            _logger = logger;
+            _serverUrl = configuration["ServerUrl"];
+        }
+
+        [CommandParameter(0, Name = "collection-name", Description = "The name of the media collection")]
+        public string Name { get; set; }
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                CancellationToken cancellationToken = console.GetCancellationToken();
+
+                Either<Error, Unit> result = await ClearMediaCollection(cancellationToken);
+
+                result.Match(
+                    _ => _logger.LogInformation("Successfully cleared media collection {MediaCollection}", Name),
+                    error => _logger.LogError(
+                        "Unable to clear media collection: {Error}",
+                        error.Message));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to clear media collection: {Error}", ex.Message);
+            }
+        }
+
+        private async Task<Either<Error, Unit>> ClearMediaCollection(CancellationToken cancellationToken) =>
+            await EnsureMediaCollectionExists(cancellationToken)
+                .BindAsync(mediaCollectionId => ClearMediaCollectionImpl(mediaCollectionId, cancellationToken));
+
+        private async Task<Either<Error, int>> EnsureMediaCollectionExists(CancellationToken cancellationToken)
+        {
+            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
+            Option<MediaCollectionViewModel> maybeExisting =
+                (await mediaCollectionsApi.ApiMediaCollectionsGetAsync(cancellationToken))
+                .SingleOrDefault(mc => mc.Name == Name);
+            return await maybeExisting.MatchAsync(
+                existing => existing.Id,
+                async () =>
+                {
+                    var data = new CreateSimpleMediaCollection(Name);
+                    MediaCollectionViewModel result =
+                        await mediaCollectionsApi.ApiMediaCollectionsPostAsync(data, cancellationToken);
+                    return result.Id;
+                });
+        }
+
+        private async Task<Either<Error, Unit>> ClearMediaCollectionImpl(
+            int mediaCollectionId,
+            CancellationToken cancellationToken)
+        {
+            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
+            await mediaCollectionsApi.ApiMediaCollectionsIdItemsPutAsync(
+                mediaCollectionId,
+                new List<int>(),
+                cancellationToken);
+            return unit;
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/MediaCollections/MediaCollectionCreateCommand.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using LanguageExt.Common;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.CommandLine.Commands.MediaCollections
+{
+    [Command("collection create", Description = "Creates a new media collection")]
+    public class MediaCollectionCreateCommand : ICommand
+    {
+        private readonly ILogger<MediaCollectionCreateCommand> _logger;
+        private readonly string _serverUrl;
+
+        public MediaCollectionCreateCommand(IConfiguration configuration, ILogger<MediaCollectionCreateCommand> logger)
+        {
+            _logger = logger;
+            _serverUrl = configuration["ServerUrl"];
+        }
+
+        [CommandParameter(0, Name = "collection-name", Description = "The name of the media collection")]
+        public string Name { get; set; }
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                CancellationToken cancellationToken = console.GetCancellationToken();
+
+                Either<Error, Unit> result = await CreateMediaCollection(cancellationToken);
+                result.IfLeft(error => _logger.LogError("Unable to create media collection: {Error}", error.Message));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to create media collection: {Error}", ex.Message);
+            }
+        }
+
+        private async Task<Either<Error, Unit>> CreateMediaCollection(CancellationToken cancellationToken) =>
+            await EnsureMediaCollectionExists(cancellationToken);
+
+        private async Task<Either<Error, Unit>> EnsureMediaCollectionExists(CancellationToken cancellationToken)
+        {
+            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
+
+            bool needToAdd = await mediaCollectionsApi
+                .ApiMediaCollectionsGetAsync(cancellationToken)
+                .Map(list => list.All(mc => mc.Name != Name));
+
+            if (needToAdd)
+            {
+                var data = new CreateSimpleMediaCollection(Name);
+                await mediaCollectionsApi.ApiMediaCollectionsPostAsync(data, cancellationToken);
+                _logger.LogInformation("Successfully created media collection {MediaCollection}", Name);
+            }
+            else
+            {
+                _logger.LogInformation("Media collection {MediaCollection} is already present", Name);
+            }
+
+            return unit;
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/PlayoutCommand.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.CommandLine.Commands
+{
+    [Command("playout build", Description = "Builds a playout with the requested channel and schedule")]
+    public class PlayoutCommand : ICommand
+    {
+        private readonly ILogger<PlayoutCommand> _logger;
+        private readonly string _serverUrl;
+
+        public PlayoutCommand(IConfiguration configuration, ILogger<PlayoutCommand> logger)
+        {
+            _logger = logger;
+            _serverUrl = configuration["ServerUrl"];
+        }
+
+        [CommandParameter(0, Name = "channel-number", Description = "The channel number")]
+        public int ChannelNumber { get; set; }
+
+        [CommandParameter(1, Name = "schedule-name", Description = "The schedule name")]
+        public string ScheduleName { get; set; }
+
+        // [Option("--type <type>")]
+        // [Required]
+        // public ProgramSchedulePlayoutType PlayoutType { get; set; }
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                CancellationToken cancellationToken = console.GetCancellationToken();
+
+                var channelsApi = new ChannelsApi(_serverUrl);
+                Option<ChannelViewModel> maybeChannel = await channelsApi.ApiChannelsGetAsync(cancellationToken)
+                    .Map(list => list.SingleOrDefault(c => c.Number == ChannelNumber));
+
+                await maybeChannel.Match(
+                    channel => BuildPlayout(cancellationToken, channel),
+                    () =>
+                    {
+                        _logger.LogError("Unable to locate channel number {ChannelNumber}", ChannelNumber);
+                        return ValueTask.CompletedTask;
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to build playout: {Error}", ex.Message);
+            }
+        }
+
+        private async ValueTask BuildPlayout(CancellationToken cancellationToken, ChannelViewModel channel)
+        {
+            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
+            Option<ProgramScheduleViewModel> maybeSchedule = await programScheduleApi
+                .ApiSchedulesGetAsync(cancellationToken)
+                .Map(list => list.SingleOrDefault(s => s.Name == ScheduleName));
+
+            await maybeSchedule.Match(
+                schedule => SynchronizePlayoutAsync(channel.Id, schedule.Id, cancellationToken),
+                () =>
+                {
+                    _logger.LogError("Unable to locate schedule {Schedule}", ScheduleName);
+                    return ValueTask.CompletedTask;
+                });
+        }
+
+        private async ValueTask SynchronizePlayoutAsync(
+            int channelId,
+            int scheduleId,
+            CancellationToken cancellationToken)
+        {
+            var playoutApi = new PlayoutApi(_serverUrl);
+            Option<PlayoutViewModel> maybeExisting = await playoutApi.ApiPlayoutsGetAsync(cancellationToken)
+                .Map(list => list.SingleOrDefault(p => p.Channel.Id == channelId));
+            await maybeExisting.Match(
+                existing =>
+                {
+                    var data = new UpdatePlayout(existing.Id, channelId, scheduleId, ProgramSchedulePlayoutType.Flood);
+                    if (existing.Channel.Id != data.ChannelId ||
+                        existing.ProgramSchedule.Id != data.ProgramScheduleId ||
+                        existing.ProgramSchedulePlayoutType != data.ProgramSchedulePlayoutType)
+                    {
+                        return playoutApi.ApiPlayoutsPatchAsync(data, cancellationToken);
+                    }
+
+                    return Task.CompletedTask;
+                },
+                () =>
+                {
+                    var data = new CreatePlayout(channelId, scheduleId, ProgramSchedulePlayoutType.Flood);
+                    return playoutApi.ApiPlayoutsPostAsync(data, cancellationToken);
+                });
+
+            _logger.LogInformation("Successfully built playout for schedule {Schedule}", ScheduleName);
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/Schedules/ScheduleAddItemCommand.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace ErsatzTV.CommandLine.Commands.Schedules
+{
+    [Command("schedule add-item", Description = "Adds an item to the end of a schedule")]
+    public class ScheduleAddItemCommand : ICommand
+    {
+        private readonly ILogger<ScheduleAddItemCommand> _logger;
+        private readonly string _serverUrl;
+
+        public ScheduleAddItemCommand(IConfiguration configuration, ILogger<ScheduleAddItemCommand> logger)
+        {
+            _logger = logger;
+            _serverUrl = configuration["ServerUrl"];
+        }
+
+        [CommandParameter(0, Name = "schedule-name", Description = "The schedule name")]
+        public string ScheduleName { get; set; }
+
+        [CommandParameter(1, Name = "collection-name", Description = "The media collection name")]
+        public string CollectionName { get; set; }
+
+        // [CommandParameter(2, Description = "The collection playback order")]
+        // public PlaybackOrder Order { get; set; }
+
+        [CommandOption("start-type", 's', Description = "The playout start type")]
+        public StartType StartType { get; set; } = StartType.Dynamic;
+
+        [CommandOption("start-time", 't', Description = "The playout start time (of day)")]
+        public string StartTime { get; set; } = null;
+
+        [CommandOption("playout-mode", 'm', Description = "The playout mode")]
+        public PlayoutMode PlayoutMode { get; set; } = PlayoutMode.Flood;
+
+        [CommandOption(
+            "multiple-count",
+            'c',
+            Description = "How many items to play from the collection (for Multiple playout mode)")]
+        public int? MultipleCount { get; set; } = null;
+
+        [CommandOption(
+            "playout-duration",
+            'd',
+            Description = "How long to play items from the collection (for Duration playout mode)")]
+        public string PlayoutDuration { get; set; } = null;
+
+        [CommandOption(
+            "offline-tail",
+            'o',
+            Description =
+                "Whether to remain offline for the entire duration, or to start the next item immediately (for Duration playout mode)")]
+        public bool? OfflineTail { get; set; } = null;
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                CancellationToken cancellationToken = console.GetCancellationToken();
+
+                Option<ProgramScheduleViewModel> maybeSchedule = await GetSchedule(cancellationToken);
+                await maybeSchedule.Match(
+                    programSchedule => AddItemToSchedule(cancellationToken, programSchedule),
+                    () =>
+                    {
+                        _logger.LogError("Unable to locate schedule {Schedule}", ScheduleName);
+                        return ValueTask.CompletedTask;
+                    });
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to add item to schedule: {Error}", ex.Message);
+            }
+        }
+
+        private async ValueTask AddItemToSchedule(
+            CancellationToken cancellationToken,
+            ProgramScheduleViewModel programSchedule)
+        {
+            var mediaCollectionsApi = new MediaCollectionsApi(_serverUrl);
+            Option<MediaCollectionViewModel> maybeMediaCollection = await mediaCollectionsApi
+                .ApiMediaCollectionsGetAsync(cancellationToken)
+                .Map(list => list.SingleOrDefault(mc => mc.Name == CollectionName));
+
+            await maybeMediaCollection.Match(
+                collection =>
+                    AddScheduleItem(programSchedule.Id, collection.Id, cancellationToken),
+                () =>
+                {
+                    _logger.LogError(
+                        "Unable to locate collection {Collection}",
+                        CollectionName);
+                    return Task.CompletedTask;
+                });
+        }
+
+        private async Task<Option<ProgramScheduleViewModel>> GetSchedule(CancellationToken cancellationToken)
+        {
+            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
+            return await programScheduleApi.ApiSchedulesGetAsync(cancellationToken)
+                .Map(list => list.SingleOrDefault(schedule => schedule.Name == ScheduleName));
+        }
+
+        private async Task AddScheduleItem(
+            int programScheduleId,
+            int mediaCollectionId,
+            CancellationToken cancellationToken)
+        {
+            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
+
+            var request = new AddProgramScheduleItem
+            {
+                ProgramScheduleId = programScheduleId,
+                StartType = StartType,
+                StartTime = StartTime,
+                PlayoutMode = PlayoutMode,
+                MediaCollectionId = mediaCollectionId,
+                PlayoutDuration = PlayoutDuration,
+                MultipleCount = MultipleCount,
+                OfflineTail = OfflineTail
+            };
+
+            await programScheduleApi.ApiSchedulesItemsAddPostAsync(request, cancellationToken);
+
+            _logger.LogInformation(
+                "Collection {Collection} has been added to schedule {Schedule}",
+                CollectionName,
+                ScheduleName);
+        }
+    }
+}

ErsatzTV.CommandLine/Commands/Schedules/ScheduleCreateCommand.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using ErsatzTV.Api.Sdk.Api;
+using ErsatzTV.Api.Sdk.Model;
+using LanguageExt;
+using LanguageExt.Common;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.CommandLine.Commands.Schedules
+{
+    [Command("schedule create", Description = "Creates a new schedule")]
+    public class ScheduleCreateCommand : ICommand
+    {
+        private readonly ILogger<ScheduleCreateCommand> _logger;
+        private readonly string _serverUrl;
+
+        public ScheduleCreateCommand(IConfiguration configuration, ILogger<ScheduleCreateCommand> logger)
+        {
+            _logger = logger;
+            _serverUrl = configuration["ServerUrl"];
+        }
+
+        [CommandParameter(0, Name = "schedule-name", Description = "The schedule name")]
+        public string Name { get; set; }
+
+        [CommandParameter(1, Name = "playback-order", Description = "The collection playback order")]
+        public PlaybackOrder Order { get; set; }
+
+        [CommandOption("reset", Description = "Resets the schedule to contain no items")]
+        public bool Reset { get; set; }
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                CancellationToken cancellationToken = console.GetCancellationToken();
+
+                Either<Error, Unit> result = await EnsureScheduleExistsAsync(cancellationToken);
+                result.IfLeft(error => _logger.LogError("Unable to create schedule: {Error}", error.Message));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError("Unable to create schedule: {Error}", ex.Message);
+            }
+        }
+
+        private async Task<Either<Error, Unit>> EnsureScheduleExistsAsync(CancellationToken cancellationToken)
+        {
+            var programScheduleApi = new ProgramScheduleApi(_serverUrl);
+
+            Option<ProgramScheduleViewModel> maybeExisting = await programScheduleApi
+                .ApiSchedulesGetAsync(cancellationToken)
+                .Map(list => list.SingleOrDefault(schedule => schedule.Name == Name));
+
+            await maybeExisting.Match(
+                existing =>
+                {
+                    // TODO: update playback order if changed?
+                    _logger.LogInformation("Schedule {Schedule} is already present", Name);
+
+                    if (Reset)
+                    {
+                        return programScheduleApi
+                            .ApiSchedulesProgramScheduleIdItemsDeleteAsync(existing.Id, cancellationToken)
+                            .Iter(_ => _logger.LogInformation("Successfully reset schedule {Schedule}", Name));
+                    }
+
+                    return Task.CompletedTask;
+                },
+                () =>
+                {
+                    var data = new CreateProgramSchedule(Name, Order);
+                    return programScheduleApi.ApiSchedulesPostAsync(data, cancellationToken)
+                        .Iter(_ => _logger.LogInformation("Successfully created schedule {Schedule}", Name));
+                });
+
+            return unit;
+        }
+    }
+}

ErsatzTV.CommandLine/Config.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.CommandLine
+{
+    public class Config
+    {
+        public string ServerUrl { get; set; }
+    }
+}

ErsatzTV.CommandLine/DesiredResolution.cs

@@ -0,0 +1,10 @@
+namespace ErsatzTV.CommandLine
+{
+    public enum DesiredResolution
+    {
+        W720H480 = 1,
+        W1280H720 = 2,
+        W1920H1080 = 3,
+        W3840H2160 = 4
+    }
+}

ErsatzTV.CommandLine/ErsatzTV.CommandLine.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net5.0</TargetFramework>
+        <AssemblyName>ersatztv-cli</AssemblyName>
+        <LangVersion>9</LangVersion>
+        <PackageVersion>0.0.1</PackageVersion>
+        <AssemblyVersion>0.0.1</AssemblyVersion>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="CliFx" Version="1.6.0" />
+      <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="5.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
+      <PackageReference Include="Microsoft.Extensions.Logging" Version="5.0.0" />
+      <PackageReference Include="RestSharp" Version="106.11.7" />
+      <PackageReference Include="Serilog" Version="2.10.0" />
+      <PackageReference Include="Serilog.Extensions.Hosting" Version="4.1.2" />
+      <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
+      <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\generated\ErsatzTV.Api.Sdk\src\ErsatzTV.Api.Sdk\ErsatzTV.Api.Sdk.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Reference Include="Microsoft.Extensions.Hosting.Abstractions, Version=5.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60">
+        <HintPath>..\..\..\..\..\..\usr\share\dotnet\packs\Microsoft.AspNetCore.App.Ref\5.0.0\ref\net5.0\Microsoft.Extensions.Hosting.Abstractions.dll</HintPath>
+      </Reference>
+    </ItemGroup>
+
+</Project>

ErsatzTV.CommandLine/Program.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CliFx;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Serilog;
+using Serilog.Events;
+
+namespace ErsatzTV.CommandLine
+{
+    public class Program
+    {
+        public static async Task<int> Main(string[] args)
+        {
+            Log.Logger = new LoggerConfiguration()
+                .MinimumLevel.Information()
+                .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
+                .Enrich.FromLogContext()
+                .WriteTo.Console()
+                .CreateLogger();
+
+            IHost host = CreateHostBuilder(args).Build();
+            try
+            {
+                return await new CliApplicationBuilder()
+                    .AddCommandsFromThisAssembly()
+                    .UseTypeActivator(host.Services.GetService)
+                    .Build()
+                    .RunAsync(args);
+            }
+            catch (Exception ex)
+            {
+                Log.Fatal(ex, "Host terminated unexpectedly");
+                return 1;
+            }
+            finally
+            {
+                Log.CloseAndFlush();
+            }
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureServices(
+                    (_, services) =>
+                    {
+                        services.AddSingleton<IConsole, SystemConsole>();
+                        IEnumerable<Type> typesThatImplementICommand = typeof(Program).Assembly.GetTypes()
+                            .Where(x => typeof(ICommand).IsAssignableFrom(x))
+                            .Where(x => !x.IsAbstract);
+                        foreach (Type t in typesThatImplementICommand)
+                        {
+                            services.AddTransient(t);
+                        }
+                    })
+                .ConfigureAppConfiguration(
+                    (_, configuration) =>
+                    {
+                        configuration.Sources.Clear();
+
+                        string configFolder = Path.Combine(
+                            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                            "ersatztv");
+
+                        configuration.SetBasePath(configFolder);
+                        configuration.AddJsonFile("cli.json", true, true);
+                    })
+                .UseSerilog()
+                .UseConsoleLifetime();
+    }
+}

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

@@ -6,12 +6,9 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="FluentAssertions" Version="6.5.1" />
+      <PackageReference Include="FluentAssertions" Version="6.2.0" />
       <PackageReference Include="LanguageExt.Core" Version="4.0.3" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="6.0.0" />
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.64">
         <PrivateAssets>all</PrivateAssets>
@@ -19,7 +16,7 @@
       </PackageReference>
       <PackageReference Include="Moq" Version="4.16.1" />
       <PackageReference Include="NUnit" Version="3.13.2" />
-      <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+      <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
       <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" />

ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Collections.Generic;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
-using ErsatzTV.FFmpeg.State;
 using FluentAssertions;
 using LanguageExt;
 using NUnit.Framework;
@@ -142,7 +140,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                WatermarkLocation.BottomLeft,
+                ChannelWatermarkLocation.BottomLeft,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=134:y=H-h-54[v]",
@@ -152,7 +150,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                WatermarkLocation.BottomRight,
+                ChannelWatermarkLocation.BottomRight,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=W-w-134:y=H-h-54[v]",
@@ -162,7 +160,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=134:y=54[v]",
@@ -172,7 +170,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                WatermarkLocation.TopRight,
+                ChannelWatermarkLocation.TopRight,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=W-w-134:y=54[v]",
@@ -182,17 +180,17 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 true,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 false,
                 100,
-                "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)'[wmp];[0:0][wmp]overlay=x=134:y=54,format=nv12[v]",
+                "[0:0][1:v]overlay=x=134:y=54:enable='lt(mod(mod(time(0),60*60),10*60),15)'[v]",
                 "0:1",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 true,
                 100,
                 "[1:v]scale=384:-1[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
@@ -202,7 +200,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 false,
                 90,
                 "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,colorchannelmixer=aa=0.90[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
@@ -212,7 +210,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
@@ -222,7 +220,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 true,
                 100,
                 "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
@@ -232,7 +230,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
@@ -242,7 +240,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 false,
                 false,
-                WatermarkLocation.TopLeft,
+                ChannelWatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:1]apad=whole_dur=3300000ms[a];[0:0][1:v]overlay=x=134:y=54[v]",
@@ -252,43 +250,30 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 bool alignAudio,
                 bool deinterlace,
                 bool intermittent,
-                WatermarkLocation location,
+                ChannelWatermarkLocation location,
                 bool scaled,
                 int opacity,
                 string expectedVideoFilter,
                 string expectedAudioLabel,
                 string expectedVideoLabel)
             {
-                var watermark = new ChannelWatermark
-                {
-                    Mode = intermittent
-                        ? ChannelWatermarkMode.Intermittent
-                        : ChannelWatermarkMode.Permanent,
-                    DurationSeconds = intermittent ? 15 : 0,
-                    FrequencyMinutes = intermittent ? 10 : 0,
-                    Location = location,
-                    Size = scaled ? WatermarkSize.Scaled : WatermarkSize.ActualSize,
-                    WidthPercent = scaled ? 20 : 0,
-                    Opacity = opacity,
-                    HorizontalMarginPercent = 7,
-                    VerticalMarginPercent = 5
-                };
-
-                Option<List<FadePoint>> maybeFadePoints = watermark.Mode == ChannelWatermarkMode.Intermittent
-                    ? Some(
-                        WatermarkCalculator.CalculateFadePoints(
-                            new DateTimeOffset(2022, 01, 31, 12, 25, 0, TimeSpan.FromHours(-5)),
-                            TimeSpan.Zero,
-                            TimeSpan.FromMinutes(55),
-                            TimeSpan.Zero,
-                            watermark.FrequencyMinutes,
-                            watermark.DurationSeconds))
-                    : None;
-                
                 FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
                     .WithWatermark(
-                        Some(watermark),
-                        maybeFadePoints,
+                        Some(
+                            new ChannelWatermark
+                            {
+                                Mode = intermittent
+                                    ? ChannelWatermarkMode.Intermittent
+                                    : ChannelWatermarkMode.Permanent,
+                                DurationSeconds = intermittent ? 15 : 0,
+                                FrequencyMinutes = intermittent ? 10 : 0,
+                                Location = location,
+                                Size = scaled ? ChannelWatermarkSize.Scaled : ChannelWatermarkSize.ActualSize,
+                                WidthPercent = scaled ? 20 : 0,
+                                Opacity = opacity,
+                                HorizontalMarginPercent = 7,
+                                VerticalMarginPercent = 5
+                            }),
                         new Resolution { Width = 1920, Height = 1080 },
                         None)
                     .WithDeinterlace(deinterlace)
@@ -305,213 +290,6 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                         filter.VideoLabel.Should().Be(expectedVideoLabel);
                     });
             }
-            
-            [Test]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.BottomLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=H-h-54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.BottomLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=H-h-54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]
-            [TestCase(
-                false,
-                false,
-                true,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)',hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                true,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)',hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                true,
-                100,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,scale=384:-1,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                true,
-                100,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,scale=384:-1,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                90,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,colorchannelmixer=aa=0.90,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                90,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,colorchannelmixer=aa=0.90,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]            
-            // TODO: do we need these anymore? interlaced content that isn't handled by mpeg2_cuvid?
-            // [TestCase(
-            //     false,
-            //     true,
-            //     false,
-            //     WatermarkLocation.TopLeft,
-            //     false,
-            //     100,
-            //     "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
-            //     "0:1",
-            //     "[v]")]
-            // [TestCase(
-            //     false,
-            //     true,
-            //     false,
-            //     WatermarkLocation.TopLeft,
-            //     true,
-            //     100,
-            //     "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
-            //     "0:1",
-            //     "[v]")]
-            // [TestCase(
-            //     true,
-            //     true,
-            //     false,
-            //     WatermarkLocation.TopLeft,
-            //     false,
-            //     100,
-            //     "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
-            //     "[a]",
-            //     "[v]")]
-            [TestCase(
-                true,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:1]apad=whole_dur=3300000ms[a];[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "[a]",
-                "[v]",
-                false)]
-            [TestCase(
-                true,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:1]apad=whole_dur=3300000ms[a];[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "[a]",
-                "[v]",
-                true)]
-            public void Should_Return_NVENC_Watermark(
-                bool alignAudio,
-                bool deinterlace,
-                bool intermittent,
-                WatermarkLocation location,
-                bool scaled,
-                int opacity,
-                string expectedVideoFilter,
-                string expectedAudioLabel,
-                string expectedVideoLabel,
-                bool scaledSource)
-            {
-                var watermark = new ChannelWatermark
-                {
-                    Mode = intermittent
-                        ? ChannelWatermarkMode.Intermittent
-                        : ChannelWatermarkMode.Permanent,
-                    DurationSeconds = intermittent ? 15 : 0,
-                    FrequencyMinutes = intermittent ? 10 : 0,
-                    Location = location,
-                    Size = scaled ? WatermarkSize.Scaled : WatermarkSize.ActualSize,
-                    WidthPercent = scaled ? 20 : 0,
-                    Opacity = opacity,
-                    HorizontalMarginPercent = 7,
-                    VerticalMarginPercent = 5
-                };
-
-                Option<List<FadePoint>> maybeFadePoints = watermark.Mode == ChannelWatermarkMode.Intermittent
-                    ? Some(
-                        WatermarkCalculator.CalculateFadePoints(
-                            new DateTimeOffset(2022, 01, 31, 12, 25, 0, TimeSpan.FromHours(-5)),
-                            TimeSpan.Zero,
-                            TimeSpan.FromMinutes(55),
-                            TimeSpan.Zero,
-                            watermark.FrequencyMinutes,
-                            watermark.DurationSeconds))
-                    : None;
-                
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
-                    .WithWatermark(
-                        Some(watermark),
-                        maybeFadePoints,
-                        new Resolution { Width = 1920, Height = 1080 },
-                        None)
-                    .WithDeinterlace(deinterlace)
-                    .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
-
-                if (scaledSource)
-                {
-                    builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1080 });
-                }
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be(expectedAudioLabel);
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
-            }
 
             [Test]
             [TestCase(true, false, false, "[0:0]deinterlace_qsv[v]", "[v]")]
@@ -519,37 +297,37 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:0]deinterlace_qsv,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:0]scale_qsv=w=1920:h=1000,setsar=1[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:0]scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
                 "[v]")]
             public void Should_Return_QSV_Video_Filter(
                 bool deinterlace,
@@ -590,37 +368,37 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1[v]",
+                "[0:0]yadif_cuda,scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:0]yadif_cuda,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:0]scale_cuda=1920:1000,setsar=1[v]",
+                "[0:0]scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:0]scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_NVENC_Video_Filter(
                 bool deinterlace,
@@ -631,8 +409,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
                     .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
-                    .WithDeinterlace(deinterlace)
-                    .WithInputPixelFormat("h264");
+                    .WithDeinterlace(deinterlace);
 
                 if (scale)
                 {
@@ -663,42 +440,42 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 false,
                 true,
-                "[0:0]deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 true,
                 true,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 true,
                 false,
-                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 false,
                 true,
-                "[0:0]setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 true,
                 true,
-                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase("mpeg4", true, false, false, "[0:0]hwupload,deinterlace_vaapi[v]", "[v]")]
             [TestCase(
@@ -706,28 +483,28 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 false,
                 true,
-                "[0:0]hwupload,deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 true,
                 true,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 false,
                 true,
                 false,
-                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
@@ -741,7 +518,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 true,
-                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_VAAPI_Video_Filter(
                 string codec,

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

@@ -4,7 +4,6 @@ using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Tests.FFmpeg
 {
@@ -17,33 +16,10 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             private readonly FFmpegPlaybackSettingsCalculator _calculator;
 
             public CalculateSettings() => _calculator = new FFmpegPlaybackSettingsCalculator();
-            
-            [Test]
-            public void Should_Not_GenPts_ForHlsSegmenter()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingSegmenter,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.FormatFlags.Should().NotContain("+genpts");
-            }
 
             [Test]
-            public void Should_Not_UseSpecifiedThreadCount_ForTransportStream()
+            public void Should_UseSpecifiedThreadCount_ForTransportStream()
             {
-                // MPEG-TS requires realtime output which is hardcoded to a single thread
-                
                 FFmpegProfile ffmpegProfile = TestProfile() with { ThreadCount = 7 };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
@@ -55,20 +31,18 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
-                actual.ThreadCount.Should().Be(1);
+                actual.ThreadCount.Should().Be(7);
             }
 
             [Test]
-            public void Should_UseSpecifiedThreadCount_ForHttpLiveStreamingSegmenter()
+            public void Should_UseSpecifiedThreadCount_ForHttpLiveStreaming()
             {
                 FFmpegProfile ffmpegProfile = TestProfile() with { ThreadCount = 7 };
 
                 FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingSegmenter,
+                    StreamingMode.HttpLiveStreamingDirect,
                     ffmpegProfile,
                     new MediaVersion(),
                     new MediaStream(),
@@ -76,9 +50,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ThreadCount.Should().Be(7);
             }
@@ -97,9 +69,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
                 actual.FormatFlags.Count.Should().Be(expected.Length);
@@ -120,9 +90,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
                 actual.FormatFlags.Count.Should().Be(expected.Length);
@@ -143,9 +111,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.RealtimeOutput.Should().BeTrue();
             }
@@ -164,9 +130,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.RealtimeOutput.Should().BeTrue();
             }
@@ -187,9 +151,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     now,
                     now.AddMinutes(5),
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.StreamSeek.IsSome.Should().BeTrue();
                 actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
@@ -211,9 +173,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     now,
                     now.AddMinutes(5),
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.StreamSeek.IsSome.Should().BeTrue();
                 actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
@@ -233,9 +193,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
             }
@@ -261,9 +219,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
             }
@@ -289,9 +245,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
             }
@@ -317,9 +271,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -347,9 +299,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -376,9 +326,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 IDisplaySize scaledSize = actual.ScaledSize.IfNone(new MediaVersion { Width = 0, Height = 0 });
                 scaledSize.Width.Should().Be(1280);
@@ -408,9 +356,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -438,9 +384,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -469,9 +413,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -503,9 +445,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -537,9 +477,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -570,9 +508,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -604,9 +540,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -640,9 +574,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -674,9 +606,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -707,9 +637,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -739,9 +667,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeTrue();
@@ -773,9 +699,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.ScaledSize.IsNone.Should().BeTrue();
                 actual.PadToDesiredResolution.Should().BeFalse();
@@ -803,9 +727,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("aac");
             }
@@ -830,9 +752,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("copy");
             }
@@ -858,9 +778,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("aac");
             }
@@ -886,9 +804,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioCodec.Should().Be("copy");
             }
@@ -915,9 +831,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioBitrate.IfNone(0).Should().Be(2424);
             }
@@ -944,9 +858,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioBufferSize.IfNone(0).Should().Be(2424);
             }
@@ -973,9 +885,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioChannels.IfNone(0).Should().Be(6);
             }
@@ -1002,9 +912,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioSampleRate.IfNone(0).Should().Be(48);
             }
@@ -1030,9 +938,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioChannels.IfNone(0).Should().Be(6);
             }
@@ -1058,9 +964,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.AudioSampleRate.IfNone(0).Should().Be(48);
             }
@@ -1087,9 +991,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.FromMinutes(2),
-                    false,
-                    None);
+                    TimeSpan.FromMinutes(2));
 
                 actual.AudioDuration.IfNone(TimeSpan.MinValue).Should().Be(TimeSpan.FromMinutes(2));
             }
@@ -1115,9 +1017,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.NormalizeLoudness.Should().BeTrue();
             }
@@ -1143,9 +1043,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.NormalizeLoudness.Should().BeFalse();
             }
@@ -1173,9 +1071,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                     DateTimeOffset.Now,
                     DateTimeOffset.Now,
                     TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+                    TimeSpan.Zero);
 
                 actual.HardwareAcceleration.Should().Be(HardwareAccelerationKind.Qsv);
             }

ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs

@@ -1,9 +1,6 @@
 using System;
 using ErsatzTV.Core.FFmpeg;
-using ErsatzTV.Core.Interfaces.FFmpeg;
 using FluentAssertions;
-using Microsoft.Extensions.Logging;
-using Moq;
 using NUnit.Framework;
 
 namespace ErsatzTV.Core.Tests.FFmpeg
@@ -11,19 +8,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
     [TestFixture]
     public class HlsPlaylistFilterTests
     {
-        private HlsPlaylistFilter _hlsPlaylistFilter;
-        
-        [SetUp]
-        public void SetUp()
-        {
-            _hlsPlaylistFilter = new HlsPlaylistFilter(
-                new Mock<ITempFilePool>().Object,
-                new Mock<ILogger<HlsPlaylistFilter>>().Object
-            );
-        }
-
         [Test]
-        public void _hlsPlaylistFilter_ShouldRewriteProgramDateTime()
+        public void HlsPlaylistFilter_ShouldRewriteProgramDateTime()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
             string[] input = NormalizeLineEndings(@"#EXTM3U
@@ -42,7 +28,7 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
 
             result.PlaylistStart.Should().Be(start);
             result.Sequence.Should().Be(1137);
@@ -67,7 +53,7 @@ live001139.ts
         }
         
         [Test]
-        public void _hlsPlaylistFilter_ShouldLimitSegments()
+        public void HlsPlaylistFilter_ShouldLimitSegments()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
             string[] input = NormalizeLineEndings(@"#EXTM3U
@@ -86,7 +72,7 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
 
             result.PlaylistStart.Should().Be(start);
             result.Sequence.Should().Be(1137);
@@ -108,7 +94,7 @@ live001138.ts
         }
         
         [Test]
-        public void _hlsPlaylistFilter_ShouldAddDiscontinuity()
+        public void HlsPlaylistFilter_ShouldAddDiscontinuity()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
             string[] input = NormalizeLineEndings(@"#EXTM3U
@@ -127,7 +113,7 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(
                 start,
                 start.AddSeconds(-30),
                 input,
@@ -158,7 +144,7 @@ live001139.ts
         }
 
         [Test]
-        public void _hlsPlaylistFilter_ShouldFilterOldSegments()
+        public void HlsPlaylistFilter_ShouldFilterOldSegments()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
             string[] input = NormalizeLineEndings(@"#EXTM3U
@@ -177,7 +163,7 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
 
             result.PlaylistStart.Should().Be(start.AddSeconds(8));
             result.Sequence.Should().Be(1139);
@@ -196,7 +182,7 @@ live001139.ts
         }
         
         [Test]
-        public void _hlsPlaylistFilter_ShouldFilterOldDiscontinuity()
+        public void HlsPlaylistFilter_ShouldFilterOldDiscontinuity()
         {
             var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
             string[] input = NormalizeLineEndings(@"#EXTM3U
@@ -216,7 +202,7 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+            TrimPlaylistResult result = HlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
 
             result.PlaylistStart.Should().Be(start.AddSeconds(8));
             result.Sequence.Should().Be(1139);

ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs

@@ -4,8 +4,6 @@ using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
-using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
@@ -39,53 +37,23 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             Assert.Pass();
         }
 
-        public record InputFormat(string Encoder, string PixelFormat);
-
-        public enum Padding
-        {
-            NoPadding,
-            WithPadding
-        }
-
         private class TestData
         {
-            public static Padding[] Paddings =
+            public static string[] InputCodecs =
             {
-                Padding.NoPadding,
-                Padding.WithPadding
+                "h264",
+                "mpeg2video",
+                "hevc",
+                "mpeg4"
             };
 
-            public static VideoScanKind[] VideoScanKinds =
+            public static string[] InputPixelFormats =
             {
-                VideoScanKind.Progressive,
-                VideoScanKind.Interlaced
-            };
-
-            public static InputFormat[] InputFormats =
-            {
-                new("libx264", "yuv420p"),
-                new("libx264", "yuvj420p"),
-                new("libx264", "yuv420p10le"),
-                // new("libx264", "yuv444p10le"),
-
-                new("mpeg1video", "yuv420p"),
-
-                new("mpeg2video", "yuv420p"),
-
-                new("libx265", "yuv420p"),
-                new("libx265", "yuv420p10le"),
-
-                new("mpeg4", "yuv420p"),
-
-                new("libvpx-vp9", "yuv420p"),
-
-                // new("libaom-av1", "yuv420p")
-                // av1    yuv420p10le    51
-
-                new("msmpeg4v2", "yuv420p"),
-                new("msmpeg4v3", "yuv420p")
-
-                // wmv3    yuv420p    1
+                "yuv420p",
+                "yuv420p10le",
+                "yuvj420p",
+                "yuv444p",
+                "yuv444p10le"
             };
             
             public static Resolution[] Resolutions =
@@ -126,73 +94,31 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 HardwareAccelerationKind.Vaapi
             };
-
-            public static string[] VideoToolboxCodecs =
-            {
-                "h264_videotoolbox",
-                "hevc_videotoolbox"
-            };
-
-            public static HardwareAccelerationKind[] VideoToolboxAcceleration =
-            {
-                HardwareAccelerationKind.VideoToolbox
-            };
-
-            public static string[] QsvCodecs =
-            {
-                "h264_qsv",
-                "hevc_qsv"
-            };
-
-            public static HardwareAccelerationKind[] QsvAcceleration =
-            {
-                HardwareAccelerationKind.Qsv
-            };
         }
 
         [Test, Combinatorial]
         public async Task Transcode(
-            [ValueSource(typeof(TestData), nameof(TestData.InputFormats))]
-            InputFormat inputFormat,
+            [ValueSource(typeof(TestData), nameof(TestData.InputCodecs))]
+            string inputCodec,
+            [ValueSource(typeof(TestData), nameof(TestData.InputPixelFormats))]
+            string inputPixelFormat,
             [ValueSource(typeof(TestData), nameof(TestData.Resolutions))]
             Resolution profileResolution,
-            [ValueSource(typeof(TestData), nameof(TestData.Paddings))]
-            Padding padding,
-            [ValueSource(typeof(TestData), nameof(TestData.VideoScanKinds))]
-            VideoScanKind videoScanKind,
             // [ValueSource(typeof(TestData), nameof(TestData.SoftwareCodecs))] string profileCodec,
             // [ValueSource(typeof(TestData), nameof(TestData.NoAcceleration))] HardwareAccelerationKind profileAcceleration)
             [ValueSource(typeof(TestData), nameof(TestData.NvidiaCodecs))] string profileCodec,
             [ValueSource(typeof(TestData), nameof(TestData.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
             // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
             // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.QsvCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.QsvAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
         {
-            if (inputFormat.Encoder is "mpeg1video" or "msmpeg4v2" or "msmpeg4v3")
-            {
-                if (videoScanKind == VideoScanKind.Interlaced)
-                {
-                    Assert.Inconclusive($"{inputFormat.Encoder} does not support interlaced content");
-                    return;
-                }
-            }
-
             string name = GetStringSha256Hash(
-                $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");
+                $"{inputCodec}_{inputPixelFormat}_{profileResolution}_{profileCodec}_{profileAcceleration}");
 
             string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
             if (!File.Exists(file))
             {
-                string resolution = padding == Padding.WithPadding ? "1920x1060" : "1920x1080";
-
-                string videoFilter = videoScanKind == VideoScanKind.Interlaced ? "-vf tinterlace=interleave_top,fieldorder=tff" : string.Empty;
-                string flags = videoScanKind == VideoScanKind.Interlaced ? "-flags +ildct+ilme" : string.Empty;
-                
-                string args =
-                    $"-y -f lavfi -i anoisesrc=color=brown -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 {videoFilter} -c:a aac -c:v {inputFormat.Encoder} -shortest -pix_fmt {inputFormat.PixelFormat} -strict -2 {flags} {file}";
+                var args =
+                    $"-y -f lavfi -i anullsrc=channel_layout=stereo:sample_rate=44100 -f lavfi -i testsrc=duration=1:size=1920x1080:rate=30 -c:a aac -c:v {inputCodec} -shortest -pix_fmt {inputPixelFormat} -strict -2 {file}";
                 var p1 = new Process
                 {
                     StartInfo = new ProcessStartInfo
@@ -209,35 +135,19 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 p1.ExitCode.Should().Be(0);
             }
 
-            var oldService = new FFmpegProcessService(
+            var service = new FFmpegProcessService(
                 new FFmpegPlaybackSettingsCalculator(),
                 new FakeStreamSelector(),
                 new Mock<IImageCache>().Object,
                 new Mock<ITempFilePool>().Object,
                 new Mock<ILogger<FFmpegProcessService>>().Object);
 
-            var service = new FFmpegLibraryProcessService(
-                oldService,
-                new FFmpegPlaybackSettingsCalculator(),
-                new FakeStreamSelector(),
-                new Mock<ILogger<FFmpegLibraryProcessService>>().Object);
-
-            var v = new MediaVersion
-            {
-                MediaFiles = new List<MediaFile>
-                {
-                    new() { Path = file }
-                }
-            };
+            MediaVersion v = new MediaVersion();
 
             var metadataRepository = new Mock<IMetadataRepository>();
             metadataRepository
-                .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
-                .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
-                {
-                    version.MediaFiles = v.MediaFiles;
-                    v = version;
-                });
+                .Setup(r => r.UpdateLocalStatistics(It.IsAny<int>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
+                .Callback<int, MediaVersion, bool>((_, version, _) => v = version);
 
             var localStatisticsProvider = new LocalStatisticsProvider(
                 metadataRepository.Object,
@@ -267,12 +177,10 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 new Channel(Guid.NewGuid())
                 {
-                    Number = "1",
                     FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
                     {
                         HardwareAcceleration = profileAcceleration,
-                        VideoCodec = profileCodec,
-                        AudioCodec = "aac"
+                        VideoCodec = profileCodec
                     },
                     StreamingMode = StreamingMode.TransportStream
                 },
@@ -289,56 +197,26 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 FillerKind.None,
                 TimeSpan.Zero,
-                TimeSpan.FromSeconds(5),
-                0,
-                None);
+                TimeSpan.FromSeconds(5));
 
             process.StartInfo.RedirectStandardError = true;
-            process.EnableRaisingEvents = true;
-            
-            // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
 
             process.Start().Should().BeTrue();
 
+            process.BeginOutputReadLine();
+            string error = await process.StandardError.ReadToEndAsync();
+            await process.WaitForExitAsync();
+            // ReSharper disable once MethodHasAsyncOverload
+            process.WaitForExit();
+
             string[] unsupportedMessages =
             {
                 "No support for codec",
                 "No usable",
                 "Provided device doesn't support"
             };
-
-            var errorBuffer = new StringBuilder();
             
-            process.ErrorDataReceived += (_, errorLine) =>
-            {
-                string data = errorLine.Data ?? string.Empty;
-                errorBuffer.AppendLine(data);
-            };
-
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
-            // string error = await process.StandardError.ReadToEndAsync();
-
-            var timeoutSignal = new CancellationTokenSource(TimeSpan.FromSeconds(30));
-            try
-            {
-                await process.WaitForExitAsync(timeoutSignal.Token);
-                // ReSharper disable once MethodHasAsyncOverload
-                process.WaitForExit();
-            }
-            catch (OperationCanceledException)
-            {
-                process.Kill();
-
-                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-                Assert.Fail($"Transcode failure (timeout): ffmpeg {string.Join(" ", quotedArgs)}");
-                return;
-            }
-
-            var error = errorBuffer.ToString();
-            bool isUnsupported = unsupportedMessages.Any(error.Contains); 
-
-            if (profileAcceleration != HardwareAccelerationKind.None && isUnsupported)
+            if (profileAcceleration != HardwareAccelerationKind.None && unsupportedMessages.Any(error.Contains))
             {
                 var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
                 process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
@@ -351,12 +229,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
             else
             {
-                var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-                process.ExitCode.Should().Be(0, errorBuffer + Environment.NewLine + string.Join(" ", quotedArgs));
-                if (process.ExitCode == 0)
-                {
-                    Console.WriteLine(string.Join(" ", quotedArgs));
-                }
+                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
+                process.ExitCode.Should().Be(0, error + Environment.NewLine + string.Join(" ", quotedArgs));
             }
         }
         

ErsatzTV.Core.Tests/FFmpeg/WatermarkCalculatorTests.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.FFmpeg;
-using FluentAssertions;
-using NUnit.Framework;
-using static LanguageExt.Prelude;
-
-namespace ErsatzTV.Core.Tests.FFmpeg;
-
-[TestFixture]
-public class WatermarkCalculatorTests
-{
-    [Test]
-    public void EntireVideoBetweenWatermarks_ShouldReturn_EmptyFadePointList()
-    {
-        List<FadePoint> actual = WatermarkCalculator.CalculateFadePoints(
-            new DateTimeOffset(2022, 01, 31, 13, 34, 00, TimeSpan.FromHours(-5)),
-            TimeSpan.Zero,
-            TimeSpan.FromMinutes(5),
-            None,
-            15,
-            10);
-
-        actual.Should().HaveCount(0);
-    }
-}