update changelog for release v0.7.1-beta [no ci]

* hide windows on windows

* update dependencies

.editorconfig

@@ -1,6 +1,6 @@
 
 [*]
-charset=utf-8-bom
+charset=utf-8
 end_of_line=lf
 trim_trailing_whitespace=false
 insert_final_newline=false

.github/workflows/artifacts.yml

@@ -41,18 +41,18 @@ jobs:
             target: osx-arm64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
           submodules: true
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x
 
       - name: Setup Node.js
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
           node-version: '14'
 
@@ -81,7 +81,10 @@ jobs:
 
       - 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
+        run: |
+          sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.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
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.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
@@ -108,15 +111,16 @@ jobs:
             --icon "ErsatzTV.app" 200 190 \
             --hide-extension "ErsatzTV.app" \
             --app-drop-link 600 185 \
+            --skip-jenkins \
             "ErsatzTV.dmg" \
             "ErsatzTV.app/"
 
       - name: Notarize
         shell: bash
         run: |
-          curl -o gon.zip -L -s "https://github.com/mitchellh/gon/releases/latest/download/gon_macos.zip"
-          unzip -o -q gon.zip
-          ./gon -log-level=debug -log-json ./gon.json
+          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 }}
@@ -129,7 +133,8 @@ jobs:
           rm -r ErsatzTV.app
 
       - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
+        uses: asfernandes/delete-release-assets@update-libraries-and-node
+        if: ${{ inputs.release_tag == 'develop' }}
         with:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}
@@ -167,20 +172,26 @@ jobs:
             target: win-x64
     steps:
       - name: Get the sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x
 
       - name: Setup Node.js
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
           node-version: '14'
 
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+        if: ${{ matrix.kind == 'windows' }}
+
       - name: Cache NPM dependencies
         uses: bahmutov/npm-install@v1.4.5
         with:
@@ -197,7 +208,7 @@ jobs:
         id: downloadffmpeg
         name: Download ffmpeg
         with:
-          url: "https://github.com/GyanD/codexffmpeg/releases/download/5.0/ffmpeg-5.0-full_build.7z"
+          url: "https://github.com/GyanD/codexffmpeg/releases/download/5.1/ffmpeg-5.1-full_build.7z"
           target: ffmpeg/
 
       - name: Build
@@ -208,11 +219,15 @@ jobs:
           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
+          sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+          dotnet publish ErsatzTV.Scanner/ErsatzTV.Scanner.csproj --framework net7.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" -p:InformationalVersion="${{ inputs.release_version }}-${{ matrix.target }}" -p:EnableCompressionInSingleFile=true -p:DebugType=Embedded -p:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net7.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
+            cargo build --manifest-path=ErsatzTV-Windows/Cargo.toml --release --all-features
+            ls -l ErsatzTV-Windows/target/release
+            mv ErsatzTV-Windows/target/release/ersatztv_windows.exe "$release_name/ErsatzTV-Windows.exe"
           fi
 
           # Download ffmpeg
@@ -235,7 +250,8 @@ jobs:
           AC_PASSWORD: ${{ secrets.ac_password }}
 
       - name: Delete old release assets
-        uses: mknejp/delete-release-assets@v1
+        uses: asfernandes/delete-release-assets@update-libraries-and-node
+        if: ${{ inputs.release_tag == 'develop' }}
         with:
           token: ${{ secrets.gh_token }}
           tag: ${{ inputs.release_tag }}

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Extract Docker Tag

.github/workflows/docker.yml

@@ -39,32 +39,36 @@ jobs:
             path: 'vaapi/'
             suffix: '-vaapi'
             qemu: false
+          - name: arm32v7
+            path: 'arm32v7/'
+            suffix: '-arm'
+            qemu: true
           - name: arm64
             path: 'arm64/'
             suffix: '-arm64'
             qemu: true
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v2
         if: ${{ matrix.qemu == true }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
+        uses: docker/setup-buildx-action@v2
         id: docker-buildx
 
       - name: Login to DockerHub
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.docker_hub_username }}
           password: ${{ secrets.docker_hub_access_token }}
 
       - name: Build and push
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
@@ -75,10 +79,10 @@ jobs:
           tags: |
             jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
             jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
-        if: ${{ matrix.name != 'arm64' }}
+        if: ${{ matrix.name != 'arm64' && matrix.name != 'arm32v7' }}
 
       - name: Build and push
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v3
         with:
           builder: ${{ steps.docker-buildx.outputs.name }}
           context: .
@@ -91,3 +95,18 @@ jobs:
             jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
             jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
         if: ${{ matrix.name == 'arm64' }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          builder: ${{ steps.docker-buildx.outputs.name }}
+          context: .
+          file: ./docker/${{ matrix.path }}Dockerfile
+          push: true
+          platforms: 'linux/arm/v7'
+          build-args: |
+            INFO_VERSION=${{ inputs.info_version }}-docker${{ matrix.suffix }}
+          tags: |
+            jasongdove/ersatztv:${{ inputs.base_version }}${{ matrix.suffix }}
+            jasongdove/ersatztv:${{ inputs.tag_version }}${{ matrix.suffix }}
+        if: ${{ matrix.name == 'arm32v7' }}

.github/workflows/docs.yml

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

.github/workflows/pr.yml

@@ -2,20 +2,21 @@
 on:
   pull_request:
 jobs:
-  build_and_test:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, ubuntu-latest, macos-latest ]
+  build_and_test_windows:
+    runs-on: windows-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
 
       - name: Clean
         run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -23,6 +24,67 @@ jobs:
       - name: Install dependencies
         run: dotnet restore
 
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+
+      - name: Build Windows
+        run: |
+          cd ErsatzTV-Windows
+          cargo build --release --all-features
+  build_and_test_linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
+      - name: Build
+        run: dotnet build --configuration Release --no-restore
+
+      - name: Test
+        run: dotnet test --no-restore --verbosity normal
+  build_and_test_mac:
+    runs-on: macos-latest
+    steps:
+      - name: Get the sources
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Clean
+        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Prep project file
+        run: sed -i '' '/Scanner/d' ErsatzTV/ErsatzTV.csproj
+
       - name: Build
         run: dotnet build --configuration Release --no-restore
 

.github/workflows/release.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Get the sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Extract Docker Tag

.github/workflows/vue-lint.yml

@@ -7,10 +7,10 @@ jobs:
     steps:
       # Checkout the current repo
       - name: Checkout current repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       # Setup NodeJS version 14  
       - name: Setup NodeJS V14.x.x
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
           node-version: '14'
       # CD into the current client directory and lint and build the client

CHANGELOG.md

@@ -1,10 +1,241 @@
-# Changelog
+ Changelog
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [0.7.1-beta] - 2023-01-03
+### Added
+- Add new music video credit templates
+
+### Fixed
+- Fix many transcoding failures caused by the colorspace filter
+- Fix song playback with VAAPI and NVENC
+- Fix edge case where some local movies would not automatically be restored from trash
+- Fix synchronizing Jellyfin and Emby collection items
+- Fix saving some external subtitle records to database 
+
+### Changed
+- Upgrade to dotnet 7
+- Upgrade all docker images to ubuntu jammy and ffmpeg 5.1.2
+- Limit library scan interval between 0 and 1,000,000
+  - 0 means do not automatically scan libraries
+  - 1 to 999,999 means scan if it has been that many hours since the last scan
+- Use new `ErsatzTV.Scanner` process for scanning all libraries
+  - This should reduce the ongoing memory footprint
+
+## [0.7.0-beta] - 2022-12-11
+### Fixed
+- Fix removing Jellyfin and Emby libraries that have been deleted from the source media server
+- Fix `Work-Ahead HLS Segmenter Limit` setting to properly limit number of channels that can work-ahead at once
+- Include base path value in generated channel playlist (M3U) and channel guide (XMLTV) links
+- Fix parsing song metadata from OGG audio files
+- Properly unlock/re-enable trakt list operations after an operation is canceled
+
+### Added
+- Add (required) bit depth normalization option to ffmpeg profile
+  - This can help if your card only supports e.g. h264 encoding, normalizing to 8 bits will allow the hardware encoder to be used
+- Extract font attachments after extracting text subtitles
+  - This should improve SubStation Alpha subtitle rendering
+- Detect VAAPI capabilities and fallback to software decoding/encoding as needed
+- Add audio stream selector scripts for episodes and movies
+  - This will let you customize which audio stream is selected for playback
+  - Episodes are passed the following data:
+    - `channelNumber`
+    - `channelName`
+    - `showTitle`
+    - `showGuids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `seasonNumber`
+    - `episodeNumber`
+    - `episodeGuids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `preferredLanguageCodes`: array of string preferred language codes configured for the channel
+    - `audioStreams`: array of audio stream data, each containing
+      - `index`: the stream's index number, this is what the function needs to return
+      - `channels`: the number of audio channels
+      - `codec`: the audio codec
+      - `isDefault`: bool indicating whether the stream is flagged as default
+      - `isForced`: bool indicating whether the stream is flagged as forced
+      - `language`: the stream's language
+      - `title`: the stream's title
+  - Movies are passed the following data:
+      - `channelNumber`
+      - `channelName`
+      - `title`
+      - `guids`: array of string ids like `imdb_1234` or `tvdb_1234`
+    - `preferredLanguageCodes`: array of string preferred language codes configured for the channel
+    - `audioStreams`: array of audio stream data, each containing
+        - `index`: the stream's index number, this is what the function needs to return
+        - `channels`: the number of audio channels
+        - `codec`: the audio codec
+        - `isDefault`: bool indicating whether the stream is flagged as default
+        - `isForced`: bool indicating whether the stream is flagged as forced
+        - `language`: the stream's language
+        - `title`: the stream's title
+- Add new fields to search index
+  - `video_codec`: the video codec
+  - `video_bit_depth`: the number of bits in the video stream's pixel format, e.g. 8 or 10
+  - `video_dynamic_range`: the video's dynamic range, either `sdr` or `hdr`
+
+### Changed
+- Change `Multi-Episode Shuffle` scripting system to use Javascript instead of Lua
+
+## [0.6.9-beta] - 2022-10-21
+### Fixed
+- Fix bug where tail or fallback filler would sometimes schedule much longer than expected
+  - This only happened with fixed start schedule items following a schedule item with tail or fallback filler
+- Fix NFO reader bug that caused inaccurate warning messages about invalid XML and incomplete metadata
+- Fix reverse proxy SSL termination support by supporting `X-Forwarded-Proto` header
+- Fix automatic playout reset scheduling
+  - Playouts would reset every 30 minutes between midnight and the configured time, instead of only at the configured time
+- XMLTV: properly group schedule items with `Custom Title` followed by item(s) with `Guide Mode` set to `Filler`
+
+### Added
+- Add music video credits template system
+  - Templates are selected in each channel's settings 
+  - Templates should be copied from `_default.ass.sbntxt` which is located in the config subfolder `templates/music-video-credits`
+    - Copy the file, give it any name ending with `.ass.sbntext`, and only make edits to the copied file
+  - The default template will be extracted and overwritten every time ErsatzTV is started
+  - The template is an [Advanced SubStation Alpha](http://www.tcax.org/docs/ass-specs.htm) file using [scribian](https://github.com/scriban/scriban/tree/master/doc) template syntax
+  - The following fields are available for use in the template:
+    - `resolution`: the ffmpeg profile's resolution, which is used for margin calculations
+    - `title`: the title of the music video
+    - `track`: the music video's track number
+    - `album`: the music video's album
+    - `plot`: the music video's plot
+    - `release_date`: the music video's release date
+    - `artist`: the music videos artist (the parent folder)
+    - `all_artists`: a list of additional artists from the music video's sidecar NFO metadata file
+    - `duration`: the timespan duration of the music video, which can be used to calculate timing of additional subtitles
+    - `stream_seek`: the timespan that ffmpeg will seek into the media item before beginning playback
+- Add `Multi-Episode Shuffle` playout order for `Television Show` schedule items
+  - The purpose of this playout order is to improve randomization for shows that normally have intro, multiple episodes, and outro
+  - This playout order requires splitting the parts into individual files (e.g. splitting `s01e01-03.mkv` into `s01e01.mkv`, `s01e02.mkv` and `s01e03.mkv`)
+  - This playout order requires a lua script in the config subfolder `scripts/multi-episode-shuffle`
+  - The lua script should be named for the television show's guid, e.g. `tvdb_12345.lua` or `imdb_tt123456789.lua`
+  - The script defines the number of parts that each un-split file typically contains
+  - The script also defines a function to map each episode to a part number (or no part number i.e. `nil` if an episode has not been split)
+  - All groups of part numbers (i.e. all part 1s, all part 2s) will be shuffled
+  - The playout order will then schedule a random part 1 followed by a random part 2, etc
+    - Un-split (`nil`) episodes will be randomly placed between re-combined parts (e.g. part1, part2, part3, un-split, part1, part2, part3)
+- Add `ETV_BASE_URL` environment variable to support reverse proxies that use paths (e.g. `/ersatztv`)
+
+### Changed
+- No longer place watermarks within content by default (e.g. within 4:3 content padded to a 16:9 resolution)
+  - This can be re-enabled if desired using the `Place Within Source Content` checkbox in watermark settings
+
+## [0.6.8-beta] - 2022-10-05
+### Fixed
+- Fix typo introduced in `0.6.7-beta` that stopped QSV HEVC encoder from working
+- Fix scaling logic for `Nvidia` acceleration and software mode
+- Attempt to position watermarks within content (not over added black padding)
+- Fix search results for `Other Videos` when NFO metadata is used
+- Properly synchronize tags from Emby movies and shows
+- Properly sync updated file paths from Plex
+- Fix numeric range search queries (e.g. `minutes:[5 TO 10]`, `minutes:[* TO 3]`)
+
+### Added
+- Add `QSV Device` option to ffmpeg profile on linux
+- Add guids to search index (e.g. `imdb:tt000000`, `tvdb:12345`)
+
+## [0.6.7-beta] - 2022-09-05
+### Fixed
+- When all audio streams are selected with `HLS Direct`, explicitly copy them without transcoding
+  - This only happens when the channel does not have a `Preferred Audio Language`
+- Fix scanner crash caused by invalid mtime
+- `VAAPI`: Downgrade libva from 2.15 to 2.14
+- Fix bug with XMLTV that caused some filler to display with primary content details
+- Multiple fixes for content scaling with `Nvidia`, `Qsv` and `Vaapi` accelerations
+- Properly scale image-based subtitles
+- Fix bug where a schedule containing a single item (fixed start and flood) would never finish building a playout
+  - Logic was also added to detect infinite playout build loops in the future and stop them
+- Fix bug where `Other Videos` wouldn't be included in scheduling mode `Shuffle In Order`
+
+### Added
+- Add `Preferred Audio Title` feature
+    - Preference can be configured in channel settings and overridden on schedule items
+    - When a title is specified, audio streams that contain that title (case-insensitive search) will be prioritized
+    - This can be helpful for creating channels that use commentary tracks
+    - External tooling exists to easily update title/name metadata if your audio streams don't already have this metadata
+- Add `Amf` hardware acceleration option for AMD GPUs on Windows
+- Add `QSV Extra Hardware Frames` parameter for tuning QSV acceleration
+  - Performance may improve on some systems after doubling or halving the default value of `64`
+
+## [0.6.6-beta] - 2022-08-17
+### Fixed
+- Use MIME Type `application/x-mpegurl` for all playlists instead of `application/vnd.apple.mpegurl`
+- Replace `setsar` filter with `setdar` filter
+  - `setsar` caused issues scaling between two different aspect ratios
+    - For example, some 4:3 content would appear stretched when scaled to a 16:9 resolution
+  - `setdar` is now only used when aspect ratios match 
+- Prioritize aspect ratio from container when video stream contains conflicting aspect ratio
+  - This is usually caused by bad authoring, but the change should improve scaling behavior for edge cases
+
+### Added
+- Support DSD audio file formats (DFF and DSF) in local song libraries
+- Support OGG audio file formats (OGG, OPUS, OGA, OGX, SPX) in local song libraries
+
+### Changed
+- Always return playlist after a maximum of 8 seconds while starting up an HLS Segmenter session
+- Use multi-variant playlists instead of redirects for HLS Segmenter sessions
+- Upgrade ffmpeg from 5.0 to 5.1 in most docker images (not ARM variants)
+    - Upgrading from 5.0 to 5.1 is also recommended for other installations (Windows, Linux)
+
+## [0.6.5-beta] - 2022-08-02
+### Fixed
+- Fix database initializer; fresh installs with v0.6.4-beta are missing some config data and should upgrade
+
+## [0.6.4-beta] - 2022-07-28
+### Fixed
+- Fix subtitle stream selection when subtitle language is different than audio language
+- Fix bug with unsupported AAC channel layouts
+- Fix NVIDIA second-gen maxwell capabilities detection
+- Return distinct search results for episodes and other videos that have the same title
+  - For example, two other videos both named `Trailer` would previously have displayed as one item in search results
+- Fix schedules that would begin to repeat the same content in the same order after a couple of days
+
+### Added
+- Add `640x480` resolution
+
+## [0.6.3-beta] - 2022-07-04
+### Fixed
+- Maintain stream continuity when playout is rebuilt for a channel that is actively being streamed
+- Properly apply changes to episode title, sort title, outline and plot from Plex
+- Fix search index for other videos and songs
+  - In previous versions, some libraries would incorrectly display only one item
+- Properly display old versions of renamed items in trash
+
+### Added
+- Add `Minimum Log Level` option to `Settings` page
+  - Other methods of configuring the log level will no longer work
+
+## [0.6.2-beta] - 2022-06-18
+### Fixed
+- Fix content repeating for up to a minute near the top of every hour
+- Check whether hardware-accelerated hevc codecs are supported by the NVIDIA card
+  - Software codecs will be used if they are unsupported by the NVIDIA card
+- Fix sorting of channel contents in EPG
+- Fix Jellyfin admin user id sync
+  - Ignore disabled admins and admins who do not have access to all libraries
+
+### Added
+- Add 32-bit `arm` docker tags (`develop-arm` and `latest-arm`)
+
+### Changed
+- Regularly delete old segments from transcode folder while content is actively transcoding
+  - This should help reduce required disk space
+  - To further minimize required disk space, set `Work-Ahead HLS Segmenter Limit` to `0` in `Settings`
+
+## [0.6.1-beta] - 2022-06-03
+### Fixed
+- Fix Jellyfin show library paging
+- Properly locate and identify multiple Plex servers
+- Properly restore `Unavailable`/`File Not Found` items when they are located on disk
+
+### Added
+- Add basic music video credits subtitle generation
+  - This can be enabled in channel settings
+
 ## [0.6.0-beta] - 2022-06-01
 ### Fixed
 - Additional fix for duplicate `Other Videos` entries; trash may need to be emptied one last time after upgrading
@@ -1225,7 +1456,18 @@ 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.6.0-beta...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.1-beta...HEAD
+[0.7.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.7.0-beta...v0.7.1-beta
+[0.7.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.9-beta...v0.7.0-beta
+[0.6.9-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.8-beta...v0.6.9-beta
+[0.6.8-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.7-beta...v0.6.8-beta
+[0.6.7-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.6-beta...v0.6.7-beta
+[0.6.6-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.5-beta...v0.6.6-beta
+[0.6.5-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.4-beta...v0.6.5-beta
+[0.6.4-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.3-beta...v0.6.4-beta
+[0.6.3-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.2-beta...v0.6.3-beta
+[0.6.2-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.1-beta...v0.6.2-beta
+[0.6.1-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.0-beta...v0.6.1-beta
 [0.6.0-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.8-beta...v0.6.0-beta
 [0.5.8-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.7-beta...v0.5.8-beta
 [0.5.7-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.6-beta...v0.5.7-beta
@@ -1322,4 +1564,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 [0.0.5-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.4-prealpha...v0.0.5-prealpha
 [0.0.4-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.3-prealpha...v0.0.4-prealpha
 [0.0.3-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.1-prealpha...v0.0.3-prealpha
-[0.0.1-prealpha]: https://github.com/jasongdove/ErsatzTV/releases/tag/v0.0.1-prealpha
+[0.0.1-prealpha]: https://github.com/jasongdove/ErsatzTV/releases/tag/v0.0.1-prealpha

ErsatzTV-Windows/.gitignore

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

ErsatzTV-Windows/Cargo.toml

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

ErsatzTV-Windows/ErsatzTV-Windows.csproj

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

ErsatzTV-Windows/Program.cs

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

ErsatzTV-Windows/TrayApplicationContext.cs

@@ -1,81 +0,0 @@
-using ErsatzTV.Core;
-using System.Diagnostics;
-using CliWrap;
-
-namespace ErsatzTV_Windows;
-
-public class TrayApplicationContext : ApplicationContext
-{
-    private readonly NotifyIcon _trayIcon;
-    private readonly CancellationTokenSource _tokenSource;
-
-    public TrayApplicationContext()
-    {
-        _trayIcon = new NotifyIcon
-        {
-            Icon = new Icon("./Ersatztv.ico"),
-            ContextMenuStrip = new ContextMenuStrip(),
-            Visible = true
-        };
-
-        _tokenSource = new CancellationTokenSource();
-
-        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))
-        {
-
-            Cli.Wrap(exe)
-                .WithWorkingDirectory(folder)
-                .WithValidation(CommandResultValidation.None)
-                .ExecuteAsync(_tokenSource.Token);
-        }
-    }
-
-    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)
-    {
-        _tokenSource?.Cancel();
-        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-Windows/build.rs

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

ErsatzTV-Windows/ersatztv_windows.rc

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

ErsatzTV-Windows/src/main.rs

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

ErsatzTV.Application/Channels/ChannelViewModel.cs

@@ -11,9 +11,12 @@ public record ChannelViewModel(
     int FFmpegProfileId,
     string Logo,
     string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     int PlayoutCount,
     string PreferredSubtitleLanguageCode,
-    ChannelSubtitleMode SubtitleMode);
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate);

ErsatzTV.Application/Channels/Commands/CreateChannel.cs

@@ -12,8 +12,11 @@ public record CreateChannel
     int FFmpegProfileId,
     string Logo,
     string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     string PreferredSubtitleLanguageCode,
-    ChannelSubtitleMode SubtitleMode) : IRequest<Either<BaseError, CreateChannelResult>>;
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, CreateChannelResult>>;

ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs

@@ -21,7 +21,7 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => PersistChannel(dbContext, c));
+        return await validation.Apply(c => PersistChannel(dbContext, c));
     }
 
     private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
@@ -71,8 +71,11 @@ public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseEr
                     StreamingMode = request.StreamingMode,
                     Artwork = artwork,
                     PreferredAudioLanguageCode = preferredAudioLanguageCode,
+                    PreferredAudioTitle = request.PreferredAudioTitle,
                     PreferredSubtitleLanguageCode = preferredSubtitleLanguageCode,
-                    SubtitleMode = request.SubtitleMode
+                    SubtitleMode = request.SubtitleMode,
+                    MusicVideoCreditsMode = request.MusicVideoCreditsMode,
+                    MusicVideoCreditsTemplate = request.MusicVideoCreditsTemplate
                 };
 
                 foreach (int id in watermarkId)

ErsatzTV.Application/Channels/Commands/UpdateChannel.cs

@@ -13,8 +13,11 @@ public record UpdateChannel
     int FFmpegProfileId,
     string Logo,
     string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
     StreamingMode StreamingMode,
     int? WatermarkId,
     int? FallbackFillerId,
     string PreferredSubtitleLanguageCode,
-    ChannelSubtitleMode SubtitleMode) : IRequest<Either<BaseError, ChannelViewModel>>;
+    ChannelSubtitleMode SubtitleMode,
+    ChannelMusicVideoCreditsMode MusicVideoCreditsMode,
+    string MusicVideoCreditsTemplate) : IRequest<Either<BaseError, ChannelViewModel>>;

ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs

@@ -31,7 +31,7 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+        return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
     }
 
     private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
@@ -42,8 +42,11 @@ public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseEr
         c.Categories = update.Categories;
         c.FFmpegProfileId = update.FFmpegProfileId;
         c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
+        c.PreferredAudioTitle = update.PreferredAudioTitle;
         c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
         c.SubtitleMode = update.SubtitleMode;
+        c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
+        c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
         c.Artwork ??= new List<Artwork>();
 
         if (!string.IsNullOrWhiteSpace(update.Logo))

ErsatzTV.Application/Channels/Mapper.cs

@@ -15,12 +15,15 @@ internal static class Mapper
             channel.FFmpegProfileId,
             GetLogo(channel),
             channel.PreferredAudioLanguageCode,
+            channel.PreferredAudioTitle,
             channel.StreamingMode,
             channel.WatermarkId,
             channel.FallbackFillerId,
             channel.Playouts?.Count ?? 0,
             channel.PreferredSubtitleLanguageCode,
-            channel.SubtitleMode);
+            channel.SubtitleMode,
+            channel.MusicVideoCreditsMode,
+            channel.MusicVideoCreditsTemplate);
 
     internal static ChannelResponseModel ProjectToResponseModel(Channel channel) =>
         new(

ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.Channels;
 
-public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
+public record GetChannelGuide(string Scheme, string Host, string BaseUrl) : IRequest<ChannelGuide>;

ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs

@@ -19,5 +19,11 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGu
 
     public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
         _channelRepository.GetAllForGuide()
-            .Map(channels => new ChannelGuide(_recyclableMemoryStreamManager, request.Scheme, request.Host, channels));
+            .Map(
+                channels => new ChannelGuide(
+                    _recyclableMemoryStreamManager,
+                    request.Scheme,
+                    request.Host,
+                    request.BaseUrl,
+                    channels));
 }

ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs

@@ -2,4 +2,4 @@
 
 namespace ErsatzTV.Application.Channels;
 
-public record GetChannelPlaylist(string Scheme, string Host, string Mode) : IRequest<ChannelPlaylist>;
+public record GetChannelPlaylist(string Scheme, string Host, string BaseUrl, string Mode) : IRequest<ChannelPlaylist>;

ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs

@@ -14,7 +14,7 @@ public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, Cha
     public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
         _channelRepository.GetAll()
             .Map(channels => EnsureMode(channels, request.Mode))
-            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, channels));
+            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, request.BaseUrl, channels));
 
     private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Commands/UpdateGeneralSettingsHandler.cs

@@ -0,0 +1,32 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using Serilog.Core;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateGeneralSettingsHandler : IRequestHandler<UpdateGeneralSettings, Either<BaseError, Unit>>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly LoggingLevelSwitch _loggingLevelSwitch;
+
+    public UpdateGeneralSettingsHandler(
+        LoggingLevelSwitch loggingLevelSwitch,
+        IConfigElementRepository configElementRepository)
+    {
+        _loggingLevelSwitch = loggingLevelSwitch;
+        _configElementRepository = configElementRepository;
+    }
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateGeneralSettings request,
+        CancellationToken cancellationToken) => await ApplyUpdate(request.GeneralSettings);
+
+    private async Task<Unit> ApplyUpdate(GeneralSettingsViewModel generalSettings)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.MinimumLogLevel, generalSettings.MinimumLogLevel);
+        _loggingLevelSwitch.MinimumLevel = generalSettings.MinimumLogLevel;
+
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs

@@ -24,8 +24,8 @@ public class UpdateLibraryRefreshIntervalHandler :
 
     private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
         Optional(request.LibraryRefreshInterval)
-            .Where(lri => lri > 0)
+            .Where(lri => lri is >= 0 and < 1_000_000)
             .Map(_ => Unit.Default)
-            .ToValidation<BaseError>("Tuner count must be greater than zero")
+            .ToValidation<BaseError>("Library refresh interval must be zero or greated")
             .AsTask();
 }

ErsatzTV.Application/Configuration/GeneralSettingsViewModel.cs

@@ -0,0 +1,8 @@
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GeneralSettingsViewModel
+{
+    public LogEventLevel MinimumLogLevel { get; set; }
+}

ErsatzTV.Application/Configuration/Queries/GetGeneralSettings.cs

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

ErsatzTV.Application/Configuration/Queries/GetGeneralSettingsHandler.cs

@@ -0,0 +1,24 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using Serilog.Events;
+
+namespace ErsatzTV.Application.Configuration;
+
+public class GetGeneralSettingsHandler : IRequestHandler<GetGeneralSettings, GeneralSettingsViewModel>
+{
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public GetGeneralSettingsHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<GeneralSettingsViewModel> Handle(GetGeneralSettings request, CancellationToken cancellationToken)
+    {
+        Option<LogEventLevel> maybeLogLevel =
+            await _configElementRepository.GetValue<LogEventLevel>(ConfigElementKey.MinimumLogLevel);
+
+        return new GeneralSettingsViewModel
+        {
+            MinimumLogLevel = await maybeLogLevel.IfNoneAsync(LogEventLevel.Information)
+        };
+    }
+}

ErsatzTV.Application/Emby/Commands/CallEmbyLibraryScannerHandler.cs

@@ -0,0 +1,55 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.FFmpeg.Runtime;
+
+namespace ErsatzTV.Application.Emby;
+
+public class CallEmbyLibraryScannerHandler : CallLibraryScannerHandler,
+    IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallEmbyLibraryScannerHandler(
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizeEmbyLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = Validate();
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error => Task.FromResult<Either<BaseError, string>>(error.Join()));
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-emby", request.EmbyLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+}

ErsatzTV.Application/Emby/Commands/SynchronizeEmbyCollections.cs

@@ -1,6 +0,0 @@
-using ErsatzTV.Core;
-
-namespace ErsatzTV.Application.Emby;
-
-public record SynchronizeEmbyCollections(int EmbyMediaSourceId) : IRequest<Either<BaseError, Unit>>,
-    IEmbyBackgroundServiceRequest;

ErsatzTV.Application/ErsatzTV.Application.csproj

@@ -1,22 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
         <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Bugsnag" Version="3.0.1" />
-      <PackageReference Include="CliWrap" Version="3.4.4" />
+      <PackageReference Include="Bugsnag" Version="3.1.0" />
+      <PackageReference Include="CliWrap" Version="3.6.0" />
       <PackageReference Include="Humanizer.Core" Version="2.14.1" />
-      <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.2.32">
+      <PackageReference Include="MediatR" Version="11.1.0" />
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.4.27">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
+      <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="2.0.0" />
       <PackageReference Include="Winista.MimeDetect" Version="1.0.1" />
     </ItemGroup>
 

ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings

@@ -40,5 +40,6 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=subtitles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=television_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=templates_005Cqueries/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Ccommands/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Cqueries/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs

@@ -10,8 +10,10 @@ public record CreateFFmpegProfile(
     HardwareAccelerationKind HardwareAcceleration,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
+    int? QsvExtraHardwareFrames,
     int ResolutionId,
     FFmpegProfileVideoFormat VideoFormat,
+    FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
     FFmpegProfileAudioFormat AudioFormat,

ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs

@@ -20,7 +20,7 @@ public class CreateFFmpegProfileHandler :
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, profile => PersistFFmpegProfile(dbContext, profile));
+        return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
     }
 
     private static async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
@@ -44,8 +44,10 @@ public class CreateFFmpegProfileHandler :
                 HardwareAcceleration = request.HardwareAcceleration,
                 VaapiDriver = request.VaapiDriver,
                 VaapiDevice = request.VaapiDevice,
+                QsvExtraHardwareFrames = request.QsvExtraHardwareFrames,
                 ResolutionId = resolutionId,
                 VideoFormat = request.VideoFormat,
+                BitDepth = request.BitDepth,
                 VideoBitrate = request.VideoBitrate,
                 VideoBufferSize = request.VideoBufferSize,
                 AudioFormat = request.AudioFormat,

ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfileHandler.cs

@@ -15,7 +15,7 @@ public class NewFFmpegProfileHandler : IRequestHandler<NewFFmpegProfile, FFmpegP
 
     public async Task<FFmpegProfileViewModel> Handle(NewFFmpegProfile request, CancellationToken cancellationToken)
     {
-        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
         int defaultResolutionId = await dbContext.ConfigElements
             .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId)

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs

@@ -11,8 +11,10 @@ public record UpdateFFmpegProfile(
     HardwareAccelerationKind HardwareAcceleration,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
+    int? QsvExtraHardwareFrames,
     int ResolutionId,
     FFmpegProfileVideoFormat VideoFormat,
+    FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
     FFmpegProfileAudioFormat AudioFormat,

ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs

@@ -20,7 +20,7 @@ public class
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, p => ApplyUpdateRequest(dbContext, p, request));
+        return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
     }
 
     private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
@@ -33,8 +33,10 @@ public class
         p.HardwareAcceleration = update.HardwareAcceleration;
         p.VaapiDriver = update.VaapiDriver;
         p.VaapiDevice = update.VaapiDevice;
+        p.QsvExtraHardwareFrames = update.QsvExtraHardwareFrames;
         p.ResolutionId = update.ResolutionId;
         p.VideoFormat = update.VideoFormat;
+        p.BitDepth = update.BitDepth;
         p.VideoBitrate = update.VideoBitrate;
         p.VideoBufferSize = update.VideoBufferSize;
         p.AudioFormat = update.AudioFormat;

ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs

@@ -11,8 +11,10 @@ public record FFmpegProfileViewModel(
     HardwareAccelerationKind HardwareAcceleration,
     VaapiDriver VaapiDriver,
     string VaapiDevice,
+    int? QsvExtraHardwareFrames,
     ResolutionViewModel Resolution,
     FFmpegProfileVideoFormat VideoFormat,
+    FFmpegProfileBitDepth BitDepth,
     int VideoBitrate,
     int VideoBufferSize,
     FFmpegProfileAudioFormat AudioFormat,

ErsatzTV.Application/FFmpegProfiles/Mapper.cs

@@ -14,8 +14,10 @@ internal static class Mapper
             profile.HardwareAcceleration,
             profile.VaapiDriver,
             profile.VaapiDevice,
+            profile.QsvExtraHardwareFrames,
             Project(profile.Resolution),
             profile.VideoFormat,
+            profile.BitDepth,
             profile.VideoBitrate,
             profile.VideoBufferSize,
             profile.AudioFormat,
@@ -35,6 +37,27 @@ internal static class Mapper
             ffmpegProfile.VideoFormat.ToString().ToLowerInvariant(),
             ffmpegProfile.AudioFormat.ToString().ToLowerInvariant());
 
+    internal static FFmpegFullProfileResponseModel ProjectToFullResponseModel(FFmpegProfile ffmpegProfile) =>
+        new(
+            ffmpegProfile.Id,
+            ffmpegProfile.Name,
+            ffmpegProfile.ThreadCount,
+            (int)ffmpegProfile.HardwareAcceleration,
+            (int)ffmpegProfile.VaapiDriver,
+            ffmpegProfile.VaapiDevice,
+            ffmpegProfile.ResolutionId,
+            (int)ffmpegProfile.VideoFormat,
+            ffmpegProfile.VideoBitrate,
+            ffmpegProfile.VideoBufferSize,
+            (int)ffmpegProfile.AudioFormat,
+            ffmpegProfile.AudioBitrate,
+            ffmpegProfile.AudioBufferSize,
+            ffmpegProfile.NormalizeLoudness,
+            ffmpegProfile.AudioChannels,
+            ffmpegProfile.AudioSampleRate,
+            ffmpegProfile.NormalizeFramerate,
+            ffmpegProfile.DeinterlaceVideo);
+
     private static ResolutionViewModel Project(Resolution resolution) =>
         new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
 }

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.FFmpegProfiles;
+
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record GetFFmpegFullProfileByIdForApi(int Id) : IRequest<Option<FFmpegFullProfileResponseModel>>;

ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdForApiHandler.cs

@@ -0,0 +1,28 @@
+using ErsatzTV.Core.Api.FFmpegProfiles;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.FFmpegProfiles.Mapper;
+
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class
+    GetFFmpegProfileByIdForApiHandler : IRequestHandler<GetFFmpegFullProfileByIdForApi,
+        Option<FFmpegFullProfileResponseModel>>
+{
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetFFmpegProfileByIdForApiHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<FFmpegFullProfileResponseModel>> Handle(
+        GetFFmpegFullProfileByIdForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.FFmpegProfiles
+            .Include(p => p.Resolution)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.Id)
+            .MapT(ProjectToFullResponseModel);
+    }
+}

ErsatzTV.Application/ISearchIndexBackgroundServiceRequest.cs

@@ -0,0 +1,5 @@
+namespace ErsatzTV.Application;
+
+public interface ISearchIndexBackgroundServiceRequest
+{
+}

ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs

@@ -69,7 +69,7 @@ public class
 
                     string originalPath = _imageCache.GetPathForImage(request.FileName, request.ArtworkKind, None);
 
-                    Command process = _ffmpegProcessService.ResizeImage(
+                    Command process = await _ffmpegProcessService.ResizeImage(
                         ffmpegPath,
                         originalPath,
                         withExtension,

ErsatzTV.Application/Jellyfin/Commands/CallJellyfinLibraryScannerHandler.cs

@@ -0,0 +1,55 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.FFmpeg.Runtime;
+
+namespace ErsatzTV.Application.Jellyfin;
+
+public class CallJellyfinLibraryScannerHandler : CallLibraryScannerHandler,
+    IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallJellyfinLibraryScannerHandler(
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizeJellyfinLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = Validate();
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error => Task.FromResult<Either<BaseError, string>>(error.Join()));
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-jellyfin", request.JellyfinLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+}

ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinCollections.cs

@@ -1,6 +0,0 @@
-using ErsatzTV.Core;
-
-namespace ErsatzTV.Application.Jellyfin;
-
-public record SynchronizeJellyfinCollections(int JellyfinMediaSourceId) : IRequest<Either<BaseError, Unit>>,
-    IJellyfinBackgroundServiceRequest;

ErsatzTV.Application/Libraries/Commands/CallLibraryScannerHandler.cs

@@ -0,0 +1,142 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Threading.Channels;
+using CliWrap;
+using ErsatzTV.Application.Search;
+using ErsatzTV.Core;
+using ErsatzTV.Core.MediaSources;
+using ErsatzTV.Core.Metadata;
+using ErsatzTV.FFmpeg.Runtime;
+using Newtonsoft.Json;
+using Serilog;
+using Serilog.Formatting.Compact.Reader;
+
+namespace ErsatzTV.Application.Libraries;
+
+public abstract class CallLibraryScannerHandler
+{
+    private readonly ChannelWriter<ISearchIndexBackgroundServiceRequest> _channel;
+    private readonly IMediator _mediator;
+    private readonly IRuntimeInfo _runtimeInfo;
+    private string _libraryName;
+
+    protected CallLibraryScannerHandler(
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+    {
+        _channel = channel;
+        _mediator = mediator;
+        _runtimeInfo = runtimeInfo;
+    }
+
+    protected async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        List<string> arguments,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            using var forcefulCts = new CancellationTokenSource();
+
+            await using CancellationTokenRegistration link = cancellationToken.Register(
+                () => forcefulCts.CancelAfter(TimeSpan.FromSeconds(10))
+            );
+
+            CommandResult process = await Cli.Wrap(scanner)
+                .WithArguments(arguments)
+                .WithValidation(CommandResultValidation.None)
+                .WithStandardErrorPipe(PipeTarget.ToDelegate(ProcessLogOutput))
+                .WithStandardOutputPipe(PipeTarget.ToDelegate(ProcessProgressOutput))
+                .ExecuteAsync(forcefulCts.Token, cancellationToken);
+
+            if (process.ExitCode != 0)
+            {
+                return BaseError.New($"ErsatzTV.Scanner exited with code {process.ExitCode}");
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // do nothing
+        }
+
+        return _libraryName ?? string.Empty;
+    }
+
+    private static void ProcessLogOutput(string s)
+    {
+        if (!string.IsNullOrWhiteSpace(s))
+        {
+            try
+            {
+                Log.Write(LogEventReader.ReadFromString(s));
+            }
+            catch
+            {
+                Console.WriteLine(s);
+            }
+        }
+    }
+
+    private async Task ProcessProgressOutput(string s)
+    {
+        if (!string.IsNullOrWhiteSpace(s))
+        {
+            try
+            {
+                ScannerProgressUpdate progressUpdate = JsonConvert.DeserializeObject<ScannerProgressUpdate>(s);
+                if (progressUpdate != null)
+                {
+                    if (!string.IsNullOrWhiteSpace(progressUpdate.LibraryName))
+                    {
+                        _libraryName = progressUpdate.LibraryName;
+                    }
+
+                    if (progressUpdate.PercentComplete is not null)
+                    {
+                        var progress = new LibraryScanProgress(
+                            progressUpdate.LibraryId,
+                            progressUpdate.PercentComplete.Value);
+
+                        await _mediator.Publish(progress);
+                    }
+
+                    if (progressUpdate.ItemsToReindex.Length > 0)
+                    {
+                        var reindex = new ReindexMediaItems(progressUpdate.ItemsToReindex);
+                        await _channel.WriteAsync(reindex);
+                    }
+
+                    if (progressUpdate.ItemsToRemove.Length > 0)
+                    {
+                        var remove = new RemoveMediaItems(progressUpdate.ItemsToRemove);
+                        await _channel.WriteAsync(remove);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Logger.Warning(ex, "Unable to process scanner progress update");
+            }
+        }
+    }
+
+    protected Validation<BaseError, string> Validate()
+    {
+        string executable = _runtimeInfo.IsOSPlatform(OSPlatform.Windows)
+            ? "ErsatzTV.Scanner.exe"
+            : "ErsatzTV.Scanner";
+        
+        string processFileName = Process.GetCurrentProcess().MainModule?.FileName ?? string.Empty;
+        if (!string.IsNullOrWhiteSpace(processFileName))
+        {
+            string localFileName = Path.Combine(Path.GetDirectoryName(processFileName) ?? string.Empty, executable);
+            if (File.Exists(localFileName))
+            {
+                return localFileName;
+            }
+        }
+
+        return BaseError.New("Unable to locate ErsatzTV.Scanner executable");
+    }
+}

ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs

@@ -1,7 +1,8 @@
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
@@ -13,18 +14,21 @@ namespace ErsatzTV.Application.Libraries;
 public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath, Either<BaseError, Unit>>
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
     private readonly ILogger<MoveLocalLibraryPathHandler> _logger;
     private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;
 
     public MoveLocalLibraryPathHandler(
         ISearchIndex searchIndex,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
+        IFallbackMetadataProvider fallbackMetadataProvider,
         IDbContextFactory<TvContext> dbContextFactory,
         ILogger<MoveLocalLibraryPathHandler> logger)
     {
         _searchIndex = searchIndex;
         _searchRepository = searchRepository;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
         _dbContextFactory = dbContextFactory;
         _logger = logger;
     }
@@ -35,7 +39,7 @@ public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath,
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, parameters => MovePath(dbContext, parameters));
+        return await validation.Apply(parameters => MovePath(dbContext, parameters));
     }
 
     private async Task<Unit> MovePath(TvContext dbContext, Parameters parameters)
@@ -57,7 +61,10 @@ public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath,
                 foreach (MediaItem mediaItem in maybeMediaItem)
                 {
                     _logger.LogInformation("Moving item at {Path}", await GetPath(dbContext, mediaItem));
-                    await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { mediaItem });
+                    await _searchIndex.UpdateItems(
+                        _searchRepository,
+                        _fallbackMetadataProvider,
+                        new List<MediaItem> { mediaItem });
                 }
             }
         }

ErsatzTV.Application/Logs/LogEntryViewModel.cs

@@ -1,10 +0,0 @@
-using Serilog.Events;
-
-namespace ErsatzTV.Application.Logs;
-
-public record LogEntryViewModel(
-    int Id,
-    DateTime Timestamp,
-    LogEventLevel Level,
-    string Exception,
-    string Message);

ErsatzTV.Application/Logs/Mapper.cs

@@ -1,42 +0,0 @@
-using ErsatzTV.Core.Domain;
-using Newtonsoft.Json.Linq;
-using Serilog.Events;
-
-namespace ErsatzTV.Application.Logs;
-
-internal static class Mapper
-{
-    internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry)
-    {
-        string message = logEntry.RenderedMessage;
-        if (!string.IsNullOrWhiteSpace(logEntry.Properties))
-        {
-            foreach (KeyValuePair<string, JToken> property in JObject.Parse(logEntry.Properties))
-            {
-                var token = $"{{{property.Key}}}";
-                if (message.Contains(token))
-                {
-                    message = message.Replace(token, property.Value.ToString());
-                }
-
-                var destructureToken = $"{{@{property.Key}}}";
-                if (message.Contains(destructureToken))
-                {
-                    message = message.Replace(destructureToken, property.Value.ToString());
-                }
-            }
-        }
-
-        if (!Enum.TryParse(logEntry.Level, out LogEventLevel level))
-        {
-            level = LogEventLevel.Debug;
-        }
-
-        return new LogEntryViewModel(
-            logEntry.Id,
-            logEntry.Timestamp,
-            level,
-            logEntry.Exception,
-            message);
-    }
-}

ErsatzTV.Application/Logs/PagedLogEntriesViewModel.cs

@@ -1,3 +0,0 @@
-namespace ErsatzTV.Application.Logs;
-
-public record PagedLogEntriesViewModel(int TotalCount, List<LogEntryViewModel> Page);

ErsatzTV.Application/Logs/Queries/GetRecentLogEntries.cs

@@ -1,10 +0,0 @@
-using System.Linq.Expressions;
-using ErsatzTV.Core.Domain;
-
-namespace ErsatzTV.Application.Logs;
-
-public record GetRecentLogEntries(int PageNum, int PageSize) : IRequest<PagedLogEntriesViewModel>
-{
-    public Expression<Func<LogEntry, object>> SortExpression { get; set; }
-    public Option<bool> SortDescending { get; set; }
-}

ErsatzTV.Application/Logs/Queries/GetRecentLogEntriesHandler.cs

@@ -1,40 +0,0 @@
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
-using static ErsatzTV.Application.Logs.Mapper;
-
-namespace ErsatzTV.Application.Logs;
-
-public class GetRecentLogEntriesHandler : IRequestHandler<GetRecentLogEntries, PagedLogEntriesViewModel>
-{
-    private readonly IDbContextFactory<LogContext> _dbContextFactory;
-
-    public GetRecentLogEntriesHandler(IDbContextFactory<LogContext> dbContextFactory) =>
-        _dbContextFactory = dbContextFactory;
-
-    public async Task<PagedLogEntriesViewModel> Handle(
-        GetRecentLogEntries request,
-        CancellationToken cancellationToken)
-    {
-        await using LogContext logContext = _dbContextFactory.CreateDbContext();
-        int count = await logContext.LogEntries.CountAsync(cancellationToken);
-
-        IOrderedQueryable<LogEntry> ordered = logContext.LogEntries
-            .OrderByDescending(le => le.Id);
-
-        foreach (bool descending in request.SortDescending)
-        {
-            ordered = descending
-                ? logContext.LogEntries.OrderByDescending(request.SortExpression).ThenByDescending(le => le.Id)
-                : logContext.LogEntries.OrderBy(request.SortExpression).ThenByDescending(le => le.Id);
-        }
-
-        List<LogEntryViewModel> page = await ordered
-            .Skip(request.PageNum * request.PageSize)
-            .Take(request.PageSize)
-            .ToListAsync(cancellationToken)
-            .Map(list => list.Map(ProjectToViewModel).ToList());
-
-        return new PagedLogEntriesViewModel(count, page);
-    }
-}

ErsatzTV.Application/Maintenance/Commands/EmptyTrashHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core;
+using Bugsnag;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -8,13 +9,16 @@ namespace ErsatzTV.Application.Maintenance;
 
 public class EmptyTrashHandler : IRequestHandler<EmptyTrash, Either<BaseError, Unit>>
 {
+    private readonly IClient _client;
     private readonly IMediaItemRepository _mediaItemRepository;
     private readonly ISearchIndex _searchIndex;
 
     public EmptyTrashHandler(
+        IClient client,
         IMediaItemRepository mediaItemRepository,
         ISearchIndex searchIndex)
     {
+        _client = client;
         _mediaItemRepository = mediaItemRepository;
         _searchIndex = searchIndex;
     }
@@ -39,7 +43,7 @@ public class EmptyTrashHandler : IRequestHandler<EmptyTrash, Either<BaseError, U
 
         foreach (string type in types)
         {
-            SearchResult result = await _searchIndex.Search($"type:{type} AND (state:FileNotFound)", 0, 0);
+            SearchResult result = _searchIndex.Search(_client, $"type:{type} AND (state:FileNotFound)", 0, 0);
             ids.AddRange(result.Items.Map(i => i.Id));
         }
 

ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs

@@ -1,7 +1,8 @@
 using System.Text.RegularExpressions;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Locking;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
@@ -17,12 +18,13 @@ public class AddTraktListHandler : TraktCommandBase, IRequestHandler<AddTraktLis
 
     public AddTraktListHandler(
         ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
         ISearchIndex searchIndex,
+        IFallbackMetadataProvider fallbackMetadataProvider,
         IDbContextFactory<TvContext> dbContextFactory,
         ILogger<AddTraktListHandler> logger,
         IEntityLocker entityLocker)
-        : base(traktApiClient, searchRepository, searchIndex, logger)
+        : base(traktApiClient, searchRepository, searchIndex, fallbackMetadataProvider, logger)
     {
         _dbContextFactory = dbContextFactory;
         _entityLocker = entityLocker;

ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs

@@ -1,7 +1,8 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
@@ -14,20 +15,23 @@ public class DeleteTraktListHandler : TraktCommandBase, IRequestHandler<DeleteTr
 {
     private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly IEntityLocker _entityLocker;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
     private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;
 
     public DeleteTraktListHandler(
         ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
         ISearchIndex searchIndex,
+        IFallbackMetadataProvider fallbackMetadataProvider,
         IDbContextFactory<TvContext> dbContextFactory,
         ILogger<DeleteTraktListHandler> logger,
         IEntityLocker entityLocker)
-        : base(traktApiClient, searchRepository, searchIndex, logger)
+        : base(traktApiClient, searchRepository, searchIndex, fallbackMetadataProvider, logger)
     {
         _searchRepository = searchRepository;
         _searchIndex = searchIndex;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
         _dbContextFactory = dbContextFactory;
         _entityLocker = entityLocker;
     }
@@ -38,8 +42,7 @@ public class DeleteTraktListHandler : TraktCommandBase, IRequestHandler<DeleteTr
     {
         try
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
             Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
             return await LanguageExtensions.Apply(validation, c => DoDeletion(dbContext, c));
         }
@@ -56,7 +59,7 @@ public class DeleteTraktListHandler : TraktCommandBase, IRequestHandler<DeleteTr
         dbContext.TraktLists.Remove(traktList);
         if (await dbContext.SaveChangesAsync() > 0)
         {
-            await _searchIndex.RebuildItems(_searchRepository, mediaItemIds);
+            await _searchIndex.RebuildItems(_searchRepository, _fallbackMetadataProvider, mediaItemIds);
         }
 
         _searchIndex.Commit();

ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs

@@ -1,7 +1,8 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
@@ -18,11 +19,17 @@ public class MatchTraktListItemsHandler : TraktCommandBase,
 
     public MatchTraktListItemsHandler(
         ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
         ISearchIndex searchIndex,
+        IFallbackMetadataProvider fallbackMetadataProvider,
         IDbContextFactory<TvContext> dbContextFactory,
         ILogger<MatchTraktListItemsHandler> logger,
-        IEntityLocker entityLocker) : base(traktApiClient, searchRepository, searchIndex, logger)
+        IEntityLocker entityLocker) : base(
+        traktApiClient,
+        searchRepository,
+        searchIndex,
+        fallbackMetadataProvider,
+        logger)
     {
         _dbContextFactory = dbContextFactory;
         _entityLocker = entityLocker;

ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs

@@ -1,6 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Core.Trakt;
@@ -13,18 +14,21 @@ namespace ErsatzTV.Application.MediaCollections;
 
 public abstract class TraktCommandBase
 {
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
     private readonly ILogger _logger;
     private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;
 
     protected TraktCommandBase(
         ITraktApiClient traktApiClient,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
         ISearchIndex searchIndex,
+        IFallbackMetadataProvider fallbackMetadataProvider,
         ILogger logger)
     {
         _searchRepository = searchRepository;
         _searchIndex = searchIndex;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
         _logger = logger;
         TraktApiClient = traktApiClient;
     }
@@ -158,7 +162,7 @@ public abstract class TraktCommandBase
 
             if (await dbContext.SaveChangesAsync() > 0)
             {
-                await _searchIndex.RebuildItems(_searchRepository, ids.ToList());
+                await _searchIndex.RebuildItems(_searchRepository, _fallbackMetadataProvider, ids.ToList());
             }
 
             _searchIndex.Commit();

ErsatzTV.Application/MediaSources/Commands/CallLocalLibraryScannerHandler.cs

@@ -0,0 +1,53 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.FFmpeg.Runtime;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public class CallLocalLibraryScannerHandler : CallLibraryScannerHandler,
+    IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
+    IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
+{
+    public CallLocalLibraryScannerHandler(
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>.Handle(
+        ForceScanLocalLibrary request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>.Handle(
+        ScanLocalLibraryIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(IScanLocalLibrary request, CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = Validate();
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error => Task.FromResult<Either<BaseError, string>>(error.Join()));
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        IScanLocalLibrary request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-local", request.LibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+}

ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs

@@ -1,232 +0,0 @@
-using System.Diagnostics;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Locking;
-using ErsatzTV.Core.Interfaces.Metadata;
-using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Metadata;
-using Humanizer;
-using Microsoft.Extensions.Logging;
-
-namespace ErsatzTV.Application.MediaSources;
-
-public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
-    IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
-{
-    private readonly IConfigElementRepository _configElementRepository;
-    private readonly IEntityLocker _entityLocker;
-    private readonly ILibraryRepository _libraryRepository;
-    private readonly ILogger<ScanLocalLibraryHandler> _logger;
-    private readonly IMediator _mediator;
-    private readonly IMovieFolderScanner _movieFolderScanner;
-    private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
-    private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
-    private readonly ISongFolderScanner _songFolderScanner;
-    private readonly ITelevisionFolderScanner _televisionFolderScanner;
-
-    public ScanLocalLibraryHandler(
-        ILibraryRepository libraryRepository,
-        IConfigElementRepository configElementRepository,
-        IMovieFolderScanner movieFolderScanner,
-        ITelevisionFolderScanner televisionFolderScanner,
-        IMusicVideoFolderScanner musicVideoFolderScanner,
-        IOtherVideoFolderScanner otherVideoFolderScanner,
-        ISongFolderScanner songFolderScanner,
-        IEntityLocker entityLocker,
-        IMediator mediator,
-        ILogger<ScanLocalLibraryHandler> logger)
-    {
-        _libraryRepository = libraryRepository;
-        _configElementRepository = configElementRepository;
-        _movieFolderScanner = movieFolderScanner;
-        _televisionFolderScanner = televisionFolderScanner;
-        _musicVideoFolderScanner = musicVideoFolderScanner;
-        _otherVideoFolderScanner = otherVideoFolderScanner;
-        _songFolderScanner = songFolderScanner;
-        _entityLocker = entityLocker;
-        _mediator = mediator;
-        _logger = logger;
-    }
-
-    Task<Either<BaseError, string>> IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>.Handle(
-        ForceScanLocalLibrary request,
-        CancellationToken cancellationToken) => Handle(request, cancellationToken);
-
-    Task<Either<BaseError, string>> IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>.Handle(
-        ScanLocalLibraryIfNeeded request,
-        CancellationToken cancellationToken) => Handle(request, cancellationToken);
-
-    private Task<Either<BaseError, string>> Handle(IScanLocalLibrary request, CancellationToken cancellationToken) =>
-        Validate(request)
-            .MapT(parameters => PerformScan(parameters, cancellationToken).Map(_ => parameters.LocalLibrary.Name))
-            .Bind(v => v.ToEitherAsync());
-
-    private async Task<Unit> PerformScan(RequestParameters parameters, CancellationToken cancellationToken)
-    {
-        (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
-            int libraryRefreshInterval) = parameters;
-
-        try
-        {
-            var sw = new Stopwatch();
-            sw.Start();
-
-            var scanned = false;
-
-            for (var i = 0; i < localLibrary.Paths.Count; i++)
-            {
-                LibraryPath libraryPath = localLibrary.Paths[i];
-
-                decimal progressMin = (decimal)i / localLibrary.Paths.Count;
-                decimal progressMax = (decimal)(i + 1) / localLibrary.Paths.Count;
-
-                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-                DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
-                if (forceScan || nextScan < DateTimeOffset.Now)
-                {
-                    scanned = true;
-
-                    Either<BaseError, Unit> result = localLibrary.MediaKind switch
-                    {
-                        LibraryMediaKind.Movies =>
-                            await _movieFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.Shows =>
-                            await _televisionFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.MusicVideos =>
-                            await _musicVideoFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.OtherVideos =>
-                            await _otherVideoFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffmpegPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        LibraryMediaKind.Songs =>
-                            await _songFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                ffmpegPath,
-                                progressMin,
-                                progressMax,
-                                cancellationToken),
-                        _ => Unit.Default
-                    };
-
-                    if (result.IsRight)
-                    {
-                        libraryPath.LastScan = DateTime.UtcNow;
-                        await _libraryRepository.UpdateLastScan(libraryPath);
-                    }
-                }
-
-                await _mediator.Publish(new LibraryScanProgress(libraryPath.LibraryId, progressMax), cancellationToken);
-            }
-
-            sw.Stop();
-
-            if (scanned)
-            {
-                _logger.LogDebug(
-                    "Scan of library {Name} completed in {Duration}",
-                    localLibrary.Name,
-                    sw.Elapsed.Humanize());
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of local media library {Name}",
-                    localLibrary.Name);
-            }
-
-            await _mediator.Publish(new LibraryScanProgress(localLibrary.Id, 0), cancellationToken);
-
-            return Unit.Default;
-        }
-        finally
-        {
-            _entityLocker.UnlockLibrary(localLibrary.Id);
-        }
-    }
-
-    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) =>
-        _libraryRepository.Get(request.LibraryId)
-            .Map(maybeLibrary => maybeLibrary.Map(ms => ms as LocalLibrary))
-            .Map(v => v.ToValidation<BaseError>($"Local library {request.LibraryId} does not exist."));
-
-    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 Task<Validation<BaseError, string>> ValidateFFmpegPath() =>
-        _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
-            .FilterT(File.Exists)
-            .Map(
-                ffmpegPath =>
-                    ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
-
-    private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
-        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-            .FilterT(lri => lri > 0)
-            .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-
-    private record RequestParameters(
-        LocalLibrary LocalLibrary,
-        string FFprobePath,
-        string FFmpegPath,
-        bool ForceScan,
-        int LibraryRefreshInterval);
-}

ErsatzTV.Application/MediaSources/LocalMediaSourceViewModel.cs

@@ -1,3 +0,0 @@
-namespace ErsatzTV.Application.MediaSources;
-
-public record LocalMediaSourceViewModel(int Id) : MediaSourceViewModel(Id, "Local");

ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs

@@ -5,6 +5,7 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Scheduling;
+using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using Microsoft.EntityFrameworkCore;
@@ -37,7 +38,7 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
         Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-        return await LanguageExtensions.Apply(validation, playout => ApplyUpdateRequest(dbContext, request, playout));
+        return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
     }
 
     private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, BuildPlayout request, Playout playout)
@@ -45,7 +46,12 @@ public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseErro
         try
         {
             await _playoutBuilder.Build(playout, request.Mode);
-            if (await dbContext.SaveChangesAsync() > 0)
+
+            // let any active segmenter processes know that the playout has been modified
+            // and therefore the segmenter may need to seek into the next item instead of
+            // starting at the beginning (if already working ahead)
+            bool hasChanges = await dbContext.SaveChangesAsync() > 0;
+            if (request.Mode != PlayoutBuildMode.Continue && hasChanges)
             {
                 _ffmpegSegmenterService.PlayoutUpdated(playout.Channel.Number);
             }

ErsatzTV.Application/Plex/Commands/CallPlexLibraryScannerHandler.cs

@@ -0,0 +1,60 @@
+using System.Threading.Channels;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core;
+using ErsatzTV.FFmpeg.Runtime;
+
+namespace ErsatzTV.Application.Plex;
+
+public class CallPlexLibraryScannerHandler : CallLibraryScannerHandler,
+    IRequestHandler<ForceSynchronizePlexLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>
+{
+    public CallPlexLibraryScannerHandler(
+        ChannelWriter<ISearchIndexBackgroundServiceRequest> channel,
+        IMediator mediator,
+        IRuntimeInfo runtimeInfo)
+        : base(channel, mediator, runtimeInfo)
+    {
+    }
+
+    Task<Either<BaseError, string>> IRequestHandler<ForceSynchronizePlexLibraryById, Either<BaseError, string>>.Handle(
+        ForceSynchronizePlexLibraryById request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    Task<Either<BaseError, string>> IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>.Handle(
+        SynchronizePlexLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request, cancellationToken);
+
+    private async Task<Either<BaseError, string>> Handle(
+        ISynchronizePlexLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        Validation<BaseError, string> validation = Validate();
+        return await validation.Match(
+            scanner => PerformScan(scanner, request, cancellationToken),
+            error => Task.FromResult<Either<BaseError, string>>(error.Join()));
+    }
+
+    private async Task<Either<BaseError, string>> PerformScan(
+        string scanner,
+        ISynchronizePlexLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        var arguments = new List<string>
+        {
+            "scan-plex", request.PlexLibraryId.ToString()
+        };
+
+        if (request.ForceScan)
+        {
+            arguments.Add("--force");
+        }
+
+        if (request.DeepScan)
+        {
+            arguments.Add("--deep");
+        }
+
+        return await base.PerformScan(scanner, arguments, cancellationToken);
+    }
+}

ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs

@@ -26,6 +26,7 @@ public record AddProgramScheduleItem(
     int? FallbackFillerId,
     int? WatermarkId,
     string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode? SubtitleMode) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>,
     IProgramScheduleItemRequest;

ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs

@@ -24,6 +24,7 @@ public interface IProgramScheduleItemRequest
     int? FallbackFillerId { get; }
     int? WatermarkId { get; }
     string PreferredAudioLanguageCode { get; }
+    string PreferredAudioTitle { get; }
     string PreferredSubtitleLanguageCode { get; }
     ChannelSubtitleMode? SubtitleMode { get; }
 }

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -55,6 +55,7 @@ public abstract class ProgramScheduleItemCommandBase
             {
                 case PlaybackOrder.Chronological:
                 case PlaybackOrder.Random:
+                case PlaybackOrder.MultiEpisodeShuffle:
                     return BaseError.New($"Invalid playback order for multi collection: '{item.PlaybackOrder}'");
                 case PlaybackOrder.Shuffle:
                 case PlaybackOrder.ShuffleInOrder:
@@ -180,6 +181,7 @@ public abstract class ProgramScheduleItemCommandBase
                 FallbackFillerId = item.FallbackFillerId,
                 WatermarkId = item.WatermarkId,
                 PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                 PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                 SubtitleMode = item.SubtitleMode
             },
@@ -203,6 +205,7 @@ public abstract class ProgramScheduleItemCommandBase
                 FallbackFillerId = item.FallbackFillerId,
                 WatermarkId = item.WatermarkId,
                 PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                 PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                 SubtitleMode = item.SubtitleMode
             },
@@ -227,6 +230,7 @@ public abstract class ProgramScheduleItemCommandBase
                 FallbackFillerId = item.FallbackFillerId,
                 WatermarkId = item.WatermarkId,
                 PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                 PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                 SubtitleMode = item.SubtitleMode
             },
@@ -252,6 +256,7 @@ public abstract class ProgramScheduleItemCommandBase
                 FallbackFillerId = item.FallbackFillerId,
                 WatermarkId = item.WatermarkId,
                 PreferredAudioLanguageCode = item.PreferredAudioLanguageCode,
+                PreferredAudioTitle = item.PreferredAudioTitle,
                 PreferredSubtitleLanguageCode = item.PreferredSubtitleLanguageCode,
                 SubtitleMode = item.SubtitleMode
             },

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs

@@ -26,6 +26,7 @@ public record ReplaceProgramScheduleItem(
     int? FallbackFillerId,
     int? WatermarkId,
     string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode? SubtitleMode) : IProgramScheduleItemRequest;
 

ErsatzTV.Application/ProgramSchedules/Mapper.cs

@@ -63,6 +63,7 @@ internal static class Mapper
                         ? Watermarks.Mapper.ProjectToViewModel(duration.Watermark)
                         : null,
                     duration.PreferredAudioLanguageCode,
+                    duration.PreferredAudioTitle,
                     duration.PreferredSubtitleLanguageCode,
                     duration.SubtitleMode),
             ProgramScheduleItemFlood flood =>
@@ -110,6 +111,7 @@ internal static class Mapper
                         ? Watermarks.Mapper.ProjectToViewModel(flood.Watermark)
                         : null,
                     flood.PreferredAudioLanguageCode,
+                    flood.PreferredAudioTitle,
                     flood.PreferredSubtitleLanguageCode,
                     flood.SubtitleMode),
             ProgramScheduleItemMultiple multiple =>
@@ -158,6 +160,7 @@ internal static class Mapper
                         ? Watermarks.Mapper.ProjectToViewModel(multiple.Watermark)
                         : null,
                     multiple.PreferredAudioLanguageCode,
+                    multiple.PreferredAudioTitle,
                     multiple.PreferredSubtitleLanguageCode,
                     multiple.SubtitleMode),
             ProgramScheduleItemOne one =>
@@ -205,6 +208,7 @@ internal static class Mapper
                         ? Watermarks.Mapper.ProjectToViewModel(one.Watermark)
                         : null,
                     one.PreferredAudioLanguageCode,
+                    one.PreferredAudioTitle,
                     one.PreferredSubtitleLanguageCode,
                     one.SubtitleMode),
             _ => throw new NotSupportedException(

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs

@@ -30,6 +30,7 @@ public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewMode
         FillerPresetViewModel fallbackFiller,
         WatermarkViewModel watermark,
         string preferredAudioLanguageCode,
+        string preferredAudioTitle,
         string preferredSubtitleLanguageCode,
         ChannelSubtitleMode? subtitleMode) : base(
         id,
@@ -52,6 +53,7 @@ public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewMode
         fallbackFiller,
         watermark,
         preferredAudioLanguageCode,
+        preferredAudioTitle,
         preferredSubtitleLanguageCode,
         subtitleMode)
     {

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs

@@ -28,6 +28,7 @@ public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
         FillerPresetViewModel fallbackFiller,
         WatermarkViewModel watermark,
         string preferredAudioLanguageCode,
+        string preferredAudioTitle,
         string preferredSubtitleLanguageCode,
         ChannelSubtitleMode? subtitleMode) : base(
         id,
@@ -50,6 +51,7 @@ public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
         fallbackFiller,
         watermark,
         preferredAudioLanguageCode,
+        preferredAudioTitle,
         preferredSubtitleLanguageCode,
         subtitleMode)
     {

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs

@@ -29,6 +29,7 @@ public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewMode
         FillerPresetViewModel fallbackFiller,
         WatermarkViewModel watermark,
         string preferredAudioLanguageCode,
+        string preferredAudioTitle,
         string preferredSubtitleLanguageCode,
         ChannelSubtitleMode? subtitleMode) : base(
         id,
@@ -51,6 +52,7 @@ public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewMode
         fallbackFiller,
         watermark,
         preferredAudioLanguageCode,
+        preferredAudioTitle,
         preferredSubtitleLanguageCode,
         subtitleMode) =>
         Count = count;

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs

@@ -28,6 +28,7 @@ public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
         FillerPresetViewModel fallbackFiller,
         WatermarkViewModel watermark,
         string preferredAudioLanguageCode,
+        string preferredAudioTitle,
         string preferredSubtitleLanguageCode,
         ChannelSubtitleMode? subtitleMode) : base(
         id,
@@ -50,6 +51,7 @@ public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
         fallbackFiller,
         watermark,
         preferredAudioLanguageCode,
+        preferredAudioTitle,
         preferredSubtitleLanguageCode,
         subtitleMode)
     {

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -27,6 +27,7 @@ public abstract record ProgramScheduleItemViewModel(
     FillerPresetViewModel FallbackFiller,
     WatermarkViewModel Watermark,
     string PreferredAudioLanguageCode,
+    string PreferredAudioTitle,
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode? SubtitleMode)
 {

ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs

@@ -3,6 +3,7 @@ using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
 using ErsatzTV.Core.Interfaces.Search;
 using Humanizer;
 using Microsoft.Extensions.Logging;
@@ -12,16 +13,18 @@ namespace ErsatzTV.Application.Search;
 public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex, Unit>
 {
     private readonly IConfigElementRepository _configElementRepository;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<RebuildSearchIndexHandler> _logger;
     private readonly ISearchIndex _searchIndex;
-    private readonly ISearchRepository _searchRepository;
+    private readonly ICachingSearchRepository _searchRepository;
 
     public RebuildSearchIndexHandler(
         ISearchIndex searchIndex,
-        ISearchRepository searchRepository,
+        ICachingSearchRepository searchRepository,
         IConfigElementRepository configElementRepository,
         ILocalFileSystem localFileSystem,
+        IFallbackMetadataProvider fallbackMetadataProvider,
         ILogger<RebuildSearchIndexHandler> logger)
     {
         _searchIndex = searchIndex;
@@ -29,14 +32,19 @@ public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex, Uni
         _searchRepository = searchRepository;
         _configElementRepository = configElementRepository;
         _localFileSystem = localFileSystem;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
     }
 
     public async Task<Unit> Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
     {
+        _logger.LogInformation("Initializing search index");
+
         bool indexFolderExists = Directory.Exists(FileSystemLayout.SearchIndexFolder);
 
         await _searchIndex.Initialize(_localFileSystem, _configElementRepository);
 
+        _logger.LogInformation("Done initializing search index");
+
         if (!indexFolderExists ||
             await _configElementRepository.GetValue<int>(ConfigElementKey.SearchIndexVersion) <
             _searchIndex.Version)
@@ -44,7 +52,7 @@ public class RebuildSearchIndexHandler : IRequestHandler<RebuildSearchIndex, Uni
             _logger.LogInformation("Migrating search index to version {Version}", _searchIndex.Version);
 
             var sw = Stopwatch.StartNew();
-            await _searchIndex.Rebuild(_searchRepository);
+            await _searchIndex.Rebuild(_searchRepository, _fallbackMetadataProvider);
 
             await _configElementRepository.Upsert(ConfigElementKey.SearchIndexVersion, _searchIndex.Version);
             sw.Stop();

ErsatzTV.Application/Search/Commands/ReindexMediaItems.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Search;
+
+public record ReindexMediaItems(IReadOnlyCollection<int> MediaItemIds) : IRequest<Unit>,
+    ISearchIndexBackgroundServiceRequest;

ErsatzTV.Application/Search/Commands/ReindexMediaItemsHandler.cs

@@ -0,0 +1,29 @@
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories.Caching;
+using ErsatzTV.Core.Interfaces.Search;
+
+namespace ErsatzTV.Application.Search;
+
+public class ReindexMediaItemsHandler : IRequestHandler<ReindexMediaItems, Unit>
+{
+    private readonly ICachingSearchRepository _cachingSearchRepository;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
+    private readonly ISearchIndex _searchIndex;
+
+    public ReindexMediaItemsHandler(
+        ICachingSearchRepository cachingSearchRepository,
+        IFallbackMetadataProvider fallbackMetadataProvider,
+        ISearchIndex searchIndex)
+    {
+        _cachingSearchRepository = cachingSearchRepository;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _searchIndex = searchIndex;
+    }
+
+    public async Task<Unit> Handle(ReindexMediaItems request, CancellationToken cancellationToken)
+    {
+        await _searchIndex.RebuildItems(_cachingSearchRepository, _fallbackMetadataProvider, request.MediaItemIds);
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Search/Commands/RemoveMediaItems.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.Search;
+
+public record RemoveMediaItems(IReadOnlyCollection<int> MediaItemIds) : IRequest<Unit>,
+    ISearchIndexBackgroundServiceRequest;

ErsatzTV.Application/Search/Commands/RemoveMediaItemsHandler.cs

@@ -0,0 +1,17 @@
+using ErsatzTV.Core.Interfaces.Search;
+
+namespace ErsatzTV.Application.Search;
+
+public class RemoveMediaItemsHandler : IRequestHandler<RemoveMediaItems, Unit>
+{
+    private readonly ISearchIndex _searchIndex;
+
+    public RemoveMediaItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+
+    public async Task<Unit> Handle(RemoveMediaItems request, CancellationToken cancellationToken)
+    {
+        await _searchIndex.RemoveItems(request.MediaItemIds);
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+}

ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs

@@ -1,29 +1,33 @@
-using ErsatzTV.Core.Interfaces.Search;
+using Bugsnag;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Search;
 
 namespace ErsatzTV.Application.Search;
 
-public class
-    QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
+public class QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
 {
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
 
-    public QuerySearchIndexAllItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+    public QuerySearchIndexAllItemsHandler(IClient client, ISearchIndex searchIndex)
+    {
+        _client = client;
+        _searchIndex = searchIndex;
+    }
 
-    public async Task<SearchResultAllItemsViewModel> Handle(
+    public Task<SearchResultAllItemsViewModel> Handle(
         QuerySearchIndexAllItems request,
         CancellationToken cancellationToken) =>
-        new(
-            await GetIds(SearchIndex.MovieType, request.Query),
-            await GetIds(SearchIndex.ShowType, request.Query),
-            await GetIds(SearchIndex.SeasonType, request.Query),
-            await GetIds(SearchIndex.EpisodeType, request.Query),
-            await GetIds(SearchIndex.ArtistType, request.Query),
-            await GetIds(SearchIndex.MusicVideoType, request.Query),
-            await GetIds(SearchIndex.OtherVideoType, request.Query),
-            await GetIds(SearchIndex.SongType, request.Query));
+        new SearchResultAllItemsViewModel(
+            GetIds(SearchIndex.MovieType, request.Query),
+            GetIds(SearchIndex.ShowType, request.Query),
+            GetIds(SearchIndex.SeasonType, request.Query),
+            GetIds(SearchIndex.EpisodeType, request.Query),
+            GetIds(SearchIndex.ArtistType, request.Query),
+            GetIds(SearchIndex.MusicVideoType, request.Query),
+            GetIds(SearchIndex.OtherVideoType, request.Query),
+            GetIds(SearchIndex.SongType, request.Query)).AsTask();
 
-    private Task<List<int>> GetIds(string type, string query) =>
-        _searchIndex.Search($"type:{type} AND ({query})", 0, 0)
-            .Map(result => result.Items.Map(i => i.Id).ToList());
+    private List<int> GetIds(string type, string query) =>
+        _searchIndex.Search(_client, $"type:{type} AND ({query})", 0, 0).Items.Map(i => i.Id).ToList();
 }

ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -6,15 +7,15 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 
 namespace ErsatzTV.Application.Search;
 
-public class
-    QuerySearchIndexArtistsHandler : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel
-    >
+public class QuerySearchIndexArtistsHandler : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel>
 {
     private readonly IArtistRepository _artistRepository;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
 
-    public QuerySearchIndexArtistsHandler(ISearchIndex searchIndex, IArtistRepository artistRepository)
+    public QuerySearchIndexArtistsHandler(IClient client, ISearchIndex searchIndex, IArtistRepository artistRepository)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _artistRepository = artistRepository;
     }
@@ -23,7 +24,8 @@ public class
         QuerySearchIndexArtists request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodesHandler.cs

@@ -1,12 +1,17 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
 namespace ErsatzTV.Application.Search;
@@ -14,34 +19,44 @@ namespace ErsatzTV.Application.Search;
 public class
     QuerySearchIndexEpisodesHandler : IRequestHandler<QuerySearchIndexEpisodes, TelevisionEpisodeCardResultsViewModel>
 {
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
     private readonly IEmbyPathReplacementService _embyPathReplacementService;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
     private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
     private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
     private readonly ITelevisionRepository _televisionRepository;
 
     public QuerySearchIndexEpisodesHandler(
+        IClient client,
         ISearchIndex searchIndex,
         ITelevisionRepository televisionRepository,
         IMediaSourceRepository mediaSourceRepository,
         IPlexPathReplacementService plexPathReplacementService,
         IJellyfinPathReplacementService jellyfinPathReplacementService,
-        IEmbyPathReplacementService embyPathReplacementService)
+        IEmbyPathReplacementService embyPathReplacementService,
+        IFallbackMetadataProvider fallbackMetadataProvider,
+        IDbContextFactory<TvContext> dbContextFactory)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _televisionRepository = televisionRepository;
         _mediaSourceRepository = mediaSourceRepository;
         _plexPathReplacementService = plexPathReplacementService;
         _jellyfinPathReplacementService = jellyfinPathReplacementService;
         _embyPathReplacementService = embyPathReplacementService;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _dbContextFactory = dbContextFactory;
     }
 
     public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
         QuerySearchIndexEpisodes request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);
@@ -52,8 +67,40 @@ public class
         Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
             .Map(list => list.HeadOrNone());
 
-        List<EpisodeMetadata> episodes = await _televisionRepository
-            .GetEpisodesForCards(searchResult.Items.Map(i => i.Id).ToList());
+        var episodeIds = searchResult.Items.Map(i => i.Id).ToList();
+
+        List<EpisodeMetadata> episodes = await _televisionRepository.GetEpisodesForCards(episodeIds);
+
+        // try to load fallback metadata for episodes that have none
+        // this handles an edge case of trashed items with no saved metadata
+        var missingEpisodes = episodeIds.Except(episodes.Map(e => e.EpisodeId)).ToList();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        foreach (int missingEpisodeId in missingEpisodes)
+        {
+            Option<Episode> maybeEpisode = await dbContext.Episodes
+                .AsNoTracking()
+                .Include(e => e.MediaVersions)
+                .ThenInclude(e => e.MediaFiles)
+                .Include(e => e.Season)
+                .ThenInclude(s => s.SeasonMetadata)
+                .ThenInclude(sm => sm.Artwork)
+                .Include(e => e.Season)
+                .ThenInclude(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
+                .ThenInclude(sm => sm.Artwork)
+                .SelectOneAsync(e => e.Id, e => e.Id == missingEpisodeId);
+
+            foreach (Episode episode in maybeEpisode)
+            {
+                foreach (EpisodeMetadata headMetadata in _fallbackMetadataProvider.GetFallbackMetadata(episode)
+                             .HeadOrNone())
+                {
+                    headMetadata.Episode = episode;
+                    episode.EpisodeMetadata = new List<EpisodeMetadata> { headMetadata };
+                    episodes.Add(headMetadata);
+                }
+            }
+        }
 
         var items = new List<TelevisionEpisodeCardViewModel>();
 

ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,13 +12,16 @@ public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMov
 {
     private readonly IMediaSourceRepository _mediaSourceRepository;
     private readonly IMovieRepository _movieRepository;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
 
     public QuerySearchIndexMoviesHandler(
+        IClient client,
         ISearchIndex searchIndex,
         IMovieRepository movieRepository,
         IMediaSourceRepository mediaSourceRepository)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _movieRepository = movieRepository;
         _mediaSourceRepository = mediaSourceRepository;
@@ -27,7 +31,8 @@ public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMov
         QuerySearchIndexMovies request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Emby;
@@ -18,15 +19,18 @@ public class
     private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
     private readonly IMusicVideoRepository _musicVideoRepository;
     private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
 
     public QuerySearchIndexMusicVideosHandler(
+        IClient client,
         ISearchIndex searchIndex,
         IMusicVideoRepository musicVideoRepository,
         IPlexPathReplacementService plexPathReplacementService,
         IJellyfinPathReplacementService jellyfinPathReplacementService,
         IEmbyPathReplacementService embyPathReplacementService)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _musicVideoRepository = musicVideoRepository;
         _plexPathReplacementService = plexPathReplacementService;
@@ -38,7 +42,8 @@ public class
         QuerySearchIndexMusicVideos request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -11,10 +12,15 @@ public class
         OtherVideoCardResultsViewModel>
 {
     private readonly IOtherVideoRepository _otherVideoRepository;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
 
-    public QuerySearchIndexOtherVideosHandler(ISearchIndex searchIndex, IOtherVideoRepository otherVideoRepository)
+    public QuerySearchIndexOtherVideosHandler(
+        IClient client,
+        ISearchIndex searchIndex,
+        IOtherVideoRepository otherVideoRepository)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _otherVideoRepository = otherVideoRepository;
     }
@@ -23,7 +29,8 @@ public class
         QuerySearchIndexOtherVideos request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,14 +12,17 @@ public class
     QuerySearchIndexSeasonsHandler : IRequestHandler<QuerySearchIndexSeasons, TelevisionSeasonCardResultsViewModel>
 {
     private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
     private readonly ITelevisionRepository _televisionRepository;
 
     public QuerySearchIndexSeasonsHandler(
+        IClient client,
         ISearchIndex searchIndex,
         ITelevisionRepository televisionRepository,
         IMediaSourceRepository mediaSourceRepository)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _televisionRepository = televisionRepository;
         _mediaSourceRepository = mediaSourceRepository;
@@ -28,7 +32,8 @@ public class
         QuerySearchIndexSeasons request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -11,14 +12,17 @@ public class
     QuerySearchIndexShowsHandler : IRequestHandler<QuerySearchIndexShows, TelevisionShowCardResultsViewModel>
 {
     private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
     private readonly ITelevisionRepository _televisionRepository;
 
     public QuerySearchIndexShowsHandler(
+        IClient client,
         ISearchIndex searchIndex,
         ITelevisionRepository televisionRepository,
         IMediaSourceRepository mediaSourceRepository)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _televisionRepository = televisionRepository;
         _mediaSourceRepository = mediaSourceRepository;
@@ -28,7 +32,8 @@ public class
         QuerySearchIndexShows request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Application.MediaCards;
+using Bugsnag;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
@@ -6,15 +7,15 @@ using static ErsatzTV.Application.MediaCards.Mapper;
 
 namespace ErsatzTV.Application.Search;
 
-public class
-    QuerySearchIndexSongsHandler : IRequestHandler<QuerySearchIndexSongs,
-        SongCardResultsViewModel>
+public class QuerySearchIndexSongsHandler : IRequestHandler<QuerySearchIndexSongs, SongCardResultsViewModel>
 {
+    private readonly IClient _client;
     private readonly ISearchIndex _searchIndex;
     private readonly ISongRepository _songRepository;
 
-    public QuerySearchIndexSongsHandler(ISearchIndex searchIndex, ISongRepository songRepository)
+    public QuerySearchIndexSongsHandler(IClient client, ISearchIndex searchIndex, ISongRepository songRepository)
     {
+        _client = client;
         _searchIndex = searchIndex;
         _songRepository = songRepository;
     }
@@ -23,7 +24,8 @@ public class
         QuerySearchIndexSongs request,
         CancellationToken cancellationToken)
     {
-        SearchResult searchResult = await _searchIndex.Search(
+        SearchResult searchResult = _searchIndex.Search(
+            _client,
             request.Query,
             (request.PageNumber - 1) * request.PageSize,
             request.PageSize);

ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs

@@ -1,4 +1,5 @@
-using ErsatzTV.Core;
+using System.Diagnostics;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.FFmpeg;
@@ -78,22 +79,47 @@ public class StartFFmpegSessionHandler : IRequestHandler<StartFFmpegSession, Eit
         IHlsSessionWorker worker,
         CancellationToken cancellationToken)
     {
-        while (!File.Exists(playlistFileName))
+        var sw = Stopwatch.StartNew();
+        try
         {
-            await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
-        }
+            DateTimeOffset start = DateTimeOffset.Now;
+            DateTimeOffset finish = start.AddSeconds(8);
 
-        var segmentCount = 0;
-        while (segmentCount < initialSegmentCount)
-        {
-            await Task.Delay(TimeSpan.FromMilliseconds(200), cancellationToken);
-
-            DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
-            Option<TrimPlaylistResult> maybeResult = await worker.TrimPlaylist(now, cancellationToken);
-            foreach (TrimPlaylistResult result in maybeResult)
+            _logger.LogDebug("Waiting for playlist to exist");
+            while (!File.Exists(playlistFileName))
             {
-                segmentCount = result.SegmentCount;
+                await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
             }
+
+            _logger.LogDebug("Playlist exists");
+
+            var segmentCount = 0;
+            var lastSegmentCount = -1;
+            while (DateTimeOffset.Now < finish && segmentCount < initialSegmentCount)
+            {
+                if (segmentCount != lastSegmentCount)
+                {
+                    lastSegmentCount = segmentCount;
+                    _logger.LogDebug(
+                        "Segment count {SegmentCount} of {InitialSegmentCount}",
+                        segmentCount,
+                        initialSegmentCount);
+                }
+
+                await Task.Delay(TimeSpan.FromMilliseconds(200), cancellationToken);
+
+                DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
+                Option<TrimPlaylistResult> maybeResult = await worker.TrimPlaylist(now, cancellationToken);
+                foreach (TrimPlaylistResult result in maybeResult)
+                {
+                    segmentCount = result.SegmentCount;
+                }
+            }
+        }
+        finally
+        {
+            sw.Stop();
+            _logger.LogDebug("WaitForPlaylistSegments took {Duration}", sw.Elapsed);
         }
     }
 

ErsatzTV.Application/Streaming/HlsSessionWorker.cs

@@ -1,4 +1,5 @@
-using System.Text;
+using System.Diagnostics;
+using System.Text;
 using System.Timers;
 using Bugsnag;
 using CliWrap;
@@ -27,7 +28,10 @@ public class HlsSessionWorker : IHlsSessionWorker
     private readonly object _sync = new();
     private string _channelNumber;
     private bool _firstProcess;
+    private bool _hasWrittenSegments;
     private DateTimeOffset _lastAccess;
+    private DateTimeOffset _lastDelete = DateTimeOffset.MinValue;
+    private bool _seekNextItem;
     private Option<int> _targetFramerate;
     private Timer _timer;
     private DateTimeOffset _transcodedUntil;
@@ -61,19 +65,38 @@ public class HlsSessionWorker : IHlsSessionWorker
         DateTimeOffset filterBefore,
         CancellationToken cancellationToken)
     {
+        var sw = Stopwatch.StartNew();
         await Slim.WaitAsync(cancellationToken);
         try
         {
             Option<string[]> maybeLines = await ReadPlaylistLines(cancellationToken);
-            return maybeLines.Map(input => _hlsPlaylistFilter.TrimPlaylist(PlaylistStart, filterBefore, input));
+            foreach (string[] input in maybeLines)
+            {
+                TrimPlaylistResult trimResult = _hlsPlaylistFilter.TrimPlaylist(PlaylistStart, filterBefore, input);
+                if (DateTimeOffset.Now > _lastDelete.AddSeconds(30))
+                {
+                    DeleteOldSegments(trimResult);
+                    _lastDelete = DateTimeOffset.Now;
+                }
+
+                return trimResult;
+            }
+
+            return None;
         }
         finally
         {
             Slim.Release();
+            sw.Stop();
+            // _logger.LogDebug("TrimPlaylist took {Duration}", sw.Elapsed);
         }
     }
 
-    public void PlayoutUpdated() => _firstProcess = true;
+    public void PlayoutUpdated()
+    {
+        _firstProcess = true;
+        _seekNextItem = true;
+    }
 
     public async Task Run(string channelNumber, TimeSpan idleTimeout, CancellationToken incomingCancellationToken)
     {
@@ -190,7 +213,7 @@ public class HlsSessionWorker : IHlsSessionWorker
 
             IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-            long ptsOffset = await GetPtsOffset(mediator, _channelNumber, _firstProcess, cancellationToken);
+            long ptsOffset = await GetPtsOffset(mediator, _channelNumber, cancellationToken);
             // _logger.LogInformation("PTS offset: {PtsOffset}", ptsOffset);
 
             var request = new GetPlayoutItemProcessByChannelNumber(
@@ -237,6 +260,13 @@ public class HlsSessionWorker : IHlsSessionWorker
                         _logger.LogInformation("HLS process has completed for channel {Channel}", _channelNumber);
                         _transcodedUntil = processModel.Until;
                         _firstProcess = false;
+                        if (_seekNextItem)
+                        {
+                            _firstProcess = true;
+                            _seekNextItem = false;
+                        }
+
+                        _hasWrittenSegments = true;
                         return true;
                     }
                     else
@@ -281,6 +311,14 @@ public class HlsSessionWorker : IHlsSessionWorker
                             if (commandResult.ExitCode == 0)
                             {
                                 _firstProcess = false;
+                                if (_seekNextItem)
+                                {
+                                    _firstProcess = true;
+                                    _seekNextItem = false;
+                                }
+
+                                _hasWrittenSegments = true;
+
                                 return true;
                             }
                         }
@@ -313,7 +351,10 @@ public class HlsSessionWorker : IHlsSessionWorker
         }
         finally
         {
-            Interlocked.Decrement(ref _workAheadCount);
+            if (!realtime)
+            {
+                Interlocked.Decrement(ref _workAheadCount);
+            }
         }
 
         return false;
@@ -334,33 +375,7 @@ public class HlsSessionWorker : IHlsSessionWorker
                     lines);
                 await WritePlaylist(trimResult.Playlist, cancellationToken);
 
-                // delete old segments
-                var allSegments = Directory.GetFiles(
-                        Path.Combine(FileSystemLayout.TranscodeFolder, _channelNumber),
-                        "live*.ts")
-                    .Map(
-                        file =>
-                        {
-                            string fileName = Path.GetFileName(file);
-                            var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
-                            return new Segment(file, sequenceNumber);
-                        })
-                    .ToList();
-
-                var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
-                // if (toDelete.Count > 0)
-                // {
-                //     _logger.LogDebug(
-                //         "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)
-                {
-                    File.Delete(segment.File);
-                }
+                DeleteOldSegments(trimResult);
 
                 PlaylistStart = trimResult.PlaylistStart;
             }
@@ -371,10 +386,40 @@ public class HlsSessionWorker : IHlsSessionWorker
         }
     }
 
+    private void DeleteOldSegments(TrimPlaylistResult trimResult)
+    {
+        // delete old segments
+        var allSegments = Directory.GetFiles(
+                Path.Combine(FileSystemLayout.TranscodeFolder, _channelNumber),
+                "live*.ts")
+            .Map(
+                file =>
+                {
+                    string fileName = Path.GetFileName(file);
+                    var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
+                    return new Segment(file, sequenceNumber);
+                })
+            .ToList();
+
+        var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
+        if (toDelete.Count > 0)
+        {
+            // _logger.LogDebug(
+            //     "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)
+        {
+            File.Delete(segment.File);
+        }
+    }
+
     private async Task<long> GetPtsOffset(
         IMediator mediator,
         string channelNumber,
-        bool firstProcess,
         CancellationToken cancellationToken)
     {
         await Slim.WaitAsync(cancellationToken);
@@ -382,8 +427,8 @@ public class HlsSessionWorker : IHlsSessionWorker
         {
             long result = 0;
 
-            // the first process always starts at zero
-            if (firstProcess)
+            // if we haven't yet written any segments, start at zero
+            if (!_hasWrittenSegments)
             {
                 return result;
             }

ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs

@@ -30,7 +30,7 @@ public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetCo
             .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
             .Map(result => result.IfNone(false));
 
-        Command process = _ffmpegProcessService.ConcatChannel(
+        Command process = await _ffmpegProcessService.ConcatChannel(
             ffmpegPath,
             saveReports,
             channel,

ErsatzTV.Application/Streaming/Queries/GetErrorProcessHandler.cs

@@ -33,7 +33,8 @@ public class GetErrorProcessHandler : FFmpegProcessHandler<GetErrorProcess>
             request.HlsRealtime,
             request.PtsOffset,
             channel.FFmpegProfile.VaapiDriver,
-            channel.FFmpegProfile.VaapiDevice);
+            channel.FFmpegProfile.VaapiDevice,
+            Optional(channel.FFmpegProfile.QsvExtraHardwareFrames));
 
         return new PlayoutItemProcessModel(process, request.MaybeDuration, request.Until);
     }

ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs

@@ -4,6 +4,7 @@ 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;
@@ -27,6 +28,7 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
     private readonly ILocalFileSystem _localFileSystem;
     private readonly ILogger<GetPlayoutItemProcessByChannelNumberHandler> _logger;
     private readonly IMediaCollectionRepository _mediaCollectionRepository;
+    private readonly IMusicVideoCreditsGenerator _musicVideoCreditsGenerator;
     private readonly IPlexPathReplacementService _plexPathReplacementService;
     private readonly ISongVideoGenerator _songVideoGenerator;
     private readonly ITelevisionRepository _televisionRepository;
@@ -42,6 +44,7 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
         ITelevisionRepository televisionRepository,
         IArtistRepository artistRepository,
         ISongVideoGenerator songVideoGenerator,
+        IMusicVideoCreditsGenerator musicVideoCreditsGenerator,
         ILogger<GetPlayoutItemProcessByChannelNumberHandler> logger)
         : base(dbContextFactory)
     {
@@ -54,6 +57,7 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
         _televisionRepository = televisionRepository;
         _artistRepository = artistRepository;
         _songVideoGenerator = songVideoGenerator;
+        _musicVideoCreditsGenerator = musicVideoCreditsGenerator;
         _logger = logger;
     }
 
@@ -90,12 +94,18 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
             .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
             .ThenInclude(mvm => mvm.Subtitles)
             .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Artists)
+            .Include(i => i.MediaItem)
             .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
             .ThenInclude(mv => mv.MediaFiles)
             .Include(i => i.MediaItem)
             .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
             .ThenInclude(mv => mv.Streams)
             .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).Artist)
+            .ThenInclude(mv => mv.ArtistMetadata)
+            .Include(i => i.MediaItem)
             .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
             .ThenInclude(ovm => ovm.Subtitles)
             .Include(i => i.MediaItem)
@@ -155,19 +165,18 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                 .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
                 .Map(result => result.IfNone(false));
 
-            List<Subtitle> subtitles = GetSubtitles(playoutItemWithPath);
-
             Command process = await _ffmpegProcessService.ForPlayoutItem(
                 ffmpegPath,
                 ffprobePath,
                 saveReports,
                 channel,
                 videoVersion,
-                audioVersion,
+                new MediaItemAudioVersion(playoutItemWithPath.PlayoutItem.MediaItem, audioVersion),
                 videoPath,
                 audioPath,
-                subtitles,
+                settings => GetSubtitles(playoutItemWithPath, channel, settings),
                 playoutItemWithPath.PlayoutItem.PreferredAudioLanguageCode ?? channel.PreferredAudioLanguageCode,
+                playoutItemWithPath.PlayoutItem.PreferredAudioTitle ?? channel.PreferredAudioTitle,
                 playoutItemWithPath.PlayoutItem.PreferredSubtitleLanguageCode ?? channel.PreferredSubtitleLanguageCode,
                 playoutItemWithPath.PlayoutItem.SubtitleMode ?? channel.SubtitleMode,
                 playoutItemWithPath.PlayoutItem.StartOffset,
@@ -177,13 +186,15 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                 maybeGlobalWatermark,
                 channel.FFmpegProfile.VaapiDriver,
                 channel.FFmpegProfile.VaapiDevice,
+                Optional(channel.FFmpegProfile.QsvExtraHardwareFrames),
                 request.HlsRealtime,
                 playoutItemWithPath.PlayoutItem.FillerKind,
                 playoutItemWithPath.PlayoutItem.InPoint,
                 playoutItemWithPath.PlayoutItem.OutPoint,
                 request.PtsOffset,
                 request.TargetFramerate,
-                playoutItemWithPath.PlayoutItem.DisableWatermarks);
+                playoutItemWithPath.PlayoutItem.DisableWatermarks,
+                _ => { });
 
             var result = new PlayoutItemProcessModel(
                 process,
@@ -223,7 +234,8 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                         request.HlsRealtime,
                         request.PtsOffset,
                         channel.FFmpegProfile.VaapiDriver,
-                        channel.FFmpegProfile.VaapiDevice);
+                        channel.FFmpegProfile.VaapiDevice,
+                        Optional(channel.FFmpegProfile.QsvExtraHardwareFrames));
 
                     return new PlayoutItemProcessModel(offlineProcess, maybeDuration, finish);
                 case PlayoutItemDoesNotExistOnDisk:
@@ -235,7 +247,8 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                         request.HlsRealtime,
                         request.PtsOffset,
                         channel.FFmpegProfile.VaapiDriver,
-                        channel.FFmpegProfile.VaapiDevice);
+                        channel.FFmpegProfile.VaapiDevice,
+                        Optional(channel.FFmpegProfile.QsvExtraHardwareFrames));
 
                     return new PlayoutItemProcessModel(doesNotExistProcess, maybeDuration, finish);
                 default:
@@ -247,7 +260,8 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
                         request.HlsRealtime,
                         request.PtsOffset,
                         channel.FFmpegProfile.VaapiDriver,
-                        channel.FFmpegProfile.VaapiDevice);
+                        channel.FFmpegProfile.VaapiDevice,
+                        Optional(channel.FFmpegProfile.QsvExtraHardwareFrames));
 
                     return new PlayoutItemProcessModel(errorProcess, maybeDuration, finish);
             }
@@ -256,22 +270,23 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
         return BaseError.New($"Unexpected error locating playout item for channel {channel.Number}");
     }
 
-    private static List<Subtitle> GetSubtitles(PlayoutItemWithPath playoutItemWithPath)
+    private async Task<List<Subtitle>> GetSubtitles(
+        PlayoutItemWithPath playoutItemWithPath,
+        Channel channel,
+        FFmpegPlaybackSettings settings)
     {
         List<Subtitle> allSubtitles = playoutItemWithPath.PlayoutItem.MediaItem switch
         {
-            Episode episode => Optional(episode.EpisodeMetadata).Flatten().HeadOrNone()
+            Episode episode => await Optional(episode.EpisodeMetadata).Flatten().HeadOrNone()
                 .Map(mm => mm.Subtitles ?? new List<Subtitle>())
-                .IfNone(new List<Subtitle>()),
-            Movie movie => Optional(movie.MovieMetadata).Flatten().HeadOrNone()
+                .IfNoneAsync(new List<Subtitle>()),
+            Movie movie => await Optional(movie.MovieMetadata).Flatten().HeadOrNone()
                 .Map(mm => mm.Subtitles ?? new List<Subtitle>())
-                .IfNone(new List<Subtitle>()),
-            MusicVideo musicVideo => Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone()
+                .IfNoneAsync(new List<Subtitle>()),
+            MusicVideo musicVideo => await GetMusicVideoSubtitles(musicVideo, channel, settings),
+            OtherVideo otherVideo => await Optional(otherVideo.OtherVideoMetadata).Flatten().HeadOrNone()
                 .Map(mm => mm.Subtitles ?? new List<Subtitle>())
-                .IfNone(new List<Subtitle>()),
-            OtherVideo otherVideo => Optional(otherVideo.OtherVideoMetadata).Flatten().HeadOrNone()
-                .Map(mm => mm.Subtitles ?? new List<Subtitle>())
-                .IfNone(new List<Subtitle>()),
+                .IfNoneAsync(new List<Subtitle>()),
             _ => new List<Subtitle>()
         };
 
@@ -309,6 +324,49 @@ public class GetPlayoutItemProcessByChannelNumberHandler : FFmpegProcessHandler<
         return allSubtitles;
     }
 
+    private async Task<List<Subtitle>> GetMusicVideoSubtitles(
+        MusicVideo musicVideo,
+        Channel channel,
+        FFmpegPlaybackSettings settings)
+    {
+        var subtitles = new List<Subtitle>();
+
+        switch (channel.MusicVideoCreditsMode)
+        {
+            case ChannelMusicVideoCreditsMode.GenerateSubtitles:
+                var fileWithExtension = $"{channel.MusicVideoCreditsTemplate}.sbntxt";
+                if (!string.IsNullOrWhiteSpace(fileWithExtension))
+                {
+                    subtitles.AddRange(
+                        await _musicVideoCreditsGenerator.GenerateCreditsSubtitleFromTemplate(
+                            musicVideo,
+                            channel.FFmpegProfile,
+                            settings,
+                            Path.Combine(FileSystemLayout.MusicVideoCreditsTemplatesFolder, fileWithExtension)));
+                }
+                else
+                {
+                    _logger.LogWarning(
+                        "Music video credits template {Template} does not exist; falling back to built-in template",
+                        fileWithExtension);
+
+                    subtitles.AddRange(
+                        await _musicVideoCreditsGenerator.GenerateCreditsSubtitle(musicVideo, channel.FFmpegProfile));
+                }
+
+                break;
+            case ChannelMusicVideoCreditsMode.None:
+            default:
+                subtitles.AddRange(
+                    await Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone()
+                        .Map(mm => mm.Subtitles)
+                        .IfNoneAsync(new List<Subtitle>()));
+                break;
+        }
+
+        return subtitles;
+    }
+
     private async Task<Either<BaseError, PlayoutItemWithPath>> CheckForFallbackFiller(
         TvContext dbContext,
         Channel channel,

ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs

@@ -30,7 +30,7 @@ public class GetWrappedProcessByChannelNumberHandler : FFmpegProcessHandler<GetW
             .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
             .Map(result => result.IfNone(false));
 
-        Command process = _ffmpegProcessService.WrapSegmenter(
+        Command process = await _ffmpegProcessService.WrapSegmenter(
             ffmpegPath,
             saveReports,
             channel,

ErsatzTV.Application/Subtitles/Commands/ExtractEmbeddedSubtitlesHandler.cs

@@ -109,31 +109,31 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                 .Filter(pi => pi.Start <= until)
                 .ToListAsync(cancellationToken);
 
-            // TODO: support other media kinds (movies, other videos, etc)
-
             var mediaItemIds = playoutItems.Map(pi => pi.MediaItemId).ToList();
 
-            // filter for subtitles that need extraction
-            List<int> unextractedMediaItemIds =
-                await GetUnextractedMediaItemIds(dbContext, mediaItemIds, cancellationToken);
+            // filter for items with text subtitles or font attachments
+            List<int> mediaItemIdsWithTextSubtitles =
+                await GetMediaItemIdsWithTextSubtitles(dbContext, mediaItemIds, cancellationToken);
 
-            if (unextractedMediaItemIds.Any())
+            if (mediaItemIdsWithTextSubtitles.Any())
             {
                 _logger.LogDebug(
-                    "Found media items {MediaItemIds} with text subtitles to extract for playouts {PlayoutIds}",
-                    unextractedMediaItemIds,
+                    "Checking media items {MediaItemIds} for text subtitles or fonts to extract for playouts {PlayoutIds}",
+                    mediaItemIdsWithTextSubtitles,
                     playoutIdsToCheck);
             }
             else
             {
-                _logger.LogDebug("Found no text subtitles to extract for playouts {PlayoutIds}", playoutIdsToCheck);
+                _logger.LogDebug(
+                    "Found no text subtitles or fonts to extract for playouts {PlayoutIds}",
+                    playoutIdsToCheck);
             }
 
             // sort by start time
             var toUpdate = playoutItems
                 .Filter(pi => pi.Finish >= DateTime.UtcNow)
                 .DistinctBy(pi => pi.MediaItemId)
-                .Filter(pi => unextractedMediaItemIds.Contains(pi.MediaItemId))
+                .Filter(pi => mediaItemIdsWithTextSubtitles.Contains(pi.MediaItemId))
                 .OrderBy(pi => pi.StartOffset)
                 .Map(pi => pi.MediaItemId)
                 .ToList();
@@ -145,14 +145,13 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                     return Unit.Default;
                 }
 
-                PlayoutItem pi = playoutItems.Find(pi => pi.MediaItemId == mediaItemId);
-                _logger.LogDebug("Extracting subtitles for item with start time {StartTime}", pi?.StartOffset);
-
                 // extract subtitles and fonts for each item and update db
                 await ExtractSubtitles(dbContext, mediaItemId, ffmpegPath, cancellationToken);
-                // await ExtractFonts(dbContext, episodeId, ffmpegPath, cancellationToken);
+                await ExtractFonts(dbContext, mediaItemId, ffmpegPath, cancellationToken);
             }
 
+            _logger.LogDebug("Done checking playouts {PlayoutIds} for text subtitles to extract", playoutIdsToCheck);
+
             return Unit.Default;
         }
         catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
@@ -161,7 +160,7 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
         }
     }
 
-    private async Task<List<int>> GetUnextractedMediaItemIds(
+    private async Task<List<int>> GetMediaItemIdsWithTextSubtitles(
         TvContext dbContext,
         List<int> mediaItemIds,
         CancellationToken cancellationToken)
@@ -174,7 +173,7 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                 .Filter(em => mediaItemIds.Contains(em.EpisodeId))
                 .Filter(
                     em => em.Subtitles.Any(
-                        s => s.SubtitleKind == SubtitleKind.Embedded && s.IsExtracted == false &&
+                        s => s.SubtitleKind == SubtitleKind.Embedded &&
                              s.Codec != "hdmv_pgs_subtitle" && s.Codec != "dvd_subtitle"))
                 .Map(em => em.EpisodeId)
                 .ToListAsync(cancellationToken);
@@ -184,7 +183,7 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                 .Filter(mm => mediaItemIds.Contains(mm.MovieId))
                 .Filter(
                     mm => mm.Subtitles.Any(
-                        s => s.SubtitleKind == SubtitleKind.Embedded && s.IsExtracted == false &&
+                        s => s.SubtitleKind == SubtitleKind.Embedded &&
                              s.Codec != "hdmv_pgs_subtitle" && s.Codec != "dvd_subtitle"))
                 .Map(mm => mm.MovieId)
                 .ToListAsync(cancellationToken);
@@ -194,7 +193,7 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                 .Filter(mm => mediaItemIds.Contains(mm.MusicVideoId))
                 .Filter(
                     mm => mm.Subtitles.Any(
-                        s => s.SubtitleKind == SubtitleKind.Embedded && s.IsExtracted == false &&
+                        s => s.SubtitleKind == SubtitleKind.Embedded &&
                              s.Codec != "hdmv_pgs_subtitle" && s.Codec != "dvd_subtitle"))
                 .Map(mm => mm.MusicVideoId)
                 .ToListAsync(cancellationToken);
@@ -204,7 +203,7 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                 .Filter(ovm => mediaItemIds.Contains(ovm.OtherVideoId))
                 .Filter(
                     ovm => ovm.Subtitles.Any(
-                        s => s.SubtitleKind == SubtitleKind.Embedded && s.IsExtracted == false &&
+                        s => s.SubtitleKind == SubtitleKind.Embedded &&
                              s.Codec != "hdmv_pgs_subtitle" && s.Codec != "dvd_subtitle"))
                 .Map(ovm => ovm.OtherVideoId)
                 .ToListAsync(cancellationToken);
@@ -218,40 +217,13 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
         return result;
     }
 
-    private async Task<Unit> ExtractSubtitles(
+    private async Task ExtractSubtitles(
         TvContext dbContext,
         int mediaItemId,
         string ffmpegPath,
         CancellationToken cancellationToken)
     {
-        Option<MediaItem> maybeMediaItem = await dbContext.MediaItems
-            .Include(mi => (mi as Episode).MediaVersions)
-            .ThenInclude(mv => mv.MediaFiles)
-            .Include(mi => (mi as Episode).MediaVersions)
-            .ThenInclude(mv => mv.Streams)
-            .Include(mi => (mi as Episode).EpisodeMetadata)
-            .ThenInclude(em => em.Subtitles)
-            .Include(mi => (mi as Movie).MediaVersions)
-            .ThenInclude(mv => mv.MediaFiles)
-            .Include(mi => (mi as Movie).MediaVersions)
-            .ThenInclude(mv => mv.Streams)
-            .Include(mi => (mi as Movie).MovieMetadata)
-            .ThenInclude(em => em.Subtitles)
-            .Include(mi => (mi as MusicVideo).MediaVersions)
-            .ThenInclude(mv => mv.MediaFiles)
-            .Include(mi => (mi as MusicVideo).MediaVersions)
-            .ThenInclude(mv => mv.Streams)
-            .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
-            .ThenInclude(em => em.Subtitles)
-            .Include(mi => (mi as OtherVideo).MediaVersions)
-            .ThenInclude(mv => mv.MediaFiles)
-            .Include(mi => (mi as OtherVideo).MediaVersions)
-            .ThenInclude(mv => mv.Streams)
-            .Include(mi => (mi as OtherVideo).OtherVideoMetadata)
-            .ThenInclude(em => em.Subtitles)
-            .SelectOneAsync(e => e.Id, e => e.Id == mediaItemId);
-
-        foreach (MediaItem mediaItem in maybeMediaItem)
+        foreach (MediaItem mediaItem in await GetMediaItem(dbContext, mediaItemId))
         {
             foreach (List<Subtitle> allSubtitles in GetSubtitles(mediaItem))
             {
@@ -273,6 +245,11 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                     }
                 }
 
+                if (subtitlesToExtract.Count == 0)
+                {
+                    continue;
+                }
+
                 string mediaItemPath = await GetMediaItemPath(mediaItem);
 
                 ArgumentsBuilder args = new ArgumentsBuilder()
@@ -316,10 +293,36 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
                 }
             }
         }
-
-        return Unit.Default;
     }
 
+    private static async Task<Option<MediaItem>> GetMediaItem(TvContext dbContext, int mediaItemId) =>
+        await dbContext.MediaItems
+            .Include(mi => (mi as Episode).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mi => (mi as Episode).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Subtitles)
+            .Include(mi => (mi as Movie).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mi => (mi as Movie).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(em => em.Subtitles)
+            .Include(mi => (mi as MusicVideo).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mi => (mi as MusicVideo).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(em => em.Subtitles)
+            .Include(mi => (mi as OtherVideo).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mi => (mi as OtherVideo).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(mi => (mi as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(em => em.Subtitles)
+            .SelectOneAsync(e => e.Id, e => e.Id == mediaItemId);
+
     private static Option<List<Subtitle>> GetSubtitles(MediaItem mediaItem) =>
         mediaItem switch
         {
@@ -330,44 +333,64 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
             _ => None
         };
 
-    private async Task<Unit> ExtractFonts(
+    private async Task ExtractFonts(
         TvContext dbContext,
         int mediaItemId,
         string ffmpegPath,
         CancellationToken cancellationToken)
     {
-        Option<Episode> maybeEpisode = await dbContext.Episodes
-            .Include(e => e.MediaVersions)
-            .ThenInclude(mv => mv.MediaFiles)
-            .Include(e => e.MediaVersions)
-            .ThenInclude(mv => mv.Streams)
-            .Include(e => e.EpisodeMetadata)
-            .ThenInclude(em => em.Subtitles)
-            .SelectOneAsync(e => e.Id, e => e.Id == mediaItemId);
-
-        foreach (Episode episode in maybeEpisode)
+        foreach (MediaItem mediaItem in await GetMediaItem(dbContext, mediaItemId))
         {
-            string mediaItemPath = episode.GetHeadVersion().MediaFiles.Head().Path;
+            MediaVersion headVersion = mediaItem.GetHeadVersion();
+            var attachments = headVersion.Streams
+                .Filter(s => s.MediaStreamKind == MediaStreamKind.Attachment)
+                .OrderBy(s => s.Index)
+                .ToList();
 
-            var arguments = $"-nostdin -hide_banner -dump_attachment:t \"\" -i \"{mediaItemPath}\" -y";
+            for (var attachmentIndex = 0; attachmentIndex < attachments.Count; attachmentIndex++)
+            {
+                MediaStream fontStream = attachments[attachmentIndex];
 
-            BufferedCommandResult result = await Cli.Wrap(ffmpegPath)
-                .WithWorkingDirectory(FileSystemLayout.FontsCacheFolder)
-                .WithArguments(arguments)
-                .WithValidation(CommandResultValidation.None)
-                .ExecuteBufferedAsync(cancellationToken);
+                if (!(fontStream.MimeType ?? string.Empty).Contains("font") &&
+                    !(fontStream.MimeType ?? string.Empty).Contains("opentype"))
+                {
+                    // not a font
+                    continue;
+                }
 
-            // if (result.ExitCode == 0)
-            // {
-            //     _logger.LogDebug("Successfully extracted attached fonts");
-            // }
-            // else
-            // {
-            //     _logger.LogError("Failed to extract attached fonts. {Error}", result.StandardError);
-            // }
+                string fullOutputPath = Path.Combine(FileSystemLayout.FontsCacheFolder, fontStream.FileName);
+                if (_localFileSystem.FileExists(fullOutputPath))
+                {
+                    // already extracted
+                    continue;
+                }
+
+                string mediaItemPath = await GetMediaItemPath(mediaItem);
+
+                var arguments =
+                    $"-nostdin -hide_banner -dump_attachment:t:{attachmentIndex} \"\" -i \"{mediaItemPath}\" -y";
+
+                BufferedCommandResult result = await Cli.Wrap(ffmpegPath)
+                    .WithWorkingDirectory(FileSystemLayout.FontsCacheFolder)
+                    .WithArguments(arguments)
+                    .WithValidation(CommandResultValidation.None)
+                    .ExecuteBufferedAsync(cancellationToken);
+
+                // ffmpeg seems to return exit code 1 in all cases when dumping an attachment
+                // so ignore it and check success a different way
+                if (_localFileSystem.FileExists(fullOutputPath))
+                {
+                    _logger.LogDebug("Successfully extracted font {Font}", fontStream.FileName);
+                }
+                else
+                {
+                    _logger.LogError(
+                        "Failed to extract attached font {Font}. {Error}",
+                        fontStream.FileName,
+                        result.StandardError);
+                }
+            }
         }
-
-        return Unit.Default;
     }
 
     private static Task<Validation<BaseError, string>> FFmpegPathMustExist(TvContext dbContext) =>
@@ -442,6 +465,4 @@ public class ExtractEmbeddedSubtitlesHandler : IRequestHandler<ExtractEmbeddedSu
     }
 
     private record SubtitleToExtract(Subtitle Subtitle, string OutputPath);
-
-    private record FontToExtract(MediaStream Stream, string OutputPath);
 }

ErsatzTV.Application/Templates/Queries/GetMusicVideoCreditTemplates.cs

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