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

* fix videotoolbox acceleration with new transcoder

* cleanup

.github/dependabot.yml

@@ -6,3 +6,21 @@ 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

@@ -0,0 +1,235 @@
+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,49 +1,19 @@
 name: Build
 on:
   workflow_dispatch:
-  pull_request:
   push:
     branches:
       - main
 jobs:
-  build_and_test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, ubuntu-latest, macos-latest ]
+  calculate_version:
+    name: Calculate version information
+    runs-on: ubuntu-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 Git Tag
+      - name: Extract Docker Tag
         shell: bash
         run: |
           tag=$(git describe --tags --abbrev=0)
@@ -51,60 +21,38 @@ jobs:
           short=$(git rev-parse --short HEAD)
           final="${tag2/alpha/$short}"
           echo "GIT_TAG=${final}" >> $GITHUB_ENV
-
-      - 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
+      - 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 }}

.github/workflows/docker.yml

@@ -0,0 +1,88 @@
+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,14 +3,13 @@ on:
   push:
     branches:
       - main
-
 jobs:
   build:
     name: Deploy docs
     runs-on: ubuntu-latest
     steps:
       - name: Checkout master
-        uses: actions/checkout@v1
+        uses: actions/checkout@v2
 
       - name: Deploy docs
         uses: mhausenblas/mkdocs-deploy-gh-pages@master

.github/workflows/pr.yml

@@ -0,0 +1,30 @@
+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,142 +1,53 @@
-name: Publish
+name: Release
 on:
   release:
     types: [ published ]
 jobs:
-  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 }}
+  calculate_version:
+    name: Calculate version information
+    runs-on: ubuntu-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
-        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}/*"
-          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 Git Tag
+      - name: Extract Docker 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: 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
+      - 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 }}

.gitmodules

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

CHANGELOG.md

@@ -5,6 +5,141 @@ 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
@@ -850,7 +985,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release to facilitate testing outside of Docker.
 
 
-[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.2-alpha...HEAD
+[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
 [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

ErsatzTV-Windows/ErsatzTV-Windows.csproj

@@ -0,0 +1,33 @@
+<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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,77 @@
+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,10 +6,13 @@ 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? FallbackFillerId,
+        int PlayoutCount);
 }

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -9,6 +9,8 @@ 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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, Channel> validation = await Validate(dbContext, request);
             return await validation.Apply(c => PersistChannel(dbContext, c));
         }
@@ -65,6 +65,8 @@ 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,6 +10,8 @@ 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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, Channel> validation = await Validate(dbContext, request);
             return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
         }
@@ -37,6 +37,8 @@ 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,12 +11,15 @@ 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.FallbackFillerId,
+                channel.Playouts?.Count ?? 0);
 
         private static string GetLogo(Channel channel) =>
             Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))

ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs

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

ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs

@@ -0,0 +1,99 @@
+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,10 +36,14 @@ namespace ErsatzTV.Application.Channels.Queries
                         channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                         result.Add(channel);
                         break;
-                    case "ts":
+                    case "ts-legacy":
                         channel.StreamingMode = StreamingMode.TransportStream;
                         result.Add(channel);
                         break;
+                    case "ts":
+                        channel.StreamingMode = StreamingMode.TransportStreamHybrid;
+                        result.Add(channel);
+                        break;
                     default:
                         result.Add(channel);
                         break;

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -3,11 +3,10 @@
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
-        <DebugType>embedded</DebugType>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="MediatR" Version="9.0.0" />
+      <PackageReference Include="MediatR" Version="10.0.1" />
       <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,5 +24,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
         bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
+        bool NormalizeAudio,
+        bool NormalizeFramerate) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
 }

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

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

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -50,6 +50,7 @@ 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,13 +1,11 @@
 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
@@ -16,16 +14,13 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
     {
         private readonly IConfigElementRepository _configElementRepository;
         private readonly ILocalFileSystem _localFileSystem;
-        private readonly IRuntimeInfo _runtimeInfo;
 
         public UpdateFFmpegSettingsHandler(
             IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem,
-            IRuntimeInfo runtimeInfo)
+            ILocalFileSystem localFileSystem)
         {
             _configElementRepository = configElementRepository;
             _localFileSystem = localFileSystem;
-            _runtimeInfo = runtimeInfo;
         }
 
         public Task<Either<BaseError, Unit>> Handle(
@@ -36,8 +31,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), ReportsAreNotSupportedOnWindows(request))
-            .Apply((_, _, _) => Unit.Default);
+            (await FFmpegMustExist(request), await FFprobeMustExist(request))
+            .Apply((_, _) => Unit.Default);
 
         private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
             ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
@@ -45,16 +40,6 @@ 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))
@@ -100,6 +85,10 @@ 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);
@@ -134,6 +123,10 @@ 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,5 +23,6 @@ namespace ErsatzTV.Application.FFmpegProfiles
         bool NormalizeLoudness,
         int AudioChannels,
         int AudioSampleRate,
-        bool NormalizeAudio);
+        bool NormalizeAudio,
+        bool NormalizeFramerate);
 }

ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs

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

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs

@@ -34,6 +34,10 @@ 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
             {
@@ -44,6 +48,8 @@ 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/GetConfiguredLibraries.cs

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

ErsatzTV.Application/Libraries/Queries/GetConfiguredLibrariesHandler.cs

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

ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs

@@ -0,0 +1,9 @@
+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

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

ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs

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

ErsatzTV.Application/MediaCards/Mapper.cs

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

ErsatzTV.Application/MediaCards/MediaCardViewModel.cs

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

ErsatzTV.Application/MediaCards/MovieCardViewModel.cs

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

ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs

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

ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs

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

ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs

@@ -47,6 +47,9 @@ 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)
@@ -56,6 +59,9 @@ 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)
@@ -81,11 +87,20 @@ 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,16 +1,21 @@
-namespace ErsatzTV.Application.MediaCards
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.MediaCards
 {
     public record SongCardViewModel
     (
         int SongId,
         string Title,
         string Subtitle,
-        string SortTitle) : MediaCardViewModel(
+        string SortTitle,
+        string Poster,
+        MediaItemState State) : MediaCardViewModel(
         SongId,
         Title,
         Subtitle,
         SortTitle,
-        null)
+        Poster,
+        State)
     {
         public int CustomIndex { get; set; }
     }

ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs

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

ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs

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

ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs

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

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);
+            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder, MediaItemState.Normal);
 
         internal static MultiCollectionViewModel ProjectToViewModel(MultiCollection multiCollection) =>
             new(

ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs

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

ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs

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

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -160,15 +160,36 @@ namespace ErsatzTV.Application.MediaSources.Commands
             return Unit.Default;
         }
 
-        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 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 Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
             IScanLocalLibrary request) =>

ErsatzTV.Application/Movies/Mapper.cs

@@ -4,6 +4,7 @@ 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;
@@ -34,7 +35,9 @@ 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())
+                metadata.Writers.Map(w => w.Name).ToList(),
+                movie.GetHeadVersion().MediaFiles.Head().Path,
+                movie.State)
             {
                 Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby),
                 FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby)

ErsatzTV.Application/Movies/MovieViewModel.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Movies
 {
@@ -15,7 +16,9 @@ namespace ErsatzTV.Application.Movies
         List<CultureInfo> Languages,
         List<ActorCardViewModel> Actors,
         List<string> Directors,
-        List<string> Writers)
+        List<string> Writers,
+        string Path,
+        MediaItemState MediaItemState)
     {
         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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             
             Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                 .Map(list => list.HeadOrNone());

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs

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

ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs

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

ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs

@@ -10,5 +10,6 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
         int ProgramScheduleId,
         string Name,
         bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows) : IRequest<Either<BaseError, UpdateProgramScheduleResult>>;
+        bool TreatCollectionsAsShows,
+        bool ShuffleScheduleItems) : 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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
             Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
             return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
@@ -45,12 +45,14 @@ 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.TreatCollectionsAsShows != request.TreatCollectionsAsShows ||
+                programSchedule.ShuffleScheduleItems != request.ShuffleScheduleItems;
 
             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,7 +10,8 @@ namespace ErsatzTV.Application.ProgramSchedules
                 programSchedule.Id,
                 programSchedule.Name,
                 programSchedule.KeepMultiPartEpisodesTogether,
-                programSchedule.TreatCollectionsAsShows);
+                programSchedule.TreatCollectionsAsShows,
+                programSchedule.ShuffleScheduleItems);
 
         internal static ProgramScheduleItemViewModel ProjectToViewModel(ProgramScheduleItem programScheduleItem) =>
             programScheduleItem switch

ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs

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

ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs

@@ -25,7 +25,8 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                         ps.Id,
                         ps.Name,
                         ps.KeepMultiPartEpisodesTogether,
-                        ps.TreatCollectionsAsShows))
+                        ps.TreatCollectionsAsShows,
+                        ps.ShuffleScheduleItems))
                 .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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             return await dbContext.ProgramSchedules
                 .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
                 .MapT(ProjectToViewModel);

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs

@@ -4,6 +4,7 @@ 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;
@@ -23,7 +24,11 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
             GetProgramScheduleItems request,
             CancellationToken cancellationToken)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            Option<ProgramSchedule> maybeProgramSchedule =
+                await dbContext.ProgramSchedules.SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id);
+
             return await dbContext.ProgramScheduleItems
                 .Filter(psi => psi.ProgramScheduleId == request.Id)
                 .Include(i => i.Collection)
@@ -51,7 +56,29 @@ namespace ErsatzTV.Application.ProgramSchedules.Queries
                 .Include(i => i.TailFiller)
                 .Include(i => i.FallbackFiller)
                 .ToListAsync(cancellationToken)
-                .Map(programScheduleItems => programScheduleItems.Map(ProjectToViewModel).ToList());
+                .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;
         }
     }
 }

ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs

@@ -5,6 +5,7 @@ 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;
@@ -21,6 +22,7 @@ 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(
@@ -28,13 +30,15 @@ namespace ErsatzTV.Application.Streaming.Commands
             ILogger<StartFFmpegSessionHandler> logger,
             IServiceScopeFactory serviceScopeFactory,
             IFFmpegSegmenterService ffmpegSegmenterService,
-            IConfigElementRepository configElementRepository)
+            IConfigElementRepository configElementRepository,
+            IHlsPlaylistFilter hlsPlaylistFilter)
         {
             _localFileSystem = localFileSystem;
             _logger = logger;
             _serviceScopeFactory = serviceScopeFactory;
             _ffmpegSegmenterService = ffmpegSegmenterService;
             _configElementRepository = configElementRepository;
+            _hlsPlaylistFilter = hlsPlaylistFilter;
         }
 
         public Task<Either<BaseError, Unit>> Handle(StartFFmpegSession request, CancellationToken cancellationToken) =>
@@ -50,7 +54,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);
@@ -68,12 +72,32 @@ 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));
             }
 
-            return Unit.Default;
+            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;
+            }
         }
 
         private Task<Validation<BaseError, Unit>> Validate(StartFFmpegSession request) =>

ErsatzTV.Application/Streaming/HlsSessionWorker.cs

@@ -1,9 +1,11 @@
 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;
@@ -22,6 +24,7 @@ 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;
@@ -29,9 +32,11 @@ namespace ErsatzTV.Application.Streaming
         private Timer _timer;
         private readonly object _sync = new();
         private DateTimeOffset _playlistStart;
+        private Option<int> _targetFramerate;
 
-        public HlsSessionWorker(IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
+        public HlsSessionWorker(IHlsPlaylistFilter hlsPlaylistFilter, IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
         {
+            _hlsPlaylistFilter = hlsPlaylistFilter;
             _serviceScopeFactory = serviceScopeFactory;
             _logger = logger;
         }
@@ -65,6 +70,13 @@ 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;
@@ -113,7 +125,11 @@ 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
             {
@@ -132,12 +148,17 @@ 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);
+                    realtime,
+                    ptsOffset,
+                    _targetFramerate);
 
                 // _logger.LogInformation("Request {@Request}", request);
 
@@ -197,7 +218,7 @@ namespace ErsatzTV.Application.Streaming
 
             return true;
         }
-        
+
         private async Task TrimAndDelete(string channelNumber, CancellationToken cancellationToken)
         {
             string playlistFileName = Path.Combine(
@@ -209,29 +230,66 @@ 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
-                foreach (string file in Directory.GetFiles(
-                    Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber),
-                    "*.ts"))
+                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)
                 {
-                    string fileName = Path.GetFileName(file);
-                    if (fileName.StartsWith("live") && int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]) <
-                        trimResult.Sequence)
-                    {
-                        File.Delete(file);
-                    }
+                    File.Delete(segment.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();
@@ -239,5 +297,7 @@ 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

@@ -0,0 +1,16 @@
+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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
             return await validation.Match(
                 tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
@@ -56,7 +56,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                         {
                             "hls-direct" => StreamingMode.HttpLiveStreamingDirect,
                             "segmenter" => StreamingMode.HttpLiveStreamingSegmenter,
-                            "ts" => StreamingMode.TransportStream,
+                            "ts" => StreamingMode.TransportStreamHybrid,
+                            "ts-legacy" => StreamingMode.TransportStream,
                             _ => channel.StreamingMode
                         };
 

ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs

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

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs

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

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

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

ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,87 @@
+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,21 +1,18 @@
 using System;
+using LanguageExt;
 
 namespace ErsatzTV.Application.Streaming.Queries
 {
-    public record GetPlayoutItemProcessByChannelNumber : FFmpegProcessRequest
-    {
-        public GetPlayoutItemProcessByChannelNumber(
-            string channelNumber,
-            string mode,
-            DateTimeOffset now,
-            bool startAtZero,
-            bool hlsRealtime) : base(
-            channelNumber,
-            mode,
-            now,
-            startAtZero,
-            hlsRealtime)
-        {
-        }
-    }
+    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);
 }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -2,20 +2,19 @@
 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;
@@ -32,16 +31,15 @@ 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,
-            IFFmpegProcessService ffmpegProcessService,
+            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
             ILocalFileSystem localFileSystem,
             IPlexPathReplacementService plexPathReplacementService,
             IJellyfinPathReplacementService jellyfinPathReplacementService,
@@ -49,11 +47,10 @@ namespace ErsatzTV.Application.Streaming.Queries
             IMediaCollectionRepository mediaCollectionRepository,
             ITelevisionRepository televisionRepository,
             IArtistRepository artistRepository,
-            IRuntimeInfo runtimeInfo,
             ISongVideoGenerator songVideoGenerator)
             : base(dbContextFactory)
         {
-            _ffmpegProcessService = ffmpegProcessService;
+            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
             _localFileSystem = localFileSystem;
             _plexPathReplacementService = plexPathReplacementService;
             _jellyfinPathReplacementService = jellyfinPathReplacementService;
@@ -61,7 +58,6 @@ namespace ErsatzTV.Application.Streaming.Queries
             _mediaCollectionRepository = mediaCollectionRepository;
             _televisionRepository = televisionRepository;
             _artistRepository = artistRepository;
-            _runtimeInfo = runtimeInfo;
             _songVideoGenerator = songVideoGenerator;
         }
 
@@ -116,6 +112,8 @@ namespace ErsatzTV.Application.Streaming.Queries
                 maybePlayoutItem = await CheckForFallbackFiller(dbContext, channel, now);
             }
 
+            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
+
             return await maybePlayoutItem.Match(
                 async playoutItemWithPath =>
                 {
@@ -142,11 +140,11 @@ namespace ErsatzTV.Application.Streaming.Queries
                             ffmpegPath);
                     }
 
-                    bool saveReports = !_runtimeInfo.IsOSPlatform(OSPlatform.Windows) && await dbContext.ConfigElements
+                    bool saveReports = 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,
@@ -163,7 +161,9 @@ namespace ErsatzTV.Application.Streaming.Queries
                         request.HlsRealtime,
                         playoutItemWithPath.PlayoutItem.FillerKind,
                         playoutItemWithPath.PlayoutItem.InPoint,
-                        playoutItemWithPath.PlayoutItem.OutPoint);
+                        playoutItemWithPath.PlayoutItem.OutPoint,
+                        request.PtsOffset,
+                        request.TargetFramerate);
 
                     var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
 
@@ -193,12 +193,13 @@ 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.HlsRealtime,
+                                    request.PtsOffset);
                                 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }
@@ -212,12 +213,13 @@ 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.HlsRealtime,
+                                    request.PtsOffset);
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }
@@ -231,12 +233,13 @@ 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.HlsRealtime,
+                                    request.PtsOffset);
 
                                 return new PlayoutItemProcessModel(errorProcess, finish);
                             }

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs

@@ -0,0 +1,22 @@
+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

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

ErsatzTV.Application/Watermarks/Commands/UpdateWatermark.cs

@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.FFmpeg.State;
 using LanguageExt;
 using MediatR;
 
@@ -11,8 +12,8 @@ namespace ErsatzTV.Application.Watermarks.Commands
         string Image,
         ChannelWatermarkMode Mode,
         ChannelWatermarkImageSource ImageSource,
-        ChannelWatermarkLocation Location,
-        ChannelWatermarkSize Size,
+        WatermarkLocation Location,
+        WatermarkSize 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 = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, ChannelWatermark> validation = await Validate(dbContext, request);
             return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
         }

ErsatzTV.Application/Watermarks/WatermarkViewModel.cs

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

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

@@ -6,9 +6,12 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="FluentAssertions" Version="6.2.0" />
+      <PackageReference Include="FluentAssertions" Version="6.5.1" />
       <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>
@@ -16,7 +19,7 @@
       </PackageReference>
       <PackageReference Include="Moq" Version="4.16.1" />
       <PackageReference Include="NUnit" Version="3.13.2" />
-      <PackageReference Include="NUnit3TestAdapter" Version="4.1.0" />
+      <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
       <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,6 +1,8 @@
 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;
@@ -140,7 +142,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                ChannelWatermarkLocation.BottomLeft,
+                WatermarkLocation.BottomLeft,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=134:y=H-h-54[v]",
@@ -150,7 +152,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                ChannelWatermarkLocation.BottomRight,
+                WatermarkLocation.BottomRight,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=W-w-134:y=H-h-54[v]",
@@ -160,7 +162,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=134:y=54[v]",
@@ -170,7 +172,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                ChannelWatermarkLocation.TopRight,
+                WatermarkLocation.TopRight,
                 false,
                 100,
                 "[0:0][1:v]overlay=x=W-w-134:y=54[v]",
@@ -180,17 +182,17 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 true,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.TopLeft,
                 false,
                 100,
-                "[0:0][1:v]overlay=x=134:y=54:enable='lt(mod(mod(time(0),60*60),10*60),15)'[v]",
+                "[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:1",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.TopLeft,
                 true,
                 100,
                 "[1:v]scale=384:-1[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
@@ -200,7 +202,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 false,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.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]",
@@ -210,7 +212,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
@@ -220,7 +222,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.TopLeft,
                 true,
                 100,
                 "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
@@ -230,7 +232,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                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]",
@@ -240,7 +242,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 false,
                 false,
-                ChannelWatermarkLocation.TopLeft,
+                WatermarkLocation.TopLeft,
                 false,
                 100,
                 "[0:1]apad=whole_dur=3300000ms[a];[0:0][1:v]overlay=x=134:y=54[v]",
@@ -250,30 +252,43 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 bool alignAudio,
                 bool deinterlace,
                 bool intermittent,
-                ChannelWatermarkLocation location,
+                WatermarkLocation 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(
-                            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
-                            }),
+                        Some(watermark),
+                        maybeFadePoints,
                         new Resolution { Width = 1920, Height = 1080 },
                         None)
                     .WithDeinterlace(deinterlace)
@@ -290,6 +305,213 @@ 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]")]
@@ -297,37 +519,37 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:0]deinterlace_qsv,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]deinterlace_qsv,setsar=1,hwdownload,format=nv12,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,hwdownload,format=nv12,setsar=1,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,setsar=1,hwdownload,format=nv12,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,hwdownload,format=nv12,setsar=1,hwupload=extra_hw_frames=64[v]",
+                "[0:0]scale_qsv=w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[0:0]setsar=1,hwdownload,format=nv12,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,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+                "[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]",
                 "[v]")]
             public void Should_Return_QSV_Video_Filter(
                 bool deinterlace,
@@ -368,37 +590,37 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]yadif_cuda,scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 true,
                 false,
                 true,
-                "[0:0]yadif_cuda,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 true,
                 true,
                 true,
-                "[0:0]yadif_cuda,scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 false,
-                "[0:0]scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,hwupload[v]",
+                "[0:0]scale_cuda=1920:1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 false,
                 false,
                 true,
-                "[0:0]hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             [TestCase(
                 false,
                 true,
                 true,
-                "[0:0]scale_cuda=1920:1000,hwdownload,format=nv12,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
                 "[v]")]
             public void Should_Return_NVENC_Video_Filter(
                 bool deinterlace,
@@ -409,7 +631,8 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             {
                 FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
                     .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
-                    .WithDeinterlace(deinterlace);
+                    .WithDeinterlace(deinterlace)
+                    .WithInputPixelFormat("h264");
 
                 if (scale)
                 {
@@ -440,42 +663,42 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 true,
                 false,
                 true,
-                "[0:0]deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,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,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,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,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "h264",
                 false,
                 false,
                 true,
-                "[0:0]hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]setsar=1,hwdownload,format=nv12|vaapi,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,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,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(
@@ -483,28 +706,28 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 true,
                 true,
                 false,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
                 true,
                 false,
                 true,
-                "[0:0]hwupload,deinterlace_vaapi,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,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,hwdownload,format=nv12|vaapi,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,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,hwdownload,format=nv12|vaapi,setsar=1,hwupload[v]",
+                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
                 "[v]")]
             [TestCase(
                 "mpeg4",
@@ -518,7 +741,7 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 true,
                 true,
-                "[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]",
+                "[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]",
                 "[v]")]
             public void Should_Return_VAAPI_Video_Filter(
                 string codec,

ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs

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

ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs

@@ -1,6 +1,9 @@
 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
@@ -8,8 +11,19 @@ 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
@@ -28,7 +42,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);
@@ -53,7 +67,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
@@ -72,7 +86,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);
@@ -94,7 +108,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
@@ -113,7 +127,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,
@@ -144,7 +158,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
@@ -163,7 +177,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);
@@ -182,7 +196,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
@@ -202,7 +216,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,6 +4,8 @@ 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;
@@ -37,23 +39,53 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             Assert.Pass();
         }
 
+        public record InputFormat(string Encoder, string PixelFormat);
+
+        public enum Padding
+        {
+            NoPadding,
+            WithPadding
+        }
+
         private class TestData
         {
-            public static string[] InputCodecs =
+            public static Padding[] Paddings =
             {
-                "h264",
-                "mpeg2video",
-                "hevc",
-                "mpeg4"
+                Padding.NoPadding,
+                Padding.WithPadding
             };
 
-            public static string[] InputPixelFormats =
+            public static VideoScanKind[] VideoScanKinds =
             {
-                "yuv420p",
-                "yuv420p10le",
-                "yuvj420p",
-                "yuv444p",
-                "yuv444p10le"
+                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
             };
             
             public static Resolution[] Resolutions =
@@ -94,31 +126,73 @@ 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.InputCodecs))]
-            string inputCodec,
-            [ValueSource(typeof(TestData), nameof(TestData.InputPixelFormats))]
-            string inputPixelFormat,
+            [ValueSource(typeof(TestData), nameof(TestData.InputFormats))]
+            InputFormat inputFormat,
             [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(
-                $"{inputCodec}_{inputPixelFormat}_{profileResolution}_{profileCodec}_{profileAcceleration}");
+                $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");
 
             string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
             if (!File.Exists(file))
             {
-                var args =
-                    $"-y -f lavfi -i anullsrc=channel_layout=stereo:sample_rate=44100 -f lavfi -i testsrc=duration=1:size=1920x1080:rate=30 -c:a aac -c:v {inputCodec} -shortest -pix_fmt {inputPixelFormat} -strict -2 {file}";
+                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 p1 = new Process
                 {
                     StartInfo = new ProcessStartInfo
@@ -135,19 +209,35 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 p1.ExitCode.Should().Be(0);
             }
 
-            var service = new FFmpegProcessService(
+            var oldService = new FFmpegProcessService(
                 new FFmpegPlaybackSettingsCalculator(),
                 new FakeStreamSelector(),
                 new Mock<IImageCache>().Object,
                 new Mock<ITempFilePool>().Object,
                 new Mock<ILogger<FFmpegProcessService>>().Object);
 
-            MediaVersion v = new MediaVersion();
+            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 }
+                }
+            };
 
             var metadataRepository = new Mock<IMetadataRepository>();
             metadataRepository
-                .Setup(r => r.UpdateLocalStatistics(It.IsAny<int>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
-                .Callback<int, MediaVersion, bool>((_, version, _) => v = version);
+                .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
+                .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
+                {
+                    version.MediaFiles = v.MediaFiles;
+                    v = version;
+                });
 
             var localStatisticsProvider = new LocalStatisticsProvider(
                 metadataRepository.Object,
@@ -177,10 +267,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 new Channel(Guid.NewGuid())
                 {
+                    Number = "1",
                     FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
                     {
                         HardwareAcceleration = profileAcceleration,
-                        VideoCodec = profileCodec
+                        VideoCodec = profileCodec,
+                        AudioCodec = "aac"
                     },
                     StreamingMode = StreamingMode.TransportStream
                 },
@@ -197,26 +289,56 @@ namespace ErsatzTV.Core.Tests.FFmpeg
                 false,
                 FillerKind.None,
                 TimeSpan.Zero,
-                TimeSpan.FromSeconds(5));
+                TimeSpan.FromSeconds(5),
+                0,
+                None);
 
             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();
             
-            if (profileAcceleration != HardwareAccelerationKind.None && unsupportedMessages.Any(error.Contains))
+            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)
             {
                 var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
                 process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
@@ -229,8 +351,12 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             }
             else
             {
-                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-                process.ExitCode.Should().Be(0, error + Environment.NewLine + string.Join(" ", quotedArgs));
+                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));
+                }
             }
         }
         

ErsatzTV.Core.Tests/FFmpeg/WatermarkCalculatorTests.cs

@@ -0,0 +1,26 @@
+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);
+    }
+}

ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs

@@ -44,7 +44,7 @@ namespace ErsatzTV.Core.Tests.Fakes
                 .IfNone(SystemTime.MinValueUtc);
 
         public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
-            _files.Any(f => f.Path.StartsWith(libraryPath.Path + Path.DirectorySeparatorChar));
+            _folders.Any(f => f.Path == libraryPath.Path);
 
         public IEnumerable<string> ListSubdirectories(string folder) =>
             _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
@@ -53,6 +53,7 @@ namespace ErsatzTV.Core.Tests.Fakes
             _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
 
         public bool FileExists(string path) => _files.Any(f => f.Path == path);
+        public bool FolderExists(string folder) => false;
 
         public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
 

ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs

@@ -37,5 +37,6 @@ namespace ErsatzTV.Core.Tests.Fakes
             throw new NotSupportedException();
 
         public Task<bool> IsCustomPlaybackOrder(int collectionId) => false.AsTask();
+        public Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection) => Option<string>.None.AsTask();
     }
 }

ErsatzTV.Core.Tests/Jellyfin/JellyfinPathReplacementServiceTests.cs

@@ -0,0 +1,211 @@
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Runtime;
+using ErsatzTV.Core.Jellyfin;
+using FluentAssertions;
+using LanguageExt;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Jellyfin
+{
+    [TestFixture]
+    public class JellyfinPathReplacementServiceTests
+    {
+        [Test]
+        public async Task JellyfinWindows_To_EtvWindows()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"C:\Something\Some Shared Folder",
+                    LocalPath = @"C:\Something Else\Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinWindows_To_EtvLinux()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"C:\Something\Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinWindows_To_EtvLinux_UncPath()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinWindows_To_EtvLinux_UncPathWithTrailingSlash()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                    LocalPath = @"/mnt/something else/Some Shared Folder/",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinLinux_To_EtvWindows()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"/mnt/something/Some Shared Folder",
+                    LocalPath = @"C:\Something Else\Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+        }
+
+        [Test]
+        public async Task JellyfinLinux_To_EtvLinux()
+        {
+            var replacements = new List<JellyfinPathReplacement>
+            {
+                new()
+                {
+                    Id = 1,
+                    JellyfinPath = @"/mnt/something/Some Shared Folder",
+                    LocalPath = @"/mnt/something else/Some Shared Folder",
+                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+                }
+            };
+
+            var repo = new Mock<IMediaSourceRepository>();
+            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+            var runtime = new Mock<IRuntimeInfo>();
+            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+            var service = new JellyfinPathReplacementService(
+                repo.Object,
+                runtime.Object,
+                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+            string result = await service.GetReplacementJellyfinPath(
+                0,
+                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+        }
+    }
+}

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -6,7 +6,6 @@ using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
-using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -54,6 +53,10 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
                     .Returns(new List<string>().AsEnumerable().AsTask());
 
+                _mediaItemRepository = new Mock<IMediaItemRepository>();
+                _mediaItemRepository.Setup(x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()))
+                    .Returns(new List<int>().AsTask());
+
                 _localStatisticsProvider = new Mock<ILocalStatisticsProvider>();
                 _localMetadataProvider = new Mock<ILocalMetadataProvider>();
 
@@ -73,28 +76,11 @@ namespace ErsatzTV.Core.Tests.Metadata
             }
 
             private Mock<IMovieRepository> _movieRepository;
+            private Mock<IMediaItemRepository> _mediaItemRepository;
             private Mock<ILocalStatisticsProvider> _localStatisticsProvider;
             private Mock<ILocalMetadataProvider> _localMetadataProvider;
             private Mock<IImageCache> _imageCache;
 
-            [Test]
-            public async Task Missing_Folder()
-            {
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(Path.Combine(FakeRoot, Path.Combine("Movie (2020)", "Movie (2020).mkv")))
-                );
-                var libraryPath = new LibraryPath { Path = BadFakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsLeft.Should().BeTrue();
-                result.IfLeft(error => error.Should().BeOfType<MediaSourceInaccessible>());
-            }
-
             [Test]
             public async Task NewMovie_Statistics_And_FallbackMetadata(
                 [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
@@ -535,6 +521,9 @@ namespace ErsatzTV.Core.Tests.Metadata
             [Test]
             public async Task RenamedMovie_Should_Delete_Old_Movie()
             {
+                // TODO: handle this case more elegantly
+                // ideally, detect that the movie was renamed and still delete the old one (or update the path?)
+
                 string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
                 string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
 
@@ -557,12 +546,14 @@ namespace ErsatzTV.Core.Tests.Metadata
 
                 result.IsRight.Should().BeTrue();
 
-                _movieRepository.Verify(x => x.DeleteByPath(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.DeleteByPath(libraryPath, oldMoviePath), Times.Once);
+                _mediaItemRepository.Verify(
+                    x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
+                    Times.Once);
+                _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
             }
 
             [Test]
-            public async Task DeletedMovieAndFolder_Should_Delete_Old_Movie()
+            public async Task DeletedMovieAndFolder_Should_Flag_File_Not_Found()
             {
                 string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
                 string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
@@ -570,10 +561,8 @@ namespace ErsatzTV.Core.Tests.Metadata
                 _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
                     .Returns(new List<string> { oldMoviePath }.AsEnumerable().AsTask());
 
-                string moviePath = Path.Combine(movieFolder, "Movie (2020).mkv");
-
                 MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
+                    new FakeFolderEntry(FakeRoot)
                 );
                 var libraryPath = new LibraryPath
                     { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
@@ -586,11 +575,12 @@ namespace ErsatzTV.Core.Tests.Metadata
 
                 result.IsRight.Should().BeTrue();
 
-                _movieRepository.Verify(x => x.DeleteByPath(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.DeleteByPath(libraryPath, oldMoviePath), Times.Once);
+                _mediaItemRepository.Verify(
+                    x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
+                    Times.Once);
+                _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
             }
 
-
             private MovieFolderScanner GetService(params FakeFileEntry[] files) =>
                 new(
                     new FakeLocalFileSystem(new List<FakeFileEntry>(files)),
@@ -602,6 +592,25 @@ namespace ErsatzTV.Core.Tests.Metadata
                     new Mock<ISearchIndex>().Object,
                     new Mock<ISearchRepository>().Object,
                     new Mock<ILibraryRepository>().Object,
+                    _mediaItemRepository.Object,
+                    new Mock<IMediator>().Object,
+                    null,
+                    new Mock<ITempFilePool>().Object,
+                    new Mock<ILogger<MovieFolderScanner>>().Object
+                );
+            
+            private MovieFolderScanner GetService(params FakeFolderEntry[] folders) =>
+                new(
+                    new FakeLocalFileSystem(new List<FakeFileEntry>(), new List<FakeFolderEntry>(folders)),
+                    _movieRepository.Object,
+                    _localStatisticsProvider.Object,
+                    _localMetadataProvider.Object,
+                    new Mock<IMetadataRepository>().Object,
+                    _imageCache.Object,
+                    new Mock<ISearchIndex>().Object,
+                    new Mock<ISearchRepository>().Object,
+                    new Mock<ILibraryRepository>().Object,
+                    _mediaItemRepository.Object,
                     new Mock<IMediator>().Object,
                     null,
                     new Mock<ITempFilePool>().Object,

ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs

@@ -624,8 +624,11 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 Anchor = new PlayoutAnchor
                 {
                     NextStart = HoursAfterMidnight(9).UtcDateTime,
-                    NextScheduleItem = items[0],
-                    NextScheduleItemId = 1,
+                    ScheduleItemsEnumeratorState = new CollectionEnumeratorState
+                    {
+                        Index = 0,
+                        Seed = 1
+                    },
                     InFlood = true
                 }
             };
@@ -918,8 +921,11 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 Anchor = new PlayoutAnchor
                 {
                     NextStart = HoursAfterMidnight(1).UtcDateTime,
-                    NextScheduleItem = items[0],
-                    NextScheduleItemId = 1,
+                    ScheduleItemsEnumeratorState = new CollectionEnumeratorState
+                    {
+                        Index = 0,
+                        Seed = 1
+                    },
                     MultipleRemaining = 2
                 }
             };
@@ -951,7 +957,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
             result.Items[3].MediaItemId.Should().Be(2);
 
-            result.Anchor.NextScheduleItem.Should().Be(items[1]);
+            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(1);
             result.Anchor.MultipleRemaining.Should().Be(1);
         }
 
@@ -1048,7 +1054,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
             result.Items[4].MediaItemId.Should().Be(5);
 
-            result.Anchor.NextScheduleItem.Should().Be(items[0]);
+            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
             result.Anchor.MultipleRemaining.Should().BeNull();
         }
 
@@ -1116,8 +1122,11 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 Anchor = new PlayoutAnchor
                 {
                     NextStart = HoursAfterMidnight(1).UtcDateTime,
-                    NextScheduleItem = items[0],
-                    NextScheduleItemId = 1,
+                    ScheduleItemsEnumeratorState = new CollectionEnumeratorState
+                    {
+                        Index = 0,
+                        Seed = 1
+                    },
                     DurationFinish = HoursAfterMidnight(3).UtcDateTime
                 }
             };
@@ -1149,7 +1158,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
             result.Items[3].MediaItemId.Should().Be(2);
 
-            result.Anchor.NextScheduleItem.Should().Be(items[1]);
+            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(1);
             result.Anchor.DurationFinish.Should().Be(HoursAfterMidnight(6).UtcDateTime);
         }
         
@@ -1284,7 +1293,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Items[11].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 55, 0));
             result.Items[11].MediaItemId.Should().Be(3);
             
-            result.Anchor.NextScheduleItem.Should().Be(items[0]);
+            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
             result.Anchor.DurationFinish.Should().BeNull();
         }
         
@@ -1361,7 +1370,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
             result.Items[5].MediaItemId.Should().Be(4);
 
-            result.Anchor.NextScheduleItem.Should().Be(items[0]);
+            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
             result.Anchor.DurationFinish.Should().BeNull();
         }
 

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs

@@ -31,19 +31,25 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 PlaybackOrder = PlaybackOrder.Chronological
             };
 
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
+
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
                 new CollectionEnumeratorState());
+
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
             
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -51,26 +57,26 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
@@ -93,20 +99,26 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 PlaybackOrder = PlaybackOrder.Chronological,
                 CustomTitle = "Custom Title"
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -114,28 +126,28 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
             playoutItems[0].CustomTitle.Should().Be("Custom Title");
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
             playoutItems[1].CustomTitle.Should().Be("Custom Title");
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(1);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
@@ -158,20 +170,26 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 TailMode = TailMode.None,
                 PlaybackOrder = PlaybackOrder.Chronological
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -179,26 +197,26 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
             
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
@@ -220,48 +238,54 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 TailMode = TailMode.Offline,
                 PlaybackOrder = PlaybackOrder.Chronological
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
             // duration block should end after exact duration, with gap
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
             playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
             
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
@@ -290,6 +314,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionTwo.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -299,15 +327,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionTwo.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -315,7 +345,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
             
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -323,25 +353,25 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
             
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
             playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
@@ -370,6 +400,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionTwo.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -379,15 +413,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionTwo.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -395,7 +431,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
             
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -403,37 +439,37 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
@@ -462,6 +498,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionTwo.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -471,23 +511,25 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionTwo.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+            playoutItems.Last().FinishOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
             playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
             
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -495,37 +537,37 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[4].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[5].GuideFinish.HasValue.Should().BeFalse();
@@ -561,6 +603,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionThree.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -574,9 +620,11 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionThree.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -586,9 +634,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -596,7 +644,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
             
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -605,43 +653,43 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(7);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
             playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[4].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
             playoutItems[5].GuideFinish.HasValue.Should().BeFalse();
 
             playoutItems[6].MediaItemId.Should().Be(5);
-            playoutItems[6].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems[6].GuideGroup.Should().Be(3);
             playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
             playoutItems[6].GuideFinish.HasValue.Should().BeFalse();

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs

@@ -40,16 +40,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -57,29 +63,29 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }
         
-                [Test]
+        [Test]
         public void Should_Fill_Exactly_To_Next_Schedule_Item_Flood()
         {
             Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
@@ -109,16 +115,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     StartTime = TimeSpan.FromHours(3),
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -126,24 +138,24 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }
@@ -188,15 +200,21 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 NextScheduleItem
             };
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -204,7 +222,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -212,32 +230,32 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
 
             playoutItems[2].MediaItemId.Should().Be(2);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[2].GuideGroup.Should().Be(2);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(4);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 55, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 55, 0)));
             playoutItems[3].GuideGroup.Should().Be(2);
             playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
 
             playoutItems[4].MediaItemId.Should().Be(1);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.PostRoll);
         }
@@ -268,16 +286,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -285,24 +309,24 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }
@@ -343,16 +367,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -360,7 +390,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -368,32 +398,32 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
         }
@@ -434,16 +464,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -451,7 +487,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -459,22 +495,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
         }
@@ -515,16 +551,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -532,7 +574,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -540,32 +582,32 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
         }
@@ -616,10 +658,16 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -629,9 +677,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -639,7 +687,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -648,37 +696,37 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(7);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[6].MediaItemId.Should().Be(5);
-            playoutItems[6].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems[6].GuideGroup.Should().Be(3);
             playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
         }
@@ -729,10 +777,16 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 scheduleItem,
                 NextScheduleItem
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                sortedScheduleItems,
+                new CollectionEnumeratorState());
 
-            var scheduler = new PlayoutModeSchedulerFlood(sortedScheduleItems, new Mock<ILogger>().Object);
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -742,9 +796,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -752,7 +806,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(0);
@@ -761,17 +815,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerMultipleTests.cs

@@ -33,6 +33,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 FallbackFiller = null,
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -42,16 +46,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
             {
                 { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
             }.ToMap();
-    
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -59,24 +65,24 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }
@@ -98,6 +104,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 FallbackFiller = null,
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -107,16 +117,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
             {
                 { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
             }.ToMap();
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -124,24 +136,24 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }
@@ -169,6 +181,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 FallbackFiller = null,
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -183,16 +199,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
                 { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
             }.ToMap();
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -200,7 +218,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -208,32 +226,32 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
         }
@@ -261,6 +279,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 },
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -275,16 +297,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
                 { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionTwo.MediaItems }
             }.ToMap();
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -292,7 +316,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -300,22 +324,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
         }
@@ -343,6 +367,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 FallbackFiller = null,
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -357,16 +385,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
                 { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
             }.ToMap();
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -374,7 +404,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -382,32 +412,32 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(6);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
             
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
         
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
         }
@@ -441,6 +471,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 },
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -461,9 +495,11 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
             }.ToMap();
 
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -473,9 +509,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -483,7 +519,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -492,37 +528,37 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(7);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddMinutes(55));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
         
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
             
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[3].GuideGroup.Should().Be(3);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[4].GuideGroup.Should().Be(3);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
         
             playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[5].GuideGroup.Should().Be(3);
             playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[6].MediaItemId.Should().Be(5);
-            playoutItems[6].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems[6].GuideGroup.Should().Be(3);
             playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
         }
@@ -556,6 +592,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 },
                 Count = 3
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -575,10 +615,12 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
                 { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
             }.ToMap();
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -588,9 +630,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(4);
@@ -598,7 +640,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(0);
@@ -607,17 +649,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(3);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(2);
             playoutItems[1].FillerKind.Should().Be(FillerKind.None);
         
             playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.AddHours(2));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
             playoutItems[2].GuideGroup.Should().Be(3);
             playoutItems[2].FillerKind.Should().Be(FillerKind.None);
         }

ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerOneTests.cs

@@ -30,20 +30,26 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 TailFiller = null,
                 FallbackFiller = null
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
                 new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -51,14 +57,14 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator.State.Index.Should().Be(1);
 
             playoutItems.Count.Should().Be(1);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
         }
@@ -91,6 +97,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     Collection = collectionThree
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -104,15 +114,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionThree.MediaItems,
                 new CollectionEnumeratorState());
             
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -120,7 +132,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(0);
@@ -129,7 +141,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(1);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
         }
@@ -156,6 +168,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 },
                 FallbackFiller = null
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -164,16 +180,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
             var enumerator2 = new ChronologicalMediaCollectionEnumerator(
                 collectionTwo.MediaItems,
                 new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -181,7 +199,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -189,22 +207,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(1);
             playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
         
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[3].GuideGroup.Should().Be(1);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
         }
@@ -231,6 +249,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionTwo.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -239,16 +261,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
             var enumerator2 = new ChronologicalMediaCollectionEnumerator(
                 collectionTwo.MediaItems,
                 new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -256,7 +280,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -264,12 +288,12 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(2);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.AddHours(1));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.Fallback);
         }
@@ -296,6 +320,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 },
                 FallbackFiller = null
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -304,16 +332,18 @@ namespace ErsatzTV.Core.Tests.Scheduling
             var enumerator2 = new ChronologicalMediaCollectionEnumerator(
                 collectionTwo.MediaItems,
                 new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -321,7 +351,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -329,22 +359,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[2].GuideGroup.Should().Be(1);
             playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
         
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[3].GuideGroup.Should().Be(1);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
         }
@@ -377,6 +407,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionThree.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -389,10 +423,12 @@ namespace ErsatzTV.Core.Tests.Scheduling
             var enumerator3 = new ChronologicalMediaCollectionEnumerator(
                 collectionThree.MediaItems,
                 new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -402,9 +438,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -412,7 +448,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -421,27 +457,27 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(5);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
             playoutItems[2].GuideGroup.Should().Be(1);
             playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
         
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
             playoutItems[3].GuideGroup.Should().Be(1);
             playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
 
             playoutItems[4].MediaItemId.Should().Be(5);
-            playoutItems[4].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
             playoutItems[4].GuideGroup.Should().Be(1);
             playoutItems[4].FillerKind.Should().Be(FillerKind.Fallback);
         }
@@ -474,6 +510,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionThree.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -486,10 +526,12 @@ namespace ErsatzTV.Core.Tests.Scheduling
             var enumerator3 = new ChronologicalMediaCollectionEnumerator(
                 collectionThree.MediaItems,
                 new CollectionEnumeratorState());
+            
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
 
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(
                     scheduleItem,
                     enumerator1,
@@ -499,9 +541,9 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -509,7 +551,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(0);
@@ -518,7 +560,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(1);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
         }
@@ -553,6 +595,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionThree.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -566,15 +612,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionThree.MediaItems,
                 new CollectionEnumeratorState());
 
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -582,7 +630,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -590,22 +638,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
 
             playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(1);
             playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
         
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[3].GuideGroup.Should().Be(1);
             playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
         }
@@ -640,6 +688,10 @@ namespace ErsatzTV.Core.Tests.Scheduling
                     CollectionId = collectionThree.Id
                 }
             };
+            
+            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+                new List<ProgramScheduleItem> { scheduleItem },
+                new CollectionEnumeratorState());
 
             var enumerator1 = new ChronologicalMediaCollectionEnumerator(
                 collectionOne.MediaItems,
@@ -653,15 +705,17 @@ namespace ErsatzTV.Core.Tests.Scheduling
                 collectionThree.MediaItems,
                 new CollectionEnumeratorState());
 
+            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
             var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
             (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                StartState,
+                startState,
                 CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
                 scheduleItem,
                 NextScheduleItem,
-                HardStop);
+                HardStop(scheduleItemsEnumerator));
 
-            playoutBuilderState.CurrentTime.Should().Be(StartState.CurrentTime.AddHours(3));
+            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
             playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
 
             playoutBuilderState.NextGuideGroup.Should().Be(2);
@@ -669,7 +723,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutBuilderState.InFlood.Should().BeFalse();
             playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
             playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemIndex.Should().Be(1);
+            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
 
             enumerator1.State.Index.Should().Be(1);
             enumerator2.State.Index.Should().Be(1);
@@ -678,22 +732,22 @@ namespace ErsatzTV.Core.Tests.Scheduling
             playoutItems.Count.Should().Be(4);
 
             playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(StartState.CurrentTime);
+            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
             playoutItems[0].GuideGroup.Should().Be(1);
             playoutItems[0].FillerKind.Should().Be(FillerKind.None);
 
             playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
             playoutItems[1].GuideGroup.Should().Be(1);
             playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
 
             playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
             playoutItems[2].GuideGroup.Should().Be(1);
             playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
         
             playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(StartState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
             playoutItems[3].GuideGroup.Should().Be(1);
             playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
         }

ErsatzTV.Core.Tests/Scheduling/SchedulerTestBase.cs

@@ -10,8 +10,8 @@ namespace ErsatzTV.Core.Tests.Scheduling
 {
     public abstract class SchedulerTestBase
     {
-        protected static PlayoutBuilderState StartState => new(
-            0,
+        protected static PlayoutBuilderState StartState(IScheduleItemsEnumerator scheduleItemsEnumerator) => new(
+            scheduleItemsEnumerator,
             Prelude.None,
             Prelude.None,
             false,
@@ -24,7 +24,8 @@ namespace ErsatzTV.Core.Tests.Scheduling
             StartTime = null
         };
 
-        protected static DateTimeOffset HardStop => StartState.CurrentTime.AddHours(6);
+        protected static DateTimeOffset HardStop(IScheduleItemsEnumerator scheduleItemsEnumerator) =>
+            StartState(scheduleItemsEnumerator).CurrentTime.AddHours(6);
 
         protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
             ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator) =>

ErsatzTV.Core/Domain/Channel.cs

@@ -13,6 +13,8 @@ namespace ErsatzTV.Core.Domain
         public Guid UniqueId { get; init; }
         public string Number { get; set; }
         public string Name { get; set; }
+        public string Group { get; set; }
+        public string Categories { get; set; }
         public int FFmpegProfileId { get; set; }
         public FFmpegProfile FFmpegProfile { get; set; }
         public int? WatermarkId { get; set; }

ErsatzTV.Core/Domain/ChannelWatermark.cs

@@ -1,4 +1,6 @@
-namespace ErsatzTV.Core.Domain
+using ErsatzTV.FFmpeg.State;
+
+namespace ErsatzTV.Core.Domain
 {
     public class ChannelWatermark
     {
@@ -7,8 +9,8 @@
         public ChannelWatermarkMode Mode { get; set; }
         public ChannelWatermarkImageSource ImageSource { get; set; }
         public string Image { get; set; }
-        public ChannelWatermarkLocation Location { get; set; }
-        public ChannelWatermarkSize Size { get; set; }
+        public WatermarkLocation Location { get; set; }
+        public WatermarkSize Size { get; set; }
         public int WidthPercent { get; set; }
         public int HorizontalMarginPercent { get; set; }
         public int VerticalMarginPercent { get; set; }
@@ -17,24 +19,6 @@
         public int Opacity { get; set; }
     }
 
-    public enum ChannelWatermarkLocation
-    {
-        BottomRight = 0,
-        BottomLeft = 1,
-        TopRight = 2,
-        TopLeft = 3,
-        TopMiddle = 4,
-        RightMiddle = 5,
-        BottomMiddle = 6,
-        LeftMiddle = 7
-    }
-
-    public enum ChannelWatermarkSize
-    {
-        Scaled = 0,
-        ActualSize = 1
-    }
-
     public enum ChannelWatermarkMode
     {
         None = 0,