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

fix qsv encoder regression and memory errors (#828 )
* fix qsv encoders; only use 64 extra hw frames * update changelog
2022-06-01 18:01:07 -05:00 · 2022-05-31 06:07:50 -05:00 · 2022-05-31 05:56:48 -05:00 · 2022-05-29 20:44:27 -05:00 · 2022-05-28 20:41:54 -05:00 · 2022-05-28 20:41:22 -05:00
52 changed files with 5891 additions and 655 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

 ## [Unreleased]

+## [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
+- Fix watermark opacity in cultures where `,` is a decimal separator
+- Rework playlist filtering to avoid empty playlist responses
+- Fix some QSV/VAAPI memory errors by always requesting 64 extra hardware frames
+
+### Added
+- Enable QSV hardware acceleration for vaapi docker images
+
+### Changed
+- Use paging to synchronize all media from Plex, Jellyfin and Emby
+  - This will reduce memory use and improve reliability of synchronizing large libraries
+- Disable low power mode for `h264_qsv` and `hevc_qsv` encoders
+
 ## [0.5.8-beta] - 2022-05-20
 ### Fixed
 - Fix error display with `HLS Segmenter` and `MPEG-TS` streaming modes
@@ -1210,7 +1225,8 @@ 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.5.8-beta...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.6.0-beta...HEAD
+[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
 [0.5.6-beta]: https://github.com/jasongdove/ErsatzTV/compare/v0.5.5-beta...v0.5.6-beta
--- a/ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs
@@ -9,7 +9,9 @@ public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGu
    private readonly IChannelRepository _channelRepository;
    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;

-    public GetChannelGuideHandler(IChannelRepository channelRepository, RecyclableMemoryStreamManager recyclableMemoryStreamManager)
+    public GetChannelGuideHandler(
+        IChannelRepository channelRepository,
+        RecyclableMemoryStreamManager recyclableMemoryStreamManager)
    {
        _channelRepository = channelRepository;
        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
--- a/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
+++ b/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
@@ -190,7 +190,7 @@ public class HlsSessionWorker : IHlsSessionWorker

            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();

-            long ptsOffset = await GetPtsOffset(mediator, _channelNumber, cancellationToken);
+            long ptsOffset = await GetPtsOffset(mediator, _channelNumber, _firstProcess, cancellationToken);
            // _logger.LogInformation("PTS offset: {PtsOffset}", ptsOffset);

            var request = new GetPlayoutItemProcessByChannelNumber(
@@ -374,6 +374,7 @@ public class HlsSessionWorker : IHlsSessionWorker
    private async Task<long> GetPtsOffset(
        IMediator mediator,
        string channelNumber,
+        bool firstProcess,
        CancellationToken cancellationToken)
    {
        await Slim.WaitAsync(cancellationToken);
@@ -381,6 +382,12 @@ public class HlsSessionWorker : IHlsSessionWorker
        {
            long result = 0;

+            // the first process always starts at zero
+            if (firstProcess)
+            {
+                return result;
+            }
+
            Either<BaseError, PtsAndDuration> queryResult = await mediator.Send(
                new GetLastPtsDuration(channelNumber),
                cancellationToken);
--- a/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
+++ b/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
@@ -9,8 +9,8 @@
    <ItemGroup>
      <PackageReference Include="Bugsnag" Version="3.0.1" />
      <PackageReference Include="CliWrap" Version="3.4.4" />
-      <PackageReference Include="FluentAssertions" Version="6.6.0" />
-      <PackageReference Include="LanguageExt.Core" Version="4.1.0" />
+      <PackageReference Include="FluentAssertions" Version="6.7.0" />
+      <PackageReference Include="LanguageExt.Core" Version="4.1.1" />
      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="6.0.1" />
      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
      <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
--- a/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
@@ -20,7 +20,7 @@ public class HlsPlaylistFilterTests
    private HlsPlaylistFilter _hlsPlaylistFilter;

    [Test]
-    public void _hlsPlaylistFilter_ShouldRewriteProgramDateTime()
+    public void HlsPlaylistFilter_ShouldRewriteProgramDateTime()
    {
        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
        string[] input = NormalizeLineEndings(
@@ -50,9 +50,8 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
-#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-DISCONTINUITY-SEQUENCE:1
 #EXT-X-INDEPENDENT-SEGMENTS
-#EXT-X-DISCONTINUITY
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
 live001137.ts
@@ -66,7 +65,7 @@ live001139.ts
    }

    [Test]
-    public void _hlsPlaylistFilter_ShouldLimitSegments()
+    public void HlsPlaylistFilter_ShouldLimitSegments()
    {
        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
        string[] input = NormalizeLineEndings(
@@ -96,9 +95,8 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
-#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-DISCONTINUITY-SEQUENCE:1
 #EXT-X-INDEPENDENT-SEGMENTS
-#EXT-X-DISCONTINUITY
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
 live001137.ts
@@ -109,7 +107,7 @@ live001138.ts
    }

    [Test]
-    public void _hlsPlaylistFilter_ShouldAddDiscontinuity()
+    public void HlsPlaylistFilter_ShouldAddDiscontinuity()
    {
        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
        string[] input = NormalizeLineEndings(
@@ -144,9 +142,8 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
-#EXT-X-DISCONTINUITY-SEQUENCE:0
+#EXT-X-DISCONTINUITY-SEQUENCE:1
 #EXT-X-INDEPENDENT-SEGMENTS
-#EXT-X-DISCONTINUITY
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
 live001137.ts
@@ -161,7 +158,7 @@ live001139.ts
    }

    [Test]
-    public void _hlsPlaylistFilter_ShouldFilterOldSegments()
+    public void HlsPlaylistFilter_ShouldFilterOldSegmentsBeyondMax()
    {
        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
        string[] input = NormalizeLineEndings(
@@ -181,48 +178,7 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);

-        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
-
-        result.PlaylistStart.Should().Be(start.AddSeconds(8));
-        result.Sequence.Should().Be(1139);
-        result.Playlist.Should().Be(
-            NormalizeLineEndings(
-                @"#EXTM3U
-#EXT-X-VERSION:6
-#EXT-X-TARGETDURATION:4
-#EXT-X-MEDIA-SEQUENCE:1139
-#EXT-X-DISCONTINUITY-SEQUENCE:0
-#EXT-X-INDEPENDENT-SEGMENTS
-#EXT-X-DISCONTINUITY
-#EXTINF:4.000000,
-#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
-live001139.ts
-"));
-    }
-
-    [Test]
-    public void _hlsPlaylistFilter_ShouldFilterOldDiscontinuity()
-    {
-        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-        string[] input = NormalizeLineEndings(
-            @"#EXTM3U
-#EXT-X-VERSION:6
-#EXT-X-TARGETDURATION:4
-#EXT-X-MEDIA-SEQUENCE:1137
-#EXT-X-INDEPENDENT-SEGMENTS
-#EXT-X-DISCONTINUITY
-#EXTINF:4.000000,
-#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
-live001137.ts
-#EXT-X-DISCONTINUITY
-#EXTINF:4.000000,
-#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
-live001138.ts
-#EXTINF:4.000000,
-#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
-live001139.ts").Split(Environment.NewLine);
-
-        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input, 1);

        result.PlaylistStart.Should().Be(start.AddSeconds(8));
        result.Sequence.Should().Be(1139);
@@ -234,13 +190,367 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-MEDIA-SEQUENCE:1139
 #EXT-X-DISCONTINUITY-SEQUENCE:1
 #EXT-X-INDEPENDENT-SEGMENTS
-#EXT-X-DISCONTINUITY
 #EXTINF:4.000000,
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
    }

+    [Test]
+    public void HlsPlaylistFilter_ShouldFilterOldDiscontinuity()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(
+            @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:49.320-0500
+live001137.ts
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:53.320-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
+live001139.ts").Split(Environment.NewLine);
+
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(
+            NormalizeLineEndings(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:1137
+#EXT-X-DISCONTINUITY-SEQUENCE:1
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:00.000-0500
+live001137.ts
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
+live001138.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
+live001139.ts
+"));
+    }
+
+    [Test]
+    public void HlsPlaylistFilter_Should_Increment_DiscontinuityCount()
+    {
+        var start = new DateTimeOffset(2022, 5, 25, 20, 8, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(
+            @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:0
+#EXT-X-DISCONTINUITY
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-DISCONTINUITY
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:08:55.981-0500
+live000000.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:08:59.985-0500
+live000001.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:03.989-0500
+live000002.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:07.993-0500
+live000003.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:11.997-0500
+live000004.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:16.001-0500
+live000005.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:20.005-0500
+live000006.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:24.009-0500
+live000007.ts
+#EXTINF:3.970633,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:28.013-0500
+live000008.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:31.983-0500
+live000009.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:35.987-0500
+live000010.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:39.991-0500
+live000011.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:43.995-0500
+live000012.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:47.999-0500
+live000013.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:52.003-0500
+live000014.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:09:56.007-0500
+live000015.ts
+#EXTINF:3.970633,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:00.011-0500
+live000016.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:03.982-0500
+live000017.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:07.986-0500
+live000018.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:11.990-0500
+live000019.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:15.994-0500
+live000020.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:19.998-0500
+live000021.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:24.002-0500
+live000022.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:28.006-0500
+live000023.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:32.010-0500
+live000024.ts
+#EXTINF:3.970633,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:36.014-0500
+live000025.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:39.985-0500
+live000026.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:43.989-0500
+live000027.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:47.993-0500
+live000028.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:51.997-0500
+live000029.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:10:56.001-0500
+live000030.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:00.005-0500
+live000031.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:04.009-0500
+live000032.ts
+#EXTINF:3.970633,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:08.013-0500
+live000033.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:11.983-0500
+live000034.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:15.987-0500
+live000035.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:19.991-0500
+live000036.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:23.995-0500
+live000037.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:27.999-0500
+live000038.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:32.003-0500
+live000039.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:36.007-0500
+live000040.ts
+#EXTINF:3.970633,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:40.011-0500
+live000041.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:43.982-0500
+live000042.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:47.986-0500
+live000043.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:51.990-0500
+live000044.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:55.994-0500
+live000045.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:59.998-0500
+live000046.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:04.002-0500
+live000047.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:08.006-0500
+live000048.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:12.010-0500
+live000049.ts
+#EXTINF:3.970633,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:16.014-0500
+live000050.ts
+#EXTINF:4.004000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:19.985-0500
+live000051.ts
+#EXTINF:0.433767,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:23.989-0500
+live000052.ts
+#EXT-X-DISCONTINUITY
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:30.007-0500
+live000053.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:34.007-0500
+live000054.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:38.007-0500
+live000055.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:42.007-0500
+live000056.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:46.007-0500
+live000057.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:50.007-0500
+live000058.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:54.007-0500
+live000059.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:58.007-0500
+live000060.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:02.007-0500
+live000061.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:06.007-0500
+live000062.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:10.007-0500
+live000063.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:14.007-0500
+live000064.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:18.007-0500
+live000065.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:22.007-0500
+live000066.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:26.007-0500
+live000067.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:30.007-0500
+live000068.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:34.007-0500
+live000069.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:38.007-0500
+live000070.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:42.007-0500
+live000071.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:46.007-0500
+live000072.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:50.007-0500
+live000073.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:54.007-0500
+live000074.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:58.007-0500
+live000075.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:02.007-0500
+live000076.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:06.007-0500
+live000077.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:10.007-0500
+live000078.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:14.007-0500
+live000079.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:18.007-0500
+live000080.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:22.007-0500
+live000081.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:13:26.007-0500
+live000082.ts").Split(Environment.NewLine);
+
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(220), input);
+
+        // result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(56);
+        result.Playlist.Should().Be(
+            NormalizeLineEndings(
+                @"#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:56
+#EXT-X-DISCONTINUITY-SEQUENCE:2
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:40.441-0500
+live000056.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:44.441-0500
+live000057.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:48.441-0500
+live000058.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:52.441-0500
+live000059.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:11:56.441-0500
+live000060.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:00.441-0500
+live000061.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:04.441-0500
+live000062.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:08.441-0500
+live000063.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:12.441-0500
+live000064.ts
+#EXTINF:4.000000,
+#EXT-X-PROGRAM-DATE-TIME:2022-05-25T20:12:16.441-0500
+live000065.ts
+"));
+    }
+
    private static string NormalizeLineEndings(string str) =>
        str
            .Replace("\r\n", "\n")
--- a/ErsatzTV.Core/Emby/EmbyCollectionScanner.cs
+++ b/ErsatzTV.Core/Emby/EmbyCollectionScanner.cs
@@ -30,28 +30,22 @@ public class EmbyCollectionScanner : IEmbyCollectionScanner

    public async Task<Either<BaseError, Unit>> ScanCollections(string address, string apiKey)
    {
-        // get all collections from db (item id, etag)
-        List<EmbyCollection> existingCollections = await _embyCollectionRepository.GetCollections();
-
-        // get all collections from emby
-        Either<BaseError, List<EmbyCollection>> maybeIncomingCollections =
-            await _embyApiClient.GetCollectionLibraryItems(address, apiKey);
-
-        foreach (BaseError error in maybeIncomingCollections.LeftToSeq())
+        try
        {
-            _logger.LogWarning("Failed to get collections from Emby: {Error}", error.ToString());
-            return error;
-        }
+            var incomingItemIds = new List<string>();

-        foreach (List<EmbyCollection> incomingCollections in maybeIncomingCollections.RightToSeq())
-        {
-            // loop over collections
-            foreach (EmbyCollection collection in incomingCollections)
+            // get all collections from db (item id, etag)
+            List<EmbyCollection> existingCollections = await _embyCollectionRepository.GetCollections();
+
+            await foreach (EmbyCollection collection in _embyApiClient.GetCollectionLibraryItems(address, apiKey))
            {
+                incomingItemIds.Add(collection.ItemId);
+
                Option<EmbyCollection> maybeExisting = existingCollections.Find(c => c.ItemId == collection.ItemId);

                // skip if unchanged (etag)
-                if (await maybeExisting.Map(e => e.Etag ?? string.Empty).IfNoneAsync(string.Empty) == collection.Etag)
+                if (await maybeExisting.Map(e => e.Etag ?? string.Empty).IfNoneAsync(string.Empty) ==
+                    collection.Etag)
                {
                    _logger.LogDebug("Emby collection {Name} is unchanged", collection.Name);
                    continue;
@@ -75,12 +69,16 @@ public class EmbyCollectionScanner : IEmbyCollectionScanner
            }

            // remove missing collections (and remove any lingering tags from those collections)
-            foreach (EmbyCollection collection in existingCollections
-                         .Filter(e => incomingCollections.All(i => i.ItemId != e.ItemId)))
+            foreach (EmbyCollection collection in existingCollections.Filter(e => !incomingItemIds.Contains(e.ItemId)))
            {
                await _embyCollectionRepository.RemoveCollection(collection);
            }
        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to get collections from Emby");
+            return BaseError.New(ex.Message);
+        }

        return Unit.Default;
    }
@@ -90,32 +88,31 @@ public class EmbyCollectionScanner : IEmbyCollectionScanner
        string apiKey,
        EmbyCollection collection)
    {
-        // get collection items from JF
-        Either<BaseError, List<MediaItem>> maybeItems =
-            await _embyApiClient.GetCollectionItems(address, apiKey, collection.ItemId);
-
-        foreach (BaseError error in maybeItems.LeftToSeq())
+        try
        {
-            _logger.LogWarning("Failed to get collection items from Emby: {Error}", error.ToString());
-            return;
+            // get collection items from Emby
+            IAsyncEnumerable<MediaItem> items = _embyApiClient.GetCollectionItems(address, apiKey, collection.ItemId);
+
+            List<int> removedIds = await _embyCollectionRepository.RemoveAllTags(collection);
+
+            // sync tags on items
+            var addedIds = new List<int>();
+            await foreach (MediaItem item in items)
+            {
+                addedIds.Add(await _embyCollectionRepository.AddTag(item, collection));
+            }
+
+            _logger.LogDebug("Emby collection {Name} contains {Count} items", collection.Name, addedIds.Count);
+
+            var changedIds = removedIds.Except(addedIds).ToList();
+            changedIds.AddRange(addedIds.Except(removedIds));
+
+            await _searchIndex.RebuildItems(_searchRepository, changedIds);
+            _searchIndex.Commit();
        }
-
-        List<int> removedIds = await _embyCollectionRepository.RemoveAllTags(collection);
-
-        var embyItems = maybeItems.RightToSeq().Flatten().ToList();
-        _logger.LogDebug("Emby collection {Name} contains {Count} items", collection.Name, embyItems.Count);
-
-        // sync tags on items
-        var addedIds = new List<int>();
-        foreach (MediaItem item in embyItems)
+        catch (Exception ex)
        {
-            addedIds.Add(await _embyCollectionRepository.AddTag(item, collection));
+            _logger.LogWarning(ex, "Failed to synchronize Emby collection {Name}", collection.Name);
        }
-
-        var changedIds = removedIds.Except(addedIds).ToList();
-        changedIds.AddRange(addedIds.Except(removedIds));
-
-        await _searchIndex.RebuildItems(_searchRepository, changedIds);
-        _searchIndex.Commit();
    }
 }
--- a/ErsatzTV.Core/Emby/EmbyItemType.cs
+++ b/ErsatzTV.Core/Emby/EmbyItemType.cs
@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Emby;
+
+public static class EmbyItemType
+{
+    public static readonly string Movie = "Movie";
+    public static readonly string Show = "Series";
+    public static readonly string Season = "Season";
+    public static readonly string Episode = "Episode";
+    public static readonly string Collection = "BoxSet";
+    public static readonly string CollectionItems = "Movie,Series,Season,Episode";
+}
--- a/ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs
@@ -79,7 +79,16 @@ public class EmbyMovieLibraryScanner :
    protected override string MediaServerItemId(EmbyMovie movie) => movie.ItemId;
    protected override string MediaServerEtag(EmbyMovie movie) => movie.Etag;

-    protected override Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
+    protected override Task<Either<BaseError, int>> CountMovieLibraryItems(
+        EmbyConnectionParameters connectionParameters,
+        EmbyLibrary library) =>
+        _embyApiClient.GetLibraryItemCount(
+            connectionParameters.Address,
+            connectionParameters.ApiKey,
+            library.ItemId,
+            EmbyItemType.Movie);
+
+    protected override IAsyncEnumerable<EmbyMovie> GetMovieLibraryItems(
        EmbyConnectionParameters connectionParameters,
        EmbyLibrary library) =>
        _embyApiClient.GetMovieLibraryItems(
--- a/ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs
@@ -76,13 +76,19 @@ public class EmbyTelevisionLibraryScanner : MediaServerTelevisionLibraryScanner<
            cancellationToken);
    }

-    protected override Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
+    protected override Task<Either<BaseError, int>> CountShowLibraryItems(
        EmbyConnectionParameters connectionParameters,
-        EmbyLibrary library) =>
-        _embyApiClient.GetShowLibraryItems(
+        EmbyLibrary library)
+        => _embyApiClient.GetLibraryItemCount(
            connectionParameters.Address,
            connectionParameters.ApiKey,
-            library.ItemId);
+            library.ItemId,
+            EmbyItemType.Show);
+
+    protected override IAsyncEnumerable<EmbyShow> GetShowLibraryItems(
+        EmbyConnectionParameters connectionParameters,
+        EmbyLibrary library) =>
+        _embyApiClient.GetShowLibraryItems(connectionParameters.Address, connectionParameters.ApiKey, library);

    protected override string MediaServerItemId(EmbyShow show) => show.ItemId;
    protected override string MediaServerItemId(EmbySeason season) => season.ItemId;
@@ -92,23 +98,46 @@ public class EmbyTelevisionLibraryScanner : MediaServerTelevisionLibraryScanner<
    protected override string MediaServerEtag(EmbySeason season) => season.Etag;
    protected override string MediaServerEtag(EmbyEpisode episode) => episode.Etag;

-    protected override Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
+    protected override Task<Either<BaseError, int>> CountSeasonLibraryItems(
+        EmbyConnectionParameters connectionParameters,
+        EmbyLibrary library,
+        EmbyShow show) =>
+        _embyApiClient.GetLibraryItemCount(
+            connectionParameters.Address,
+            connectionParameters.ApiKey,
+            show.ItemId,
+            EmbyItemType.Season);
+
+    protected override IAsyncEnumerable<EmbySeason> GetSeasonLibraryItems(
        EmbyLibrary library,
        EmbyConnectionParameters connectionParameters,
        EmbyShow show) =>
        _embyApiClient.GetSeasonLibraryItems(
            connectionParameters.Address,
            connectionParameters.ApiKey,
+            library,
            show.ItemId);

-    protected override Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
+    protected override Task<Either<BaseError, int>> CountEpisodeLibraryItems(
+        EmbyConnectionParameters connectionParameters,
+        EmbyLibrary library,
+        EmbySeason season) =>
+        _embyApiClient.GetLibraryItemCount(
+            connectionParameters.Address,
+            connectionParameters.ApiKey,
+            season.ItemId,
+            EmbyItemType.Episode);
+
+    protected override IAsyncEnumerable<EmbyEpisode> GetEpisodeLibraryItems(
        EmbyLibrary library,
        EmbyConnectionParameters connectionParameters,
+        EmbyShow show,
        EmbySeason season) =>
        _embyApiClient.GetEpisodeLibraryItems(
            connectionParameters.Address,
            connectionParameters.ApiKey,
            library,
+            show.ItemId,
            season.ItemId);

    protected override Task<Option<ShowMetadata>> GetFullMetadata(
--- a/ErsatzTV.Core/ErsatzTV.Core.csproj
+++ b/ErsatzTV.Core/ErsatzTV.Core.csproj
@@ -9,8 +9,8 @@
    <ItemGroup>
      <PackageReference Include="Bugsnag" Version="3.0.1" />
      <PackageReference Include="Destructurama.Attributed" Version="3.0.0" />
-      <PackageReference Include="Flurl" Version="3.0.5" />
-      <PackageReference Include="LanguageExt.Core" Version="4.1.0" />
+      <PackageReference Include="Flurl" Version="3.0.6" />
+      <PackageReference Include="LanguageExt.Core" Version="4.1.1" />
      <PackageReference Include="MediatR" Version="10.0.1" />
      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
      <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="6.0.0" />
--- a/ErsatzTV.Core/FFmpeg/HlsPlaylistFilter.cs
+++ b/ErsatzTV.Core/FFmpeg/HlsPlaylistFilter.cs
@@ -25,52 +25,38 @@ public class HlsPlaylistFilter : IHlsPlaylistFilter
    {
        try
        {
-            // _logger.LogDebug(
-            //     "TrimPlaylist - Start {PlaylistStart}, FilterBefore {FilterBefore}, MaxSegments {MaxSegments}, EndWithDiscontinuity {EndWithDiscontinuity}",
-            //     playlistStart,
-            //     filterBefore,
-            //     maxSegments,
-            //     endWithDiscontinuity);
+            List<PlaylistItem> items = new();

            DateTimeOffset currentTime = playlistStart;
-            DateTimeOffset nextPlaylistStart = DateTimeOffset.MaxValue;

            var discontinuitySequence = 0;
-            var startSequence = 0;
-            var output = new StringBuilder();
-            var started = false;
            var i = 0;
-            var segments = 0;
            while (!lines[i].StartsWith("#EXTINF:"))
            {
                if (lines[i].StartsWith("#EXT-X-DISCONTINUITY-SEQUENCE"))
                {
                    discontinuitySequence = int.Parse(lines[i].Split(':')[1]);
                }
+                else if (lines[i].StartsWith("#EXT-X-DISCONTINUITY"))
+                {
+                    items.Add(new PlaylistDiscontinuity());
+                }

                i++;
            }

            while (i < lines.Length)
            {
-                if (segments >= maxSegments)
+                string line = lines[i];
+                if (string.IsNullOrWhiteSpace(line))
                {
-                    break;
+                    i++;
+                    continue;
                }

-                string line = lines[i];
-                // _logger.LogInformation("Line: {Line}", line);
                if (line.StartsWith("#EXT-X-DISCONTINUITY"))
                {
-                    if (started)
-                    {
-                        output.AppendLine("#EXT-X-DISCONTINUITY");
-                    }
-                    else
-                    {
-                        discontinuitySequence++;
-                    }
-
+                    items.Add(new PlaylistDiscontinuity());
                    i++;
                    continue;
                }
@@ -80,50 +66,23 @@ public class HlsPlaylistFilter : IHlsPlaylistFilter
                        lines[i].TrimEnd(',').Split(':')[1],
                        NumberStyles.Number,
                        CultureInfo.InvariantCulture));
-                if (currentTime < filterBefore)
-                {
-                    currentTime += duration;
-                    i += 3;
-                    continue;
-                }

-                nextPlaylistStart = currentTime < nextPlaylistStart ? currentTime : nextPlaylistStart;
-
-                if (!started)
-                {
-                    startSequence = int.Parse(lines[i + 2].Replace("live", string.Empty).Split('.')[0]);
-
-                    output.AppendLine("#EXTM3U");
-                    output.AppendLine("#EXT-X-VERSION:6");
-                    output.AppendLine("#EXT-X-TARGETDURATION:4");
-                    output.AppendLine($"#EXT-X-MEDIA-SEQUENCE:{startSequence}");
-                    output.AppendLine($"#EXT-X-DISCONTINUITY-SEQUENCE:{discontinuitySequence}");
-                    output.AppendLine("#EXT-X-INDEPENDENT-SEGMENTS");
-                    output.AppendLine("#EXT-X-DISCONTINUITY");
-
-                    started = true;
-                }
-
-                output.AppendLine(lines[i]);
-                string offset = currentTime.ToString("zzz").Replace(":", string.Empty);
-                output.AppendLine($"#EXT-X-PROGRAM-DATE-TIME:{currentTime:yyyy-MM-ddTHH:mm:ss.fff}{offset}");
-                output.AppendLine(lines[i + 2]);
+                items.Add(new PlaylistSegment(currentTime, lines[i], lines[i + 2]));

                currentTime += duration;
-                segments++;
                i += 3;
            }

-            var playlist = output.ToString();
-            if (endWithDiscontinuity && !playlist.EndsWith($"#EXT-X-DISCONTINUITY{Environment.NewLine}"))
+            if (endWithDiscontinuity && items[^1] is not PlaylistDiscontinuity)
            {
-                playlist += "#EXT-X-DISCONTINUITY" + Environment.NewLine;
+                items.Add(new PlaylistDiscontinuity());
            }

-            if (playlist.Trim().Split(Environment.NewLine).All(l => string.IsNullOrWhiteSpace(l) || l.StartsWith('#')))
-            {
-                throw new Exception("Trimming playlist to nothing");
-            }
+            (string playlist, DateTimeOffset nextPlaylistStart, int startSequence, int segments) = GeneratePlaylist(
+                items,
+                filterBefore,
+                discontinuitySequence,
+                maxSegments);

            return new TrimPlaylistResult(nextPlaylistStart, startSequence, playlist, segments);
        }
@@ -153,6 +112,98 @@ public class HlsPlaylistFilter : IHlsPlaylistFilter
        DateTimeOffset filterBefore,
        string[] lines) =>
        TrimPlaylist(playlistStart, filterBefore, lines, int.MaxValue, true);
+
+    private static Tuple<string, DateTimeOffset, int, int> GeneratePlaylist(
+        List<PlaylistItem> items,
+        DateTimeOffset filterBefore,
+        int discontinuitySequence,
+        int maxSegments)
+    {
+        if (items.Any() && items[0] is PlaylistDiscontinuity)
+        {
+            discontinuitySequence++;
+        }
+
+        while (items.Any() && items[0] is PlaylistDiscontinuity)
+        {
+            items.RemoveAt(0);
+        }
+
+        var allSegments = items.OfType<PlaylistSegment>().ToList();
+        // only filter if we have more than requested
+        if (allSegments.Count > maxSegments)
+        {
+            var afterFilter = allSegments.Filter(s => s.StartTime >= filterBefore).ToList();
+
+            // if there are enough new segments after filtering, use those
+            // otherwise return the last maxSegments
+            allSegments = afterFilter.Count >= maxSegments
+                ? afterFilter.Take(maxSegments).ToList()
+                : allSegments.TakeLast(maxSegments).ToList();
+        }
+
+        int startSequence = allSegments
+            .HeadOrNone()
+            .Map(s => s.StartSequence)
+            .IfNone(0);
+
+        // count all discontinuities that were filtered out
+        if (allSegments.Any())
+        {
+            int index = items.IndexOf(allSegments.Head());
+            int count = items.Take(index + 1).OfType<PlaylistDiscontinuity>().Count();
+            discontinuitySequence += count;
+        }
+
+        var output = new StringBuilder();
+        output.AppendLine("#EXTM3U");
+        output.AppendLine("#EXT-X-VERSION:6");
+        output.AppendLine("#EXT-X-TARGETDURATION:4");
+        output.AppendLine($"#EXT-X-MEDIA-SEQUENCE:{startSequence}");
+        output.AppendLine($"#EXT-X-DISCONTINUITY-SEQUENCE:{discontinuitySequence}");
+        output.AppendLine("#EXT-X-INDEPENDENT-SEGMENTS");
+
+        for (var i = 0; i < items.Count; i++)
+        {
+            switch (items[i])
+            {
+                case PlaylistDiscontinuity:
+                    if (i == items.Count - 1 || allSegments.Contains(items[i + 1]))
+                    {
+                        output.AppendLine("#EXT-X-DISCONTINUITY");
+                    }
+
+                    break;
+                case PlaylistSegment segment:
+                    if (allSegments.Contains(segment))
+                    {
+                        output.AppendLine(segment.ExtInf);
+                        string offset = segment.StartTime.ToString("zzz").Replace(":", string.Empty);
+                        output.AppendLine(
+                            $"#EXT-X-PROGRAM-DATE-TIME:{segment.StartTime:yyyy-MM-ddTHH:mm:ss.fff}{offset}");
+                        output.AppendLine(segment.Line);
+                    }
+
+                    break;
+            }
+        }
+
+        var playlist = output.ToString();
+        DateTimeOffset nextPlaylistStart = allSegments.HeadOrNone()
+            .Map(s => s.StartTime)
+            .IfNone(DateTimeOffset.MaxValue);
+
+        return Tuple(playlist, nextPlaylistStart, startSequence, allSegments.Count);
+    }
+
+    private abstract record PlaylistItem;
+
+    private record PlaylistSegment(DateTimeOffset StartTime, string ExtInf, string Line) : PlaylistItem
+    {
+        public int StartSequence => int.Parse(Line.Replace("live", string.Empty).Split('.')[0]);
+    }
+
+    private record PlaylistDiscontinuity : PlaylistItem;
 }

 public record TrimPlaylistResult(DateTimeOffset PlaylistStart, int Sequence, string Playlist, int SegmentCount);
--- a/ErsatzTV.Core/Interfaces/Emby/IEmbyApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Emby/IEmbyApiClient.cs
@@ -8,33 +8,30 @@ public interface IEmbyApiClient
    Task<Either<BaseError, EmbyServerInformation>> GetServerInformation(string address, string apiKey);
    Task<Either<BaseError, List<EmbyLibrary>>> GetLibraries(string address, string apiKey);

-    Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
-        string address,
-        string apiKey,
-        EmbyLibrary library);
+    IAsyncEnumerable<EmbyMovie> GetMovieLibraryItems(string address, string apiKey, EmbyLibrary library);

-    Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
-        string address,
-        string apiKey,
-        string libraryId);
+    IAsyncEnumerable<EmbyShow> GetShowLibraryItems(string address, string apiKey, EmbyLibrary library);

-    Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
-        string address,
-        string apiKey,
-        string showId);
-
-    Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
+    IAsyncEnumerable<EmbySeason> GetSeasonLibraryItems(
        string address,
        string apiKey,
        EmbyLibrary library,
-        string seasonId);
+        string showId);

-    Task<Either<BaseError, List<EmbyCollection>>> GetCollectionLibraryItems(
-        string address,
-        string apiKey);
-
-    Task<Either<BaseError, List<MediaItem>>> GetCollectionItems(
+    IAsyncEnumerable<EmbyEpisode> GetEpisodeLibraryItems(
        string address,
        string apiKey,
-        string collectionId);
+        EmbyLibrary library,
+        string showId,
+        string seasonId);
+
+    IAsyncEnumerable<EmbyCollection> GetCollectionLibraryItems(string address, string apiKey);
+
+    IAsyncEnumerable<MediaItem> GetCollectionItems(string address, string apiKey, string collectionId);
+
+    Task<Either<BaseError, int>> GetLibraryItemCount(
+        string address,
+        string apiKey,
+        string parentId,
+        string includeItemTypes);
 }
--- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs
@@ -9,37 +9,35 @@ public interface IJellyfinApiClient
    Task<Either<BaseError, List<JellyfinLibrary>>> GetLibraries(string address, string apiKey);
    Task<Either<BaseError, string>> GetAdminUserId(string address, string apiKey);

-    Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
-        string address,
-        string apiKey,
-        JellyfinLibrary library);
+    IAsyncEnumerable<JellyfinMovie> GetMovieLibraryItems(string address, string apiKey, JellyfinLibrary library);

-    Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
-        string address,
-        string apiKey,
-        int mediaSourceId,
-        string libraryId);
+    IAsyncEnumerable<JellyfinShow> GetShowLibraryItems(string address, string apiKey, JellyfinLibrary library);

-    Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
+    IAsyncEnumerable<JellyfinSeason> GetSeasonLibraryItems(
        string address,
        string apiKey,
-        int mediaSourceId,
+        JellyfinLibrary library,
        string showId);

-    Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
+    IAsyncEnumerable<JellyfinEpisode> GetEpisodeLibraryItems(
        string address,
        string apiKey,
        JellyfinLibrary library,
        string seasonId);

-    Task<Either<BaseError, List<JellyfinCollection>>> GetCollectionLibraryItems(
-        string address,
-        string apiKey,
-        int mediaSourceId);
+    IAsyncEnumerable<JellyfinCollection> GetCollectionLibraryItems(string address, string apiKey, int mediaSourceId);

-    Task<Either<BaseError, List<MediaItem>>> GetCollectionItems(
+    IAsyncEnumerable<MediaItem> GetCollectionItems(
        string address,
        string apiKey,
        int mediaSourceId,
        string collectionId);
+
+    Task<Either<BaseError, int>> GetLibraryItemCount(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string parentId,
+        string includeItemTypes,
+        bool excludeFolders);
 }
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs
@@ -13,23 +13,33 @@ public interface IPlexServerApiClient
        PlexConnection connection,
        PlexServerAuthToken token);

-    Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryContents(
+    IAsyncEnumerable<PlexMovie> GetMovieLibraryContents(
        PlexLibrary library,
        PlexConnection connection,
        PlexServerAuthToken token);

-    Task<Either<BaseError, List<PlexShow>>> GetShowLibraryContents(
+    IAsyncEnumerable<PlexShow> GetShowLibraryContents(
        PlexLibrary library,
        PlexConnection connection,
        PlexServerAuthToken token);

-    Task<Either<BaseError, List<PlexSeason>>> GetShowSeasons(
+    Task<Either<BaseError, int>> CountShowSeasons(
+        PlexShow show,
+        PlexConnection connection,
+        PlexServerAuthToken token);
+
+    IAsyncEnumerable<PlexSeason> GetShowSeasons(
        PlexLibrary library,
        PlexShow show,
        PlexConnection connection,
        PlexServerAuthToken token);

-    Task<Either<BaseError, List<PlexEpisode>>> GetSeasonEpisodes(
+    Task<Either<BaseError, int>> CountSeasonEpisodes(
+        PlexSeason season,
+        PlexConnection connection,
+        PlexServerAuthToken token);
+
+    IAsyncEnumerable<PlexEpisode> GetSeasonEpisodes(
        PlexLibrary library,
        PlexSeason season,
        PlexConnection connection,
@@ -58,4 +68,9 @@ public interface IPlexServerApiClient
        string key,
        PlexConnection connection,
        PlexServerAuthToken token);
+
+    Task<Either<BaseError, int>> GetLibraryItemCount(
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 }
--- a/ErsatzTV.Core/Jellyfin/JellyfinCollectionScanner.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinCollectionScanner.cs
@@ -30,24 +30,21 @@ public class JellyfinCollectionScanner : IJellyfinCollectionScanner

    public async Task<Either<BaseError, Unit>> ScanCollections(string address, string apiKey, int mediaSourceId)
    {
-        // get all collections from db (item id, etag)
-        List<JellyfinCollection> existingCollections = await _jellyfinCollectionRepository.GetCollections();
-
-        // get all collections from jellyfin
-        Either<BaseError, List<JellyfinCollection>> maybeIncomingCollections =
-            await _jellyfinApiClient.GetCollectionLibraryItems(address, apiKey, mediaSourceId);
-
-        foreach (BaseError error in maybeIncomingCollections.LeftToSeq())
+        try
        {
-            _logger.LogWarning("Failed to get collections from Jellyfin: {Error}", error.ToString());
-            return error;
-        }
+            var incomingItemIds = new List<string>();
+
+            // get all collections from db (item id, etag)
+            List<JellyfinCollection> existingCollections = await _jellyfinCollectionRepository.GetCollections();

-        foreach (List<JellyfinCollection> incomingCollections in maybeIncomingCollections.RightToSeq())
-        {
            // loop over collections
-            foreach (JellyfinCollection collection in incomingCollections)
+            await foreach (JellyfinCollection collection in _jellyfinApiClient.GetCollectionLibraryItems(
+                               address,
+                               apiKey,
+                               mediaSourceId))
            {
+                incomingItemIds.Add(collection.ItemId);
+
                Option<JellyfinCollection> maybeExisting = existingCollections.Find(c => c.ItemId == collection.ItemId);

                // skip if unchanged (etag)
@@ -75,12 +72,17 @@ public class JellyfinCollectionScanner : IJellyfinCollectionScanner
            }

            // remove missing collections (and remove any lingering tags from those collections)
-            foreach (JellyfinCollection collection in existingCollections
-                         .Filter(e => incomingCollections.All(i => i.ItemId != e.ItemId)))
+            foreach (JellyfinCollection collection in existingCollections.Filter(
+                         e => !incomingItemIds.Contains(e.ItemId)))
            {
                await _jellyfinCollectionRepository.RemoveCollection(collection);
            }
        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to get collections from Jellyfin");
+            return BaseError.New(ex.Message);
+        }

        return Unit.Default;
    }
@@ -91,32 +93,35 @@ public class JellyfinCollectionScanner : IJellyfinCollectionScanner
        int mediaSourceId,
        JellyfinCollection collection)
    {
-        // get collection items from JF
-        Either<BaseError, List<MediaItem>> maybeItems =
-            await _jellyfinApiClient.GetCollectionItems(address, apiKey, mediaSourceId, collection.ItemId);
-
-        foreach (BaseError error in maybeItems.LeftToSeq())
+        try
        {
-            _logger.LogWarning("Failed to get collection items from Jellyfin: {Error}", error.ToString());
-            return;
+            // get collection items from JF
+            IAsyncEnumerable<MediaItem> items = _jellyfinApiClient.GetCollectionItems(
+                address,
+                apiKey,
+                mediaSourceId,
+                collection.ItemId);
+
+            List<int> removedIds = await _jellyfinCollectionRepository.RemoveAllTags(collection);
+
+            // sync tags on items
+            var addedIds = new List<int>();
+            await foreach (MediaItem item in items)
+            {
+                addedIds.Add(await _jellyfinCollectionRepository.AddTag(item, collection));
+            }
+
+            _logger.LogDebug("Jellyfin collection {Name} contains {Count} items", collection.Name, addedIds.Count);
+
+            var changedIds = removedIds.Except(addedIds).ToList();
+            changedIds.AddRange(addedIds.Except(removedIds));
+
+            await _searchIndex.RebuildItems(_searchRepository, changedIds);
+            _searchIndex.Commit();
        }
-
-        List<int> removedIds = await _jellyfinCollectionRepository.RemoveAllTags(collection);
-
-        var jellyfinItems = maybeItems.RightToSeq().Flatten().ToList();
-        _logger.LogDebug("Jellyfin collection {Name} contains {Count} items", collection.Name, jellyfinItems.Count);
-
-        // sync tags on items
-        var addedIds = new List<int>();
-        foreach (MediaItem item in jellyfinItems)
+        catch (Exception ex)
        {
-            addedIds.Add(await _jellyfinCollectionRepository.AddTag(item, collection));
+            _logger.LogWarning(ex, "Failed to synchronize Jellyfin collection {Name}", collection.Name);
        }
-
-        var changedIds = removedIds.Except(addedIds).ToList();
-        changedIds.AddRange(addedIds.Except(removedIds));
-
-        await _searchIndex.RebuildItems(_searchRepository, changedIds);
-        _searchIndex.Commit();
    }
 }
--- a/ErsatzTV.Core/Jellyfin/JellyfinItemType.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinItemType.cs
@@ -0,0 +1,11 @@
+namespace ErsatzTV.Core.Jellyfin;
+
+public static class JellyfinItemType
+{
+    public static readonly string Movie = "Movie";
+    public static readonly string Show = "Series";
+    public static readonly string Season = "Season";
+    public static readonly string Episode = "Episode";
+    public static readonly string Collection = "BoxSet";
+    public static readonly string CollectionItems = "Movie,Series,Season,Episode";
+}
--- a/ErsatzTV.Core/Jellyfin/JellyfinMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinMovieLibraryScanner.cs
@@ -80,7 +80,18 @@ public class JellyfinMovieLibraryScanner :

    protected override string MediaServerEtag(JellyfinMovie movie) => movie.Etag;

-    protected override Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
+    protected override Task<Either<BaseError, int>> CountMovieLibraryItems(
+        JellyfinConnectionParameters connectionParameters,
+        JellyfinLibrary library) =>
+        _jellyfinApiClient.GetLibraryItemCount(
+            connectionParameters.Address,
+            connectionParameters.ApiKey,
+            library,
+            library.ItemId,
+            JellyfinItemType.Movie,
+            true);
+
+    protected override IAsyncEnumerable<JellyfinMovie> GetMovieLibraryItems(
        JellyfinConnectionParameters connectionParameters,
        JellyfinLibrary library) =>
        _jellyfinApiClient.GetMovieLibraryItems(
--- a/ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs
@@ -77,14 +77,21 @@ public class JellyfinTelevisionLibraryScanner : MediaServerTelevisionLibraryScan
            cancellationToken);
    }

-    protected override Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
+    protected override Task<Either<BaseError, int>> CountShowLibraryItems(
        JellyfinConnectionParameters connectionParameters,
-        JellyfinLibrary library) =>
-        _jellyfinApiClient.GetShowLibraryItems(
+        JellyfinLibrary library)
+        => _jellyfinApiClient.GetLibraryItemCount(
            connectionParameters.Address,
            connectionParameters.ApiKey,
-            library.MediaSourceId,
-            library.ItemId);
+            library,
+            library.ItemId,
+            JellyfinItemType.Show,
+            false);
+
+    protected override IAsyncEnumerable<JellyfinShow> GetShowLibraryItems(
+        JellyfinConnectionParameters connectionParameters,
+        JellyfinLibrary library) =>
+        _jellyfinApiClient.GetShowLibraryItems(connectionParameters.Address, connectionParameters.ApiKey, library);

    protected override string MediaServerItemId(JellyfinShow show) => show.ItemId;
    protected override string MediaServerItemId(JellyfinSeason season) => season.ItemId;
@@ -94,19 +101,44 @@ public class JellyfinTelevisionLibraryScanner : MediaServerTelevisionLibraryScan
    protected override string MediaServerEtag(JellyfinSeason season) => season.Etag;
    protected override string MediaServerEtag(JellyfinEpisode episode) => episode.Etag;

-    protected override Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
+    protected override Task<Either<BaseError, int>> CountSeasonLibraryItems(
+        JellyfinConnectionParameters connectionParameters,
+        JellyfinLibrary library,
+        JellyfinShow show) =>
+        _jellyfinApiClient.GetLibraryItemCount(
+            connectionParameters.Address,
+            connectionParameters.ApiKey,
+            library,
+            show.ItemId,
+            JellyfinItemType.Season,
+            false);
+
+    protected override IAsyncEnumerable<JellyfinSeason> GetSeasonLibraryItems(
        JellyfinLibrary library,
        JellyfinConnectionParameters connectionParameters,
        JellyfinShow show) =>
        _jellyfinApiClient.GetSeasonLibraryItems(
            connectionParameters.Address,
            connectionParameters.ApiKey,
-            library.MediaSourceId,
+            library,
            show.ItemId);

-    protected override Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
+    protected override Task<Either<BaseError, int>> CountEpisodeLibraryItems(
+        JellyfinConnectionParameters connectionParameters,
+        JellyfinLibrary library,
+        JellyfinSeason season) =>
+        _jellyfinApiClient.GetLibraryItemCount(
+            connectionParameters.Address,
+            connectionParameters.ApiKey,
+            library,
+            season.ItemId,
+            JellyfinItemType.Episode,
+            true);
+
+    protected override IAsyncEnumerable<JellyfinEpisode> GetEpisodeLibraryItems(
        JellyfinLibrary library,
        JellyfinConnectionParameters connectionParameters,
+        JellyfinShow _,
        JellyfinSeason season) =>
        _jellyfinApiClient.GetEpisodeLibraryItems(
            connectionParameters.Address,
--- a/ErsatzTV.Core/Metadata/MediaServerMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Metadata/MediaServerMovieLibraryScanner.cs
@@ -53,23 +53,29 @@ public abstract class MediaServerMovieLibraryScanner<TConnectionParameters, TLib
    {
        try
        {
-            Either<BaseError, List<TMovie>> entries = await GetMovieLibraryItems(connectionParameters, library);
-
-            foreach (BaseError error in entries.LeftToSeq())
+            Either<BaseError, int> maybeCount = await CountMovieLibraryItems(connectionParameters, library);
+            foreach (BaseError error in maybeCount.LeftToSeq())
            {
                return error;
            }

-            return await ScanLibrary(
-                movieRepository,
-                connectionParameters,
-                library,
-                getLocalPath,
-                ffmpegPath,
-                ffprobePath,
-                entries.RightToSeq().Flatten().ToList(),
-                deepScan,
-                cancellationToken);
+            foreach (int count in maybeCount.RightToSeq())
+            {
+                return await ScanLibrary(
+                    movieRepository,
+                    connectionParameters,
+                    library,
+                    getLocalPath,
+                    ffmpegPath,
+                    ffprobePath,
+                    GetMovieLibraryItems(connectionParameters, library),
+                    count,
+                    deepScan,
+                    cancellationToken);
+            }
+
+            // this won't happen
+            return Unit.Default;
        }
        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
        {
@@ -88,21 +94,24 @@ public abstract class MediaServerMovieLibraryScanner<TConnectionParameters, TLib
        Func<TMovie, string> getLocalPath,
        string ffmpegPath,
        string ffprobePath,
-        List<TMovie> movieEntries,
+        IAsyncEnumerable<TMovie> movieEntries,
+        int totalMovieCount,
        bool deepScan,
        CancellationToken cancellationToken)
    {
+        var incomingItemIds = new List<string>();
        List<TEtag> existingMovies = await movieRepository.GetExistingMovies(library);

-        var sortedMovies = movieEntries.OrderBy(m => m.MovieMetadata.Head().SortTitle).ToList();
-        foreach (TMovie incoming in sortedMovies)
+        await foreach (TMovie incoming in movieEntries.WithCancellation(cancellationToken))
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return new ScanCanceled();
            }

-            decimal percentCompletion = (decimal)sortedMovies.IndexOf(incoming) / sortedMovies.Count;
+            incomingItemIds.Add(MediaServerItemId(incoming));
+
+            decimal percentCompletion = Math.Clamp((decimal)incomingItemIds.Count / totalMovieCount, 0, 1);
            await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion), cancellationToken);

            string localPath = getLocalPath(incoming);
@@ -165,8 +174,7 @@ public abstract class MediaServerMovieLibraryScanner<TConnectionParameters, TLib
        }

        // trash movies that are no longer present on the media server
-        var fileNotFoundItemIds = existingMovies.Map(m => m.MediaServerItemId)
-            .Except(movieEntries.Map(MediaServerItemId)).ToList();
+        var fileNotFoundItemIds = existingMovies.Map(m => m.MediaServerItemId).Except(incomingItemIds).ToList();
        List<int> ids = await movieRepository.FlagFileNotFound(library, fileNotFoundItemIds);
        await _searchIndex.RebuildItems(_searchRepository, ids);

@@ -178,7 +186,11 @@ public abstract class MediaServerMovieLibraryScanner<TConnectionParameters, TLib
    protected abstract string MediaServerItemId(TMovie movie);
    protected abstract string MediaServerEtag(TMovie movie);

-    protected abstract Task<Either<BaseError, List<TMovie>>> GetMovieLibraryItems(
+    protected abstract Task<Either<BaseError, int>> CountMovieLibraryItems(
+        TConnectionParameters connectionParameters,
+        TLibrary library);
+
+    protected abstract IAsyncEnumerable<TMovie> GetMovieLibraryItems(
        TConnectionParameters connectionParameters,
        TLibrary library);

--- a/ErsatzTV.Core/Metadata/MediaServerTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Metadata/MediaServerTelevisionLibraryScanner.cs
@@ -56,23 +56,31 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
    {
        try
        {
-            Either<BaseError, List<TShow>> entries = await GetShowLibraryItems(connectionParameters, library);
-
-            foreach (BaseError error in entries.LeftToSeq())
+            Either<BaseError, int> maybeCount = await CountShowLibraryItems(connectionParameters, library);
+            foreach (BaseError error in maybeCount.LeftToSeq())
            {
                return error;
            }

-            return await ScanLibrary(
-                televisionRepository,
-                connectionParameters,
-                library,
-                getLocalPath,
-                ffmpegPath,
-                ffprobePath,
-                entries.RightToSeq().Flatten().ToList(),
-                deepScan,
-                cancellationToken);
+            foreach (int count in maybeCount.RightToSeq())
+            {
+                _logger.LogDebug("Library {Library} contains {Count} shows", library.Name, count);
+
+                return await ScanLibrary(
+                    televisionRepository,
+                    connectionParameters,
+                    library,
+                    getLocalPath,
+                    ffmpegPath,
+                    ffprobePath,
+                    GetShowLibraryItems(connectionParameters, library),
+                    count,
+                    deepScan,
+                    cancellationToken);
+            }
+
+            // this won't happen
+            return Unit.Default;
        }
        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
        {
@@ -84,7 +92,11 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        }
    }

-    protected abstract Task<Either<BaseError, List<TShow>>> GetShowLibraryItems(
+    protected abstract Task<Either<BaseError, int>> CountShowLibraryItems(
+        TConnectionParameters connectionParameters,
+        TLibrary library);
+
+    protected abstract IAsyncEnumerable<TShow> GetShowLibraryItems(
        TConnectionParameters connectionParameters,
        TLibrary library);

@@ -102,21 +114,24 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        Func<TEpisode, string> getLocalPath,
        string ffmpegPath,
        string ffprobePath,
-        List<TShow> showEntries,
+        IAsyncEnumerable<TShow> showEntries,
+        int totalShowCount,
        bool deepScan,
        CancellationToken cancellationToken)
    {
+        var incomingItemIds = new List<string>();
        List<TEtag> existingShows = await televisionRepository.GetExistingShows(library);

-        var sortedShows = showEntries.OrderBy(s => s.ShowMetadata.Head().SortTitle).ToList();
-        foreach (TShow incoming in showEntries)
+        await foreach (TShow incoming in showEntries.WithCancellation(cancellationToken))
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return new ScanCanceled();
            }

-            decimal percentCompletion = (decimal)sortedShows.IndexOf(incoming) / sortedShows.Count;
+            incomingItemIds.Add(MediaServerItemId(incoming));
+
+            decimal percentCompletion = Math.Clamp((decimal)incomingItemIds.Count / totalShowCount, 0, 1);
            await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion), cancellationToken);

            Either<BaseError, MediaItemScanResult<TShow>> maybeShow = await televisionRepository
@@ -138,16 +153,23 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,

            foreach (MediaItemScanResult<TShow> result in maybeShow.RightToSeq())
            {
-                Either<BaseError, List<TSeason>> entries = await GetSeasonLibraryItems(
-                    library,
+                Either<BaseError, int> maybeCount = await CountSeasonLibraryItems(
                    connectionParameters,
+                    library,
                    result.Item);
-
-                foreach (BaseError error in entries.LeftToSeq())
+                foreach (BaseError error in maybeCount.LeftToSeq())
                {
                    return error;
                }

+                foreach (int count in maybeCount.RightToSeq())
+                {
+                    _logger.LogDebug(
+                        "Show {Title} contains {Count} seasons",
+                        result.Item.ShowMetadata.Head().Title,
+                        count);
+                }
+
                Either<BaseError, Unit> scanResult = await ScanSeasons(
                    televisionRepository,
                    library,
@@ -156,7 +178,7 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
                    connectionParameters,
                    ffmpegPath,
                    ffprobePath,
-                    entries.RightToSeq().Flatten().ToList(),
+                    GetSeasonLibraryItems(library, connectionParameters, result.Item),
                    deepScan,
                    cancellationToken);

@@ -175,8 +197,7 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        }

        // trash shows that are no longer present on the media server
-        var fileNotFoundItemIds = existingShows.Map(s => s.MediaServerItemId)
-            .Except(showEntries.Map(MediaServerItemId)).ToList();
+        var fileNotFoundItemIds = existingShows.Map(s => s.MediaServerItemId).Except(incomingItemIds).ToList();
        List<int> ids = await televisionRepository.FlagFileNotFoundShows(library, fileNotFoundItemIds);
        await _searchIndex.RebuildItems(_searchRepository, ids);

@@ -185,14 +206,25 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        return Unit.Default;
    }

-    protected abstract Task<Either<BaseError, List<TSeason>>> GetSeasonLibraryItems(
+    protected abstract Task<Either<BaseError, int>> CountSeasonLibraryItems(
+        TConnectionParameters connectionParameters,
+        TLibrary library,
+        TShow show);
+
+    protected abstract IAsyncEnumerable<TSeason> GetSeasonLibraryItems(
        TLibrary library,
        TConnectionParameters connectionParameters,
        TShow show);

-    protected abstract Task<Either<BaseError, List<TEpisode>>> GetEpisodeLibraryItems(
+    protected abstract Task<Either<BaseError, int>> CountEpisodeLibraryItems(
+        TConnectionParameters connectionParameters,
+        TLibrary library,
+        TSeason season);
+
+    protected abstract IAsyncEnumerable<TEpisode> GetEpisodeLibraryItems(
        TLibrary library,
        TConnectionParameters connectionParameters,
+        TShow show,
        TSeason season);

    protected abstract Task<Option<ShowMetadata>> GetFullMetadata(
@@ -236,14 +268,14 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        TConnectionParameters connectionParameters,
        string ffmpegPath,
        string ffprobePath,
-        List<TSeason> seasonEntries,
+        IAsyncEnumerable<TSeason> seasonEntries,
        bool deepScan,
        CancellationToken cancellationToken)
    {
+        var incomingItemIds = new List<string>();
        List<TEtag> existingSeasons = await televisionRepository.GetExistingSeasons(library, show);

-        var sortedSeasons = seasonEntries.OrderBy(s => s.SeasonNumber).ToList();
-        foreach (TSeason incoming in sortedSeasons)
+        await foreach (TSeason incoming in seasonEntries.WithCancellation(cancellationToken))
        {
            incoming.ShowId = show.Id;

@@ -252,6 +284,8 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
                return new ScanCanceled();
            }

+            incomingItemIds.Add(MediaServerItemId(incoming));
+
            Either<BaseError, MediaItemScanResult<TSeason>> maybeSeason = await televisionRepository
                .GetOrAdd(library, incoming)
                .BindT(existing => UpdateMetadata(connectionParameters, library, existing, incoming, deepScan));
@@ -272,16 +306,24 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,

            foreach (MediaItemScanResult<TSeason> result in maybeSeason.RightToSeq())
            {
-                Either<BaseError, List<TEpisode>> entries = await GetEpisodeLibraryItems(
-                    library,
+                Either<BaseError, int> maybeCount = await CountEpisodeLibraryItems(
                    connectionParameters,
+                    library,
                    result.Item);
-
-                foreach (BaseError error in entries.LeftToSeq())
+                foreach (BaseError error in maybeCount.LeftToSeq())
                {
                    return error;
                }

+                foreach (int count in maybeCount.RightToSeq())
+                {
+                    _logger.LogDebug(
+                        "Show {Title} season {Season} contains {Count} episodes",
+                        show.ShowMetadata.Head().Title,
+                        result.Item.SeasonNumber,
+                        count);
+                }
+
                Either<BaseError, Unit> scanResult = await ScanEpisodes(
                    televisionRepository,
                    library,
@@ -291,7 +333,7 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
                    connectionParameters,
                    ffmpegPath,
                    ffprobePath,
-                    entries.RightToSeq().Flatten().ToList(),
+                    GetEpisodeLibraryItems(library, connectionParameters, show, result.Item),
                    deepScan,
                    cancellationToken);

@@ -312,8 +354,7 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        }

        // trash seasons that are no longer present on the media server
-        var fileNotFoundItemIds = existingSeasons.Map(s => s.MediaServerItemId)
-            .Except(seasonEntries.Map(MediaServerItemId)).ToList();
+        var fileNotFoundItemIds = existingSeasons.Map(s => s.MediaServerItemId).Except(incomingItemIds).ToList();
        List<int> ids = await televisionRepository.FlagFileNotFoundSeasons(library, fileNotFoundItemIds);
        await _searchIndex.RebuildItems(_searchRepository, ids);

@@ -329,20 +370,22 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        TConnectionParameters connectionParameters,
        string ffmpegPath,
        string ffprobePath,
-        List<TEpisode> episodeEntries,
+        IAsyncEnumerable<TEpisode> episodeEntries,
        bool deepScan,
        CancellationToken cancellationToken)
    {
+        var incomingItemIds = new List<string>();
        List<TEtag> existingEpisodes = await televisionRepository.GetExistingEpisodes(library, season);

-        var sortedEpisodes = episodeEntries.OrderBy(s => s.EpisodeMetadata.Head().EpisodeNumber).ToList();
-        foreach (TEpisode incoming in sortedEpisodes)
+        await foreach (TEpisode incoming in episodeEntries.WithCancellation(cancellationToken))
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return new ScanCanceled();
            }

+            incomingItemIds.Add(MediaServerItemId(incoming));
+
            string localPath = getLocalPath(incoming);
            if (await ShouldScanItem(
                    televisionRepository,
@@ -414,8 +457,7 @@ public abstract class MediaServerTelevisionLibraryScanner<TConnectionParameters,
        }

        // trash episodes that are no longer present on the media server
-        var fileNotFoundItemIds = existingEpisodes.Map(m => m.MediaServerItemId)
-            .Except(episodeEntries.Map(MediaServerItemId)).ToList();
+        var fileNotFoundItemIds = existingEpisodes.Map(m => m.MediaServerItemId).Except(incomingItemIds).ToList();
        List<int> ids = await televisionRepository.FlagFileNotFoundEpisodes(library, fileNotFoundItemIds);
        await _searchIndex.RebuildItems(_searchRepository, ids);

--- a/ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs
@@ -89,7 +89,15 @@ public class PlexMovieLibraryScanner :

    protected override string MediaServerEtag(PlexMovie movie) => movie.Etag;

-    protected override Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryItems(
+    protected override Task<Either<BaseError, int>> CountMovieLibraryItems(
+        PlexConnectionParameters connectionParameters,
+        PlexLibrary library)
+        => _plexServerApiClient.GetLibraryItemCount(
+            library,
+            connectionParameters.Connection,
+            connectionParameters.Token);
+
+    protected override IAsyncEnumerable<PlexMovie> GetMovieLibraryItems(
        PlexConnectionParameters connectionParameters,
        PlexLibrary library) =>
        _plexServerApiClient.GetMovieLibraryContents(
--- a/ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs
@@ -137,7 +137,15 @@ public class PlexTelevisionLibraryScanner :
    //     }
    // }

-    protected override Task<Either<BaseError, List<PlexShow>>> GetShowLibraryItems(
+    protected override Task<Either<BaseError, int>> CountShowLibraryItems(
+        PlexConnectionParameters connectionParameters,
+        PlexLibrary library) =>
+        _plexServerApiClient.GetLibraryItemCount(
+            library,
+            connectionParameters.Connection,
+            connectionParameters.Token);
+
+    protected override IAsyncEnumerable<PlexShow> GetShowLibraryItems(
        PlexConnectionParameters connectionParameters,
        PlexLibrary library) =>
        _plexServerApiClient.GetShowLibraryContents(
@@ -145,7 +153,16 @@ public class PlexTelevisionLibraryScanner :
            connectionParameters.Connection,
            connectionParameters.Token);

-    protected override Task<Either<BaseError, List<PlexSeason>>> GetSeasonLibraryItems(
+    protected override Task<Either<BaseError, int>> CountSeasonLibraryItems(
+        PlexConnectionParameters connectionParameters,
+        PlexLibrary library,
+        PlexShow show) =>
+        _plexServerApiClient.CountShowSeasons(
+            show,
+            connectionParameters.Connection,
+            connectionParameters.Token);
+
+    protected override IAsyncEnumerable<PlexSeason> GetSeasonLibraryItems(
        PlexLibrary library,
        PlexConnectionParameters connectionParameters,
        PlexShow show) =>
@@ -155,9 +172,19 @@ public class PlexTelevisionLibraryScanner :
            connectionParameters.Connection,
            connectionParameters.Token);

-    protected override Task<Either<BaseError, List<PlexEpisode>>> GetEpisodeLibraryItems(
+    protected override Task<Either<BaseError, int>> CountEpisodeLibraryItems(
+        PlexConnectionParameters connectionParameters,
+        PlexLibrary library,
+        PlexSeason season) =>
+        _plexServerApiClient.CountSeasonEpisodes(
+            season,
+            connectionParameters.Connection,
+            connectionParameters.Token);
+
+    protected override IAsyncEnumerable<PlexEpisode> GetEpisodeLibraryItems(
        PlexLibrary library,
        PlexConnectionParameters connectionParameters,
+        PlexShow _,
        PlexSeason season) =>
        _plexServerApiClient.GetSeasonEpisodes(
            library,
--- a/ErsatzTV.FFmpeg.Tests/ErsatzTV.FFmpeg.Tests.csproj
+++ b/ErsatzTV.FFmpeg.Tests/ErsatzTV.FFmpeg.Tests.csproj
@@ -8,7 +8,7 @@
    </PropertyGroup>

    <ItemGroup>
-        <PackageReference Include="FluentAssertions" Version="6.6.0" />
+        <PackageReference Include="FluentAssertions" Version="6.7.0" />
        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
        <PackageReference Include="Moq" Version="4.18.1" />
        <PackageReference Include="NUnit" Version="3.13.3" />
--- a/ErsatzTV.FFmpeg.Tests/Filter/WatermarkOpacityFilterTests.cs
+++ b/ErsatzTV.FFmpeg.Tests/Filter/WatermarkOpacityFilterTests.cs
@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using ErsatzTV.FFmpeg.Filter;
+using ErsatzTV.FFmpeg.State;
+using FluentAssertions;
+using LanguageExt;
+using NUnit.Framework;
+
+namespace ErsatzTV.FFmpeg.Tests.Filter;
+
+[TestFixture]
+public class WatermarkOpacityFilterTests
+{
+    [Test]
+    // this needs to be a culture where ',' is a decimal separator
+    [SetCulture("it-IT")]
+    public void Should_Return_Filter_With_Period_Decimal_Unlike_Local_Culture()
+    {
+        var filter = new WatermarkOpacityFilter(
+            new WatermarkState(
+                Option<List<WatermarkFadePoint>>.None,
+                WatermarkLocation.BottomRight,
+                WatermarkSize.ActualSize,
+                50,
+                50,
+                50,
+                75));
+
+        filter.Filter.Should().Be("colorchannelmixer=aa=0.75");
+    }
+
+    [Test]
+    [SetCulture("en-US")]
+    public void Should_Return_Filter_With_Period_Decimal()
+    {
+        var filter = new WatermarkOpacityFilter(
+            new WatermarkState(
+                Option<List<WatermarkFadePoint>>.None,
+                WatermarkLocation.BottomRight,
+                WatermarkSize.ActualSize,
+                50,
+                50,
+                50,
+                75));
+
+        filter.Filter.Should().Be("colorchannelmixer=aa=0.75");
+    }
+}
--- a/ErsatzTV.FFmpeg.Tests/PipelineBuilderTests.cs
+++ b/ErsatzTV.FFmpeg.Tests/PipelineBuilderTests.cs
@@ -75,7 +75,8 @@ public class PipelineGeneratorTests
        result.PipelineSteps.Should().Contain(ps => ps is EncoderLibx265);

        string command = PrintCommand(videoInputFile, audioInputFile, None, None, result);
-        command.Should().Be("-threads 1 -nostdin -hide_banner -nostats -loglevel error -fflags +genpts+discardcorrupt+igndts -ss 00:00:01 -c:v h264 -re -i /tmp/whatever.mkv -map 0:1 -map 0:0 -muxdelay 0 -muxpreload 0 -movflags +faststart -flags cgop -sc_threshold 0 -video_track_timescale 90000 -b:v 2000k -maxrate:v 2000k -bufsize:v 4000k -c:a aac -ac 2 -b:a 320k -maxrate:a 320k -bufsize:a 640k -ar 48k -c:v libx265 -tag:v hvc1 -x265-params log-level=error -f mpegts -mpegts_flags +initial_discontinuity pipe:1");
+        command.Should().Be(
+            "-threads 1 -nostdin -hide_banner -nostats -loglevel error -fflags +genpts+discardcorrupt+igndts -ss 00:00:01 -c:v h264 -re -i /tmp/whatever.mkv -map 0:1 -map 0:0 -muxdelay 0 -muxpreload 0 -movflags +faststart -flags cgop -sc_threshold 0 -video_track_timescale 90000 -b:v 2000k -maxrate:v 2000k -bufsize:v 4000k -c:a aac -ac 2 -b:a 320k -maxrate:a 320k -bufsize:a 640k -ar 48k -c:v libx265 -tag:v hvc1 -x265-params log-level=error -f mpegts -mpegts_flags +initial_discontinuity pipe:1");
    }

    [Test]
--- a/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderH264Qsv.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderH264Qsv.cs
@@ -20,6 +20,7 @@ public class EncoderH264Qsv : EncoderBase

    public override string Name => "h264_qsv";
    public override StreamKind Kind => StreamKind.Video;
+    public override IList<string> OutputOptions => new[] { "-c:v", "h264_qsv", "-low_power", "0" };

    // need to upload if we're still in software and a watermark is used
    public override string Filter
@@ -36,11 +37,11 @@ public class EncoderH264Qsv : EncoderBase
                    // pixel format should already be converted to a supported format by QsvHardwareAccelerationOption
                    foreach (IPixelFormat pixelFormat in _currentState.PixelFormat)
                    {
-                        return $"format={pixelFormat.FFmpegName},hwupload=extra_hw_frames=128";
+                        return $"format={pixelFormat.FFmpegName},hwupload=extra_hw_frames=64";
                    }

                    // default to nv12
-                    return "format=nv12,hwupload=extra_hw_frames=128";
+                    return "format=nv12,hwupload=extra_hw_frames=64";
                }
            }

--- a/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderHevcQsv.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderHevcQsv.cs
@@ -20,6 +20,7 @@ public class EncoderHevcQsv : EncoderBase

    public override string Name => "hevc_qsv";
    public override StreamKind Kind => StreamKind.Video;
+    public override IList<string> OutputOptions => new[] { "-c:v", "hevc_qsv", "-low_power", "0" };

    // need to upload if we're still in software and a watermark is used
    public override string Filter
@@ -36,11 +37,11 @@ public class EncoderHevcQsv : EncoderBase
                    // pixel format should already be converted to a supported format by QsvHardwareAccelerationOption
                    foreach (IPixelFormat pixelFormat in _currentState.PixelFormat)
                    {
-                        return $"format={pixelFormat.FFmpegName},hwupload=extra_hw_frames=128";
+                        return $"format={pixelFormat.FFmpegName},hwupload=extra_hw_frames=64";
                    }

                    // default to nv12
-                    return "format=nv12,hwupload=extra_hw_frames=128";
+                    return "format=nv12,hwupload=extra_hw_frames=64";
                }
            }

--- a/ErsatzTV.FFmpeg/ErsatzTV.FFmpeg.csproj
+++ b/ErsatzTV.FFmpeg/ErsatzTV.FFmpeg.csproj
@@ -8,7 +8,7 @@

    <ItemGroup>
      <PackageReference Include="CliWrap" Version="3.4.4" />
-      <PackageReference Include="LanguageExt.Core" Version="4.1.0" />
+      <PackageReference Include="LanguageExt.Core" Version="4.1.1" />
      <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.1" />
    </ItemGroup>

--- a/ErsatzTV.FFmpeg/Filter/HardwareUploadFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/HardwareUploadFilter.cs
@@ -10,7 +10,7 @@ public class HardwareUploadFilter : BaseFilter
    {
        HardwareAccelerationMode.None => string.Empty,
        HardwareAccelerationMode.Nvenc => "hwupload_cuda",
-        HardwareAccelerationMode.Qsv => "hwupload=extra_hw_frames=128",
+        HardwareAccelerationMode.Qsv => "hwupload=extra_hw_frames=64",
        HardwareAccelerationMode.Vaapi => "format=nv12|vaapi,hwupload",
        _ => "hwupload"
    };
--- a/ErsatzTV.FFmpeg/Filter/Qsv/DeinterlaceQsvFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/Qsv/DeinterlaceQsvFilter.cs
@@ -10,7 +10,7 @@ public class DeinterlaceQsvFilter : BaseFilter

    // deinterlace_qsv seems to only support nv12, not p010le
    public override string Filter => _currentState.FrameDataLocation == FrameDataLocation.Software
-        ? "format=nv12,hwupload=extra_hw_frames=128,deinterlace_qsv"
+        ? "format=nv12,hwupload=extra_hw_frames=64,deinterlace_qsv"
        : "deinterlace_qsv";

    public override FrameState NextState(FrameState currentState)
--- a/ErsatzTV.FFmpeg/Filter/Qsv/ScaleQsvFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/Qsv/ScaleQsvFilter.cs
@@ -49,10 +49,10 @@ public class ScaleQsvFilter : BaseFilter
            string initialPixelFormat = _currentState.PixelFormat.Match(pf => pf.FFmpegName, FFmpegFormat.NV12);
            if (!string.IsNullOrWhiteSpace(scale))
            {
-                return $"format={initialPixelFormat},hwupload=extra_hw_frames=128,{scale}";
+                return $"format={initialPixelFormat},hwupload=extra_hw_frames=64,{scale}";
            }

-            return $"format={initialPixelFormat},hwupload=extra_hw_frames=128";
+            return $"format={initialPixelFormat},hwupload=extra_hw_frames=64";
        }
    }

--- a/ErsatzTV.FFmpeg/Filter/SubtitleHardwareUploadFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/SubtitleHardwareUploadFilter.cs
@@ -16,7 +16,7 @@ public class SubtitleHardwareUploadFilter : BaseFilter
        {
            HardwareAccelerationMode.None => string.Empty,
            HardwareAccelerationMode.Nvenc => "hwupload_cuda",
-            HardwareAccelerationMode.Qsv => "hwupload=extra_hw_frames=128",
+            HardwareAccelerationMode.Qsv => "hwupload=extra_hw_frames=64",

            // leave vaapi in software since we don't (yet) use overlay_vaapi
            HardwareAccelerationMode.Vaapi when _currentState.FrameDataLocation == FrameDataLocation.Software =>
--- a/ErsatzTV.FFmpeg/Filter/WatermarkHardwareUploadFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/WatermarkHardwareUploadFilter.cs
@@ -15,7 +15,7 @@ public class WatermarkHardwareUploadFilter : BaseFilter
    {
        HardwareAccelerationMode.None => string.Empty,
        HardwareAccelerationMode.Nvenc => "hwupload_cuda",
-        HardwareAccelerationMode.Qsv => "hwupload=extra_hw_frames=128",
+        HardwareAccelerationMode.Qsv => "hwupload=extra_hw_frames=64",

        // leave vaapi in software since we don't (yet) use overlay_vaapi
        HardwareAccelerationMode.Vaapi when _currentState.FrameDataLocation == FrameDataLocation.Software =>
--- a/ErsatzTV.FFmpeg/Filter/WatermarkOpacityFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/WatermarkOpacityFilter.cs
@@ -1,4 +1,5 @@
-using ErsatzTV.FFmpeg.State;
+using System.Globalization;
+using ErsatzTV.FFmpeg.State;

 namespace ErsatzTV.FFmpeg.Filter;

@@ -13,7 +14,7 @@ public class WatermarkOpacityFilter : BaseFilter
        get
        {
            double opacity = _desiredState.Opacity / 100.0;
-            return $"colorchannelmixer=aa={opacity:F2}";
+            return $"colorchannelmixer=aa={opacity.ToString("F2", NumberFormatInfo.InvariantInfo)}";
        }
    }

--- a/ErsatzTV.Infrastructure/AsyncEnumerable.cs
+++ b/ErsatzTV.Infrastructure/AsyncEnumerable.cs
@@ -0,0 +1,26 @@
+namespace ErsatzTV.Infrastructure;
+
+public static class AsyncEnumerable
+{
+    /// <summary>
+    ///     Creates an <see cref="IAsyncEnumerable{T}" /> which yields no results, similar to
+    ///     <see cref="Enumerable.Empty{TResult}" />.
+    /// </summary>
+    public static IAsyncEnumerable<T> Empty<T>() => EmptyAsyncEnumerator<T>.Instance;
+
+    private class EmptyAsyncEnumerator<T> : IAsyncEnumerator<T>, IAsyncEnumerable<T>
+    {
+        public static readonly EmptyAsyncEnumerator<T> Instance = new();
+
+        public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return this;
+        }
+
+        public T Current => default;
+        public ValueTask DisposeAsync() => default;
+
+        public ValueTask<bool> MoveNextAsync() => new(false);
+    }
+}
--- a/ErsatzTV.Infrastructure/Emby/EmbyApiClient.cs
+++ b/ErsatzTV.Infrastructure/Emby/EmbyApiClient.cs
@@ -71,137 +71,163 @@ public class EmbyApiClient : IEmbyApiClient
        }
    }

-    public async Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
-        string address,
-        string apiKey,
-        EmbyLibrary library)
-    {
-        try
-        {
-            IEmbyApi service = RestService.For<IEmbyApi>(address);
-            EmbyLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, library.ItemId);
-            return items.Items
-                .Map(i => ProjectToMovie(library, i))
-                .Somes()
-                .ToList();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting emby movie library items");
-            return BaseError.New(ex.Message);
-        }
-    }
+    public IAsyncEnumerable<EmbyMovie> GetMovieLibraryItems(string address, string apiKey, EmbyLibrary library)
+        => GetPagedLibraryContents(
+            address,
+            apiKey,
+            library,
+            library.ItemId,
+            EmbyItemType.Movie,
+            (service, itemId, skip, pageSize) => service.GetMovieLibraryItems(
+                apiKey,
+                itemId,
+                startIndex: skip,
+                limit: pageSize),
+            (maybeLibrary, item) => maybeLibrary.Map(lib => ProjectToMovie(lib, item)).Flatten());

-    public async Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
-        string address,
-        string apiKey,
-        string libraryId)
-    {
-        try
-        {
-            IEmbyApi service = RestService.For<IEmbyApi>(address);
-            EmbyLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, libraryId);
-            return items.Items
-                .Map(ProjectToShow)
-                .Somes()
-                .ToList();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting emby show library items");
-            return BaseError.New(ex.Message);
-        }
-    }
+    public IAsyncEnumerable<EmbyShow> GetShowLibraryItems(string address, string apiKey, EmbyLibrary library)
+        => GetPagedLibraryContents(
+            address,
+            apiKey,
+            library,
+            library.ItemId,
+            EmbyItemType.Show,
+            (service, itemId, skip, pageSize) => service.GetShowLibraryItems(
+                apiKey,
+                itemId,
+                startIndex: skip,
+                limit: pageSize),
+            (_, item) => ProjectToShow(item));

-    public async Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
-        string address,
-        string apiKey,
-        string showId)
-    {
-        try
-        {
-            IEmbyApi service = RestService.For<IEmbyApi>(address);
-            EmbyLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, showId);
-            return items.Items
-                .Map(ProjectToSeason)
-                .Somes()
-                .ToList();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting emby show library items");
-            return BaseError.New(ex.Message);
-        }
-    }
-
-    public async Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
+    public IAsyncEnumerable<EmbySeason> GetSeasonLibraryItems(
        string address,
        string apiKey,
        EmbyLibrary library,
-        string seasonId)
-    {
-        try
-        {
-            IEmbyApi service = RestService.For<IEmbyApi>(address);
-            EmbyLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, seasonId);
-            return items.Items
-                .Map(i => ProjectToEpisode(library, i))
-                .Somes()
-                .ToList();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting emby episode library items");
-            return BaseError.New(ex.Message);
-        }
-    }
+        string showId) => GetPagedLibraryContents(
+        address,
+        apiKey,
+        library,
+        showId,
+        EmbyItemType.Season,
+        (service, itemId, skip, pageSize) => service.GetSeasonLibraryItems(
+            apiKey,
+            itemId,
+            startIndex: skip,
+            limit: pageSize),
+        (_, item) => ProjectToSeason(item));

-    public async Task<Either<BaseError, List<EmbyCollection>>> GetCollectionLibraryItems(string address, string apiKey)
-    {
-        try
-        {
-            // TODO: should we enumerate collection libraries here?
-
-            if (_memoryCache.TryGetValue("emby_collections_library_item_id", out string itemId))
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                EmbyLibraryItemsResponse items = await service.GetCollectionLibraryItems(apiKey, itemId);
-                return items.Items
-                    .Map(ProjectToCollection)
-                    .Somes()
-                    .ToList();
-            }
-
-            return BaseError.New("Emby collection item id is not available");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting Emby collection library items");
-            return BaseError.New(ex.Message);
-        }
-    }
-
-    public async Task<Either<BaseError, List<MediaItem>>> GetCollectionItems(
+    public IAsyncEnumerable<EmbyEpisode> GetEpisodeLibraryItems(
        string address,
        string apiKey,
-        string collectionId)
+        EmbyLibrary library,
+        string showId,
+        string seasonId) => GetPagedLibraryContents(
+        address,
+        apiKey,
+        library,
+        seasonId,
+        EmbyItemType.Episode,
+        (service, _, skip, pageSize) => service.GetEpisodeLibraryItems(
+            apiKey,
+            showId,
+            seasonId,
+            startIndex: skip,
+            limit: pageSize),
+        (maybeLibrary, item) => maybeLibrary.Map(lib => ProjectToEpisode(lib, item)).Flatten());
+
+    public IAsyncEnumerable<EmbyCollection> GetCollectionLibraryItems(string address, string apiKey)
+    {
+        // TODO: should we enumerate collection libraries here?
+
+        if (_memoryCache.TryGetValue("emby_collections_library_item_id", out string itemId))
+        {
+            return GetPagedLibraryContents(
+                address,
+                apiKey,
+                None,
+                itemId,
+                EmbyItemType.Collection,
+                (service, _, skip, pageSize) => service.GetCollectionLibraryItems(
+                    apiKey,
+                    itemId,
+                    startIndex: skip,
+                    limit: pageSize),
+                (_, item) => ProjectToCollection(item));
+        }
+
+        return AsyncEnumerable.Empty<EmbyCollection>();
+    }
+
+    public IAsyncEnumerable<MediaItem> GetCollectionItems(
+        string address,
+        string apiKey,
+        string collectionId) =>
+        GetPagedLibraryContents(
+            address,
+            apiKey,
+            None,
+            collectionId,
+            EmbyItemType.CollectionItems,
+            (service, _, skip, pageSize) => service.GetCollectionItems(
+                apiKey,
+                collectionId,
+                startIndex: skip,
+                limit: pageSize),
+            (_, item) => ProjectToCollectionMediaItem(item));
+
+    public async Task<Either<BaseError, int>> GetLibraryItemCount(
+        string address,
+        string apiKey,
+        string parentId,
+        string includeItemTypes)
    {
        try
        {
            IEmbyApi service = RestService.For<IEmbyApi>(address);
-            EmbyLibraryItemsResponse items = await service.GetCollectionItems(apiKey, collectionId);
-            return items.Items
-                .Map(ProjectToCollectionMediaItem)
-                .Somes()
-                .ToList();
+            EmbyLibraryItemsResponse items = await service.GetLibraryStats(apiKey, parentId, includeItemTypes);
+            return items.TotalRecordCount;
        }
        catch (Exception ex)
        {
-            _logger.LogError(ex, "Error getting Emby collection items");
+            _logger.LogError(ex, "Error getting Emby library item count");
            return BaseError.New(ex.Message);
        }
    }

+    private static async IAsyncEnumerable<TItem> GetPagedLibraryContents<TItem>(
+        string address,
+        string apiKey,
+        Option<EmbyLibrary> maybeLibrary,
+        string parentId,
+        string itemType,
+        Func<IEmbyApi, string, int, int, Task<EmbyLibraryItemsResponse>> getItems,
+        Func<Option<EmbyLibrary>, EmbyLibraryItemResponse, Option<TItem>> mapper)
+    {
+        IEmbyApi service = RestService.For<IEmbyApi>(address);
+        int size = await service
+            .GetLibraryStats(apiKey, parentId, itemType)
+            .Map(r => r.TotalRecordCount);
+
+        const int PAGE_SIZE = 10;
+
+        int pages = (size - 1) / PAGE_SIZE + 1;
+
+        for (var i = 0; i < pages; i++)
+        {
+            int skip = i * PAGE_SIZE;
+
+            Task<IEnumerable<TItem>> result = getItems(service, parentId, skip, PAGE_SIZE)
+                .Map(items => items.Items.Map(item => mapper(maybeLibrary, item)).Somes());
+
+#pragma warning disable VSTHRD003
+            foreach (TItem item in await result)
+#pragma warning restore VSTHRD003
+            {
+                yield return item;
+            }
+        }
+    }
+
    private Option<EmbyCollection> ProjectToCollection(EmbyLibraryItemResponse item)
    {
        try
--- a/ErsatzTV.Infrastructure/Emby/IEmbyApi.cs
+++ b/ErsatzTV.Infrastructure/Emby/IEmbyApi.cs
@@ -18,6 +18,21 @@ public interface IEmbyApi
        string apiKey);

    [Get("/Items")]
+    public Task<EmbyLibraryItemsResponse> GetLibraryStats(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string parentId,
+        [Query]
+        string includeItemTypes,
+        [Query]
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);
+
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<EmbyLibraryItemsResponse> GetMovieLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -29,9 +44,13 @@ public interface IEmbyApi
        [Query]
        string includeItemTypes = "Movie",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<EmbyLibraryItemsResponse> GetShowLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -43,40 +62,40 @@ public interface IEmbyApi
        [Query]
        string includeItemTypes = "Series",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Shows/{parentId}/Seasons?sortOrder=Ascending&sortBy=SortName")]
    public Task<EmbyLibraryItemsResponse> GetSeasonLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
-        [Query]
        string parentId,
        [Query]
        string fields = "Path,DateCreated,Etag,Taglines,ProviderIds",
        [Query]
-        string includeItemTypes = "Season",
+        int startIndex = 0,
        [Query]
-        string excludeLocationTypes = "Virtual",
-        [Query]
-        bool recursive = true);
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Shows/{showId}/Episodes?sortOrder=Ascending&sortBy=SortName")]
    public Task<EmbyLibraryItemsResponse> GetEpisodeLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
+        string showId,
        [Query]
-        string parentId,
+        string seasonId,
        [Query]
        string fields =
            "Path,DateCreated,Etag,Overview,ProductionYear,PremiereDate,MediaSources,LocationType,ProviderIds,People",
        [Query]
-        string includeItemTypes = "Episode",
+        int startIndex = 0,
        [Query]
-        string excludeLocationTypes = "Virtual",
-        [Query]
-        bool recursive = true);
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<EmbyLibraryItemsResponse> GetCollectionLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -87,9 +106,13 @@ public interface IEmbyApi
        [Query]
        string includeItemTypes = "BoxSet",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<EmbyLibraryItemsResponse> GetCollectionItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -102,5 +125,9 @@ public interface IEmbyApi
        [Query]
        string excludeLocationTypes = "Virtual",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);
 }
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemsResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemsResponse.cs
@@ -3,4 +3,5 @@
 public class EmbyLibraryItemsResponse
 {
    public List<EmbyLibraryItemResponse> Items { get; set; }
+    public int TotalRecordCount { get; set; }
 }
--- a/ErsatzTV.Infrastructure/Health/Checks/FFmpegVersionHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/FFmpegVersionHealthCheck.cs
@@ -9,6 +9,7 @@ namespace ErsatzTV.Infrastructure.Health.Checks;
 public class FFmpegVersionHealthCheck : BaseHealthCheck, IFFmpegVersionHealthCheck
 {
    private const string BundledVersion = "N-106635-g83e1a1de88";
+    private const string BundledVersionVaapi = "N-106957-g27cffd16aa";
    private readonly IConfigElementRepository _configElementRepository;

    public FFmpegVersionHealthCheck(IConfigElementRepository configElementRepository) =>
@@ -74,7 +75,7 @@ public class FFmpegVersionHealthCheck : BaseHealthCheck, IFFmpegVersionHealthChe
            return FailResult($"{app} version {version} is too old; please install 5.0!");
        }

-        if (!version.StartsWith("5.0") && version != BundledVersion)
+        if (!version.StartsWith("5.0") && version != BundledVersion && version != BundledVersionVaapi)
        {
            return WarningResult(
                $"{app} version {version} is unexpected and may have problems; please install 5.0!");
--- a/ErsatzTV.Infrastructure/Health/Checks/HardwareAccelerationHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/HardwareAccelerationHealthCheck.cs
@@ -46,6 +46,7 @@ public class HardwareAccelerationHealthCheck : BaseHealthCheck, IHardwareAcceler
            else if (version.Contains("vaapi", StringComparison.OrdinalIgnoreCase))
            {
                accelerationKinds.Add(HardwareAccelerationKind.Vaapi);
+                accelerationKinds.Add(HardwareAccelerationKind.Qsv);
            }
        }

--- a/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs
@@ -23,6 +23,25 @@ public interface IJellyfinApi
        string apiKey);

    [Get("/Items")]
+    public Task<JellyfinLibraryItemsResponse> GetLibraryStats(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string userId,
+        [Query]
+        string parentId,
+        [Query]
+        string includeItemTypes,
+        [Query]
+        bool recursive = true,
+        [Query]
+        string filters = "IsNotFolder",
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);
+
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<JellyfinLibraryItemsResponse> GetMovieLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -38,9 +57,13 @@ public interface IJellyfinApi
        [Query]
        bool recursive = true,
        [Query]
-        string filters = "IsNotFolder");
+        string filters = "IsNotFolder",
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<JellyfinLibraryItemsResponse> GetShowLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -54,9 +77,13 @@ public interface IJellyfinApi
        [Query]
        string includeItemTypes = "Series",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<JellyfinLibraryItemsResponse> GetSeasonLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -69,9 +96,13 @@ public interface IJellyfinApi
        [Query]
        string includeItemTypes = "Season",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<JellyfinLibraryItemsResponse> GetEpisodeLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -84,9 +115,13 @@ public interface IJellyfinApi
        [Query]
        string includeItemTypes = "Episode",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<JellyfinLibraryItemsResponse> GetCollectionLibraryItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -99,9 +134,13 @@ public interface IJellyfinApi
        [Query]
        string includeItemTypes = "BoxSet",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);

-    [Get("/Items")]
+    [Get("/Items?sortOrder=Ascending&sortBy=SortName")]
    public Task<JellyfinLibraryItemsResponse> GetCollectionItems(
        [Header("X-Emby-Token")]
        string apiKey,
@@ -114,5 +153,9 @@ public interface IJellyfinApi
        [Query]
        string includeItemTypes = "Movie,Series,Season,Episode",
        [Query]
-        bool recursive = true);
+        bool recursive = true,
+        [Query]
+        int startIndex = 0,
+        [Query]
+        int limit = 0);
 }
--- a/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs
@@ -91,174 +91,196 @@ public class JellyfinApiClient : IJellyfinApiClient
        }
    }

-    public async Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
+    public IAsyncEnumerable<JellyfinMovie> GetMovieLibraryItems(
        string address,
        string apiKey,
-        JellyfinLibrary library)
-    {
-        try
-        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{library.MediaSourceId}", out string userId))
-            {
-                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                JellyfinLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, userId, library.ItemId);
-                return items.Items
-                    .Map(i => ProjectToMovie(library, i))
-                    .Somes()
-                    .ToList();
-            }
+        JellyfinLibrary library) =>
+        GetPagedLibraryItems(
+            address,
+            apiKey,
+            library,
+            library.MediaSourceId,
+            library.ItemId,
+            JellyfinItemType.Movie,
+            (service, userId, itemId, skip, pageSize) => service.GetMovieLibraryItems(
+                apiKey,
+                userId,
+                itemId,
+                startIndex: skip,
+                limit: pageSize),
+            (maybeLibrary, item) => maybeLibrary.Map(lib => ProjectToMovie(lib, item)).Flatten());

-            return BaseError.New("Jellyfin admin user id is not available");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting jellyfin movie library items");
-            return BaseError.New(ex.Message);
-        }
-    }
-
-    public async Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
+    public IAsyncEnumerable<JellyfinShow> GetShowLibraryItems(
        string address,
        string apiKey,
-        int mediaSourceId,
-        string libraryId)
-    {
-        try
-        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-            {
-                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                JellyfinLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, userId, libraryId);
-                return items.Items
-                    .Map(ProjectToShow)
-                    .Somes()
-                    .ToList();
-            }
+        JellyfinLibrary library) =>
+        GetPagedLibraryItems(
+            address,
+            apiKey,
+            library,
+            library.MediaSourceId,
+            library.ItemId,
+            JellyfinItemType.Show,
+            (service, userId, itemId, skip, pageSize) => service.GetShowLibraryItems(
+                apiKey,
+                userId,
+                itemId,
+                startIndex: skip,
+                limit: pageSize),
+            (_, item) => ProjectToShow(item));

-            return BaseError.New("Jellyfin admin user id is not available");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting jellyfin show library items");
-            return BaseError.New(ex.Message);
-        }
-    }
-
-    public async Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
-        string address,
-        string apiKey,
-        int mediaSourceId,
-        string showId)
-    {
-        try
-        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-            {
-                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                JellyfinLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, userId, showId);
-                return items.Items
-                    .Map(ProjectToSeason)
-                    .Somes()
-                    .ToList();
-            }
-
-            return BaseError.New("Jellyfin admin user id is not available");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting jellyfin show library items");
-            return BaseError.New(ex.Message);
-        }
-    }
-
-    public async Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
+    public IAsyncEnumerable<JellyfinSeason> GetSeasonLibraryItems(
        string address,
        string apiKey,
        JellyfinLibrary library,
-        string seasonId)
-    {
-        try
-        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{library.MediaSourceId}", out string userId))
-            {
-                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                JellyfinLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, userId, seasonId);
-                return items.Items
-                    .Map(i => ProjectToEpisode(library, i))
-                    .Somes()
-                    .ToList();
-            }
+        string showId) =>
+        GetPagedLibraryItems(
+            address,
+            apiKey,
+            library,
+            library.MediaSourceId,
+            showId,
+            JellyfinItemType.Season,
+            (service, userId, _, skip, pageSize) => service.GetSeasonLibraryItems(
+                apiKey,
+                userId,
+                showId,
+                startIndex: skip,
+                limit: pageSize),
+            (_, item) => ProjectToSeason(item));

-            return BaseError.New("Jellyfin admin user id is not available");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting jellyfin episode library items");
-            return BaseError.New(ex.Message);
-        }
-    }
+    public IAsyncEnumerable<JellyfinEpisode> GetEpisodeLibraryItems(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string seasonId) =>
+        GetPagedLibraryItems(
+            address,
+            apiKey,
+            library,
+            library.MediaSourceId,
+            seasonId,
+            JellyfinItemType.Episode,
+            (service, userId, _, skip, pageSize) => service.GetEpisodeLibraryItems(
+                apiKey,
+                userId,
+                seasonId,
+                startIndex: skip,
+                limit: pageSize),
+            (maybeLibrary, item) => maybeLibrary.Map(lib => ProjectToEpisode(lib, item)).Flatten());

-    public async Task<Either<BaseError, List<JellyfinCollection>>> GetCollectionLibraryItems(
+    public IAsyncEnumerable<JellyfinCollection> GetCollectionLibraryItems(
        string address,
        string apiKey,
        int mediaSourceId)
+    {
+        // TODO: should we enumerate collection libraries here?
+
+        if (_memoryCache.TryGetValue("jellyfin_collections_library_item_id", out string itemId))
+        {
+            return GetPagedLibraryItems(
+                address,
+                apiKey,
+                None,
+                mediaSourceId,
+                itemId,
+                JellyfinItemType.Collection,
+                (service, userId, _, skip, pageSize) => service.GetCollectionLibraryItems(
+                    apiKey,
+                    userId,
+                    itemId,
+                    startIndex: skip,
+                    limit: pageSize),
+                (_, item) => ProjectToCollection(item));
+        }
+
+        return AsyncEnumerable.Empty<JellyfinCollection>();
+    }
+
+    public IAsyncEnumerable<MediaItem> GetCollectionItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string collectionId) =>
+        GetPagedLibraryItems(
+            address,
+            apiKey,
+            None,
+            mediaSourceId,
+            collectionId,
+            JellyfinItemType.CollectionItems,
+            (service, userId, _, skip, pageSize) => service.GetCollectionItems(
+                apiKey,
+                userId,
+                collectionId,
+                startIndex: skip,
+                limit: pageSize),
+            (_, item) => ProjectToCollectionMediaItem(item));
+
+    public async Task<Either<BaseError, int>> GetLibraryItemCount(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string parentId,
+        string includeItemTypes,
+        bool excludeFolders)
    {
        try
        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
+            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{library.MediaSourceId}", out string userId))
            {
-                // TODO: should we enumerate collection libraries here?
-
-                if (_memoryCache.TryGetValue("jellyfin_collections_library_item_id", out string itemId))
-                {
-                    IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                    JellyfinLibraryItemsResponse items =
-                        await service.GetCollectionLibraryItems(apiKey, userId, itemId);
-                    return items.Items
-                        .Map(ProjectToCollection)
-                        .Somes()
-                        .ToList();
-                }
-
-                return BaseError.New("Jellyfin collection item id is not available");
+                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+                JellyfinLibraryItemsResponse items = await service.GetLibraryStats(
+                    apiKey,
+                    userId,
+                    parentId,
+                    includeItemTypes,
+                    filters: excludeFolders ? "IsNotFolder" : null);
+                return items.TotalRecordCount;
            }

            return BaseError.New("Jellyfin admin user id is not available");
        }
        catch (Exception ex)
        {
-            _logger.LogError(ex, "Error getting jellyfin collection library items");
+            _logger.LogError(ex, "Error getting jellyfin library item count");
            return BaseError.New(ex.Message);
        }
    }

-    public async Task<Either<BaseError, List<MediaItem>>> GetCollectionItems(
+    private async IAsyncEnumerable<TItem> GetPagedLibraryItems<TItem>(
        string address,
        string apiKey,
+        Option<JellyfinLibrary> maybeLibrary,
        int mediaSourceId,
-        string collectionId)
+        string parentId,
+        string itemType,
+        Func<IJellyfinApi, string, string, int, int, Task<JellyfinLibraryItemsResponse>> getItems,
+        Func<Option<JellyfinLibrary>, JellyfinLibraryItemResponse, Option<TItem>> mapper)
    {
-        try
+        if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-            {
-                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                JellyfinLibraryItemsResponse items = await service.GetCollectionItems(
-                    apiKey,
-                    userId,
-                    collectionId);
-                return items.Items
-                    .Map(ProjectToCollectionMediaItem)
-                    .Somes()
-                    .ToList();
-            }
+            IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+            int size = await service
+                .GetLibraryStats(apiKey, userId, parentId, itemType)
+                .Map(r => r.TotalRecordCount);

-            return BaseError.New("Jellyfin admin user id is not available");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error getting jellyfin collection items");
-            return BaseError.New(ex.Message);
+            const int PAGE_SIZE = 10;
+
+            int pages = (size - 1) / PAGE_SIZE + 1;
+
+            for (var i = 0; i < pages; i++)
+            {
+                int skip = i * PAGE_SIZE;
+
+                Task<IEnumerable<TItem>> result = getItems(service, userId, parentId, skip, PAGE_SIZE)
+                    .Map(items => items.Items.Map(item => mapper(maybeLibrary, item)).Somes());
+
+                foreach (TItem item in await result)
+                {
+                    yield return item;
+                }
+            }
        }
    }

--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemsResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemsResponse.cs
@@ -3,4 +3,5 @@
 public class JellyfinLibraryItemsResponse
 {
    public List<JellyfinLibraryItemResponse> Items { get; set; }
+    public int TotalRecordCount { get; set; }
 }
--- a/ErsatzTV.Infrastructure/Migrations/20220522171735_Reset_OtherVideoLibraries20220522.Designer.cs
+++ b/ErsatzTV.Infrastructure/Migrations/20220522171735_Reset_OtherVideoLibraries20220522.Designer.cs
--- a/ErsatzTV.Infrastructure/Migrations/20220522171735_Reset_OtherVideoLibraries20220522.cs
+++ b/ErsatzTV.Infrastructure/Migrations/20220522171735_Reset_OtherVideoLibraries20220522.cs
@@ -0,0 +1,30 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.Migrations
+{
+    public partial class Reset_OtherVideoLibraries20220522 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(
+                @"UPDATE LibraryPath SET LastScan = '0001-01-01 00:00:00' WHERE Id IN
+                (SELECT LP.Id FROM LibraryPath LP INNER JOIN Library L on L.Id = LP.LibraryId WHERE MediaKind = 4)");
+
+            migrationBuilder.Sql(
+                @"UPDATE Library SET LastScan = '0001-01-01 00:00:00' WHERE MediaKind = 4");
+
+            migrationBuilder.Sql(
+                @"DELETE FROM LibraryFolder WHERE Id IN
+(SELECT LF.Id FROM LibraryFolder LF
+INNER JOIN LibraryPath LP on LP.Id = LF.LibraryPathId
+INNER JOIN Library L on L.Id = LP.LibraryId
+WHERE L.MediaKind = 4)");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+        }
+    }
+}
--- a/ErsatzTV.Infrastructure/Migrations/TvContextModelSnapshot.cs
+++ b/ErsatzTV.Infrastructure/Migrations/TvContextModelSnapshot.cs
@@ -15,7 +15,7 @@ namespace ErsatzTV.Infrastructure.Migrations
        protected override void BuildModel(ModelBuilder modelBuilder)
        {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "6.0.4");
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.5");

            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
                {
--- a/ErsatzTV.Infrastructure/Plex/IPlexServerApi.cs
+++ b/ErsatzTV.Infrastructure/Plex/IPlexServerApi.cs
@@ -17,11 +17,22 @@ public interface IPlexServerApi
        [Query] [AliasAs("X-Plex-Token")]
        string token);

+    [Get("/library/sections/{key}/all?X-Plex-Container-Start=0&X-Plex-Container-Size=0")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlMediaContainerStatsResponse> GetLibrarySection(
+        string key,
+        [Query] [AliasAs("X-Plex-Token")]
+        string token);
+
    [Get("/library/sections/{key}/all")]
    [Headers("Accept: application/json")]
    public Task<PlexMediaContainerResponse<PlexMediaContainerMetadataContent<PlexMetadataResponse>>>
        GetLibrarySectionContents(
            string key,
+            [Query] [AliasAs("X-Plex-Container-Start")]
+            int skip,
+            [Query] [AliasAs("X-Plex-Container-Size")]
+            int take,
            [Query] [AliasAs("X-Plex-Token")]
            string token);

@@ -41,19 +52,41 @@ public interface IPlexServerApi
            [Query] [AliasAs("X-Plex-Token")]
            string token);

+    [Get("/library/metadata/{key}/children?X-Plex-Container-Start=0&X-Plex-Container-Size=0")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlMediaContainerStatsResponse> CountShowChildren(
+        string key,
+        [Query] [AliasAs("X-Plex-Token")]
+        string token);
+
    [Get("/library/metadata/{key}/children")]
    [Headers("Accept: text/xml")]
    public Task<PlexXmlSeasonsMetadataResponseContainer>
        GetShowChildren(
            string key,
+            [Query] [AliasAs("X-Plex-Container-Start")]
+            int skip,
+            [Query] [AliasAs("X-Plex-Container-Size")]
+            int take,
            [Query] [AliasAs("X-Plex-Token")]
            string token);

+    [Get("/library/metadata/{key}/children?X-Plex-Container-Start=0&X-Plex-Container-Size=0")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlMediaContainerStatsResponse> CountSeasonChildren(
+        string key,
+        [Query] [AliasAs("X-Plex-Token")]
+        string token);
+
    [Get("/library/metadata/{key}/children")]
    [Headers("Accept: text/xml")]
    public Task<PlexXmlEpisodesMetadataResponseContainer>
        GetSeasonChildren(
            string key,
+            [Query] [AliasAs("X-Plex-Container-Start")]
+            int skip,
+            [Query] [AliasAs("X-Plex-Container-Size")]
+            int take,
            [Query] [AliasAs("X-Plex-Token")]
            string token);
 }
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexMediaContainerResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexMediaContainerResponse.cs
@@ -17,6 +17,13 @@ public class PlexMediaContainerMetadataContent<T>
    public List<T> Metadata { get; set; }
 }

+[XmlRoot("MediaContainer", Namespace = null)]
+public class PlexXmlMediaContainerStatsResponse
+{
+    [XmlAttribute("totalSize")]
+    public int TotalSize { get; set; }
+}
+
 [XmlRoot("MediaContainer", Namespace = null)]
 public class PlexXmlVideoMetadataResponseContainer
 {
--- a/ErsatzTV.Infrastructure/Plex/PlexEtag.cs
+++ b/ErsatzTV.Infrastructure/Plex/PlexEtag.cs
@@ -8,10 +8,8 @@ public class PlexEtag
 {
    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;

-    public PlexEtag(RecyclableMemoryStreamManager recyclableMemoryStreamManager)
-    {
+    public PlexEtag(RecyclableMemoryStreamManager recyclableMemoryStreamManager) =>
        _recyclableMemoryStreamManager = recyclableMemoryStreamManager;
-    }

    public string ForMovie(PlexMetadataResponse response)
    {
--- a/ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs
+++ b/ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs
@@ -26,9 +26,7 @@ public class PlexServerApiClient : IPlexServerApiClient
        _logger = logger;
    }

-    public async Task<bool> Ping(
-        PlexConnection connection,
-        PlexServerAuthToken token)
+    public async Task<bool> Ping(PlexConnection connection, PlexServerAuthToken token)
    {
        try
        {
@@ -76,56 +74,58 @@ public class PlexServerApiClient : IPlexServerApiClient
        }
    }

-    public async Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryContents(
+    public IAsyncEnumerable<PlexMovie> GetMovieLibraryContents(
        PlexLibrary library,
        PlexConnection connection,
        PlexServerAuthToken token)
    {
-        try
+        Task<PlexXmlMediaContainerStatsResponse> CountItems(IPlexServerApi service)
        {
-            IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
-            return await service.GetLibrarySectionContents(library.Key, token.AuthToken)
+            return service.GetLibrarySection(library.Key, token.AuthToken);
+        }
+
+        Task<IEnumerable<PlexMovie>> GetItems(IPlexServerApi _, IPlexServerApi jsonService, int skip, int pageSize)
+        {
+            return jsonService
+                .GetLibrarySectionContents(library.Key, skip, pageSize, token.AuthToken)
                .Map(r => r.MediaContainer.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
-                .Map(list => list.Map(metadata => ProjectToMovie(metadata, library.MediaSourceId)).ToList());
-        }
-        catch (Exception ex)
-        {
-            return BaseError.New(ex.ToString());
+                .Map(list => list.Map(metadata => ProjectToMovie(metadata, library.MediaSourceId)));
        }
+
+        return GetPagedLibraryContents(connection, CountItems, GetItems);
    }

-    public async Task<Either<BaseError, List<PlexShow>>> GetShowLibraryContents(
+    public IAsyncEnumerable<PlexShow> GetShowLibraryContents(
        PlexLibrary library,
        PlexConnection connection,
        PlexServerAuthToken token)
    {
-        try
+        Task<PlexXmlMediaContainerStatsResponse> CountItems(IPlexServerApi service)
        {
-            IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
-            return await service.GetLibrarySectionContents(library.Key, token.AuthToken)
+            return service.GetLibrarySection(library.Key, token.AuthToken);
+        }
+
+        Task<IEnumerable<PlexShow>> GetItems(IPlexServerApi _, IPlexServerApi jsonService, int skip, int pageSize)
+        {
+            return jsonService
+                .GetLibrarySectionContents(library.Key, skip, pageSize, token.AuthToken)
                .Map(r => r.MediaContainer.Metadata)
-                .Map(
-                    list => (list ?? new List<PlexMetadataResponse>())
-                        .Map(metadata => ProjectToShow(metadata, library.MediaSourceId)).ToList());
-        }
-        catch (Exception ex)
-        {
-            return BaseError.New(ex.ToString());
+                .Map(list => list.Map(metadata => ProjectToShow(metadata, library.MediaSourceId)));
        }
+
+        return GetPagedLibraryContents(connection, CountItems, GetItems);
    }

-    public async Task<Either<BaseError, List<PlexSeason>>> GetShowSeasons(
-        PlexLibrary library,
+    public async Task<Either<BaseError, int>> CountShowSeasons(
        PlexShow show,
        PlexConnection connection,
        PlexServerAuthToken token)
    {
        try
        {
+            string showMetadataKey = show.Key.Split("/").Reverse().Skip(1).Head();
            IPlexServerApi service = XmlServiceFor(connection.Uri);
-            return await service.GetShowChildren(show.Key.Split("/").Reverse().Skip(1).Head(), token.AuthToken)
-                .Map(r => r.Metadata.Filter(m => !m.Key.Contains("allLeaves")))
-                .Map(list => list.Map(metadata => ProjectToSeason(metadata, library.MediaSourceId)).ToList());
+            return await service.CountShowChildren(showMetadataKey, token.AuthToken).Map(r => r.TotalSize);
        }
        catch (Exception ex)
        {
@@ -133,19 +133,39 @@ public class PlexServerApiClient : IPlexServerApiClient
        }
    }

-    public async Task<Either<BaseError, List<PlexEpisode>>> GetSeasonEpisodes(
+    public IAsyncEnumerable<PlexSeason> GetShowSeasons(
        PlexLibrary library,
+        PlexShow show,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        string showMetadataKey = show.Key.Split("/").Reverse().Skip(1).Head();
+
+        Task<PlexXmlMediaContainerStatsResponse> CountItems(IPlexServerApi service)
+        {
+            return service.CountShowChildren(showMetadataKey, token.AuthToken);
+        }
+
+        Task<IEnumerable<PlexSeason>> GetItems(IPlexServerApi xmlService, IPlexServerApi _, int skip, int pageSize)
+        {
+            return xmlService.GetShowChildren(showMetadataKey, skip, pageSize, token.AuthToken)
+                .Map(r => r.Metadata.Filter(m => !m.Key.Contains("allLeaves")))
+                .Map(list => list.Map(metadata => ProjectToSeason(metadata, library.MediaSourceId)));
+        }
+
+        return GetPagedLibraryContents(connection, CountItems, GetItems);
+    }
+
+    public async Task<Either<BaseError, int>> CountSeasonEpisodes(
        PlexSeason season,
        PlexConnection connection,
        PlexServerAuthToken token)
    {
        try
        {
+            string seasonMetadataKey = season.Key.Split("/").Reverse().Skip(1).Head();
            IPlexServerApi service = XmlServiceFor(connection.Uri);
-            return await service.GetSeasonChildren(season.Key.Split("/").Reverse().Skip(1).Head(), token.AuthToken)
-                .Map(r => r.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
-                .Map(list => list.Map(metadata => ProjectToEpisode(metadata, library.MediaSourceId)))
-                .Map(ProcessMultiEpisodeFiles);
+            return await service.CountSeasonChildren(seasonMetadataKey, token.AuthToken).Map(r => r.TotalSize);
        }
        catch (Exception ex)
        {
@@ -153,6 +173,29 @@ public class PlexServerApiClient : IPlexServerApiClient
        }
    }

+    public IAsyncEnumerable<PlexEpisode> GetSeasonEpisodes(
+        PlexLibrary library,
+        PlexSeason season,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        string seasonMetadataKey = season.Key.Split("/").Reverse().Skip(1).Head();
+
+        Task<PlexXmlMediaContainerStatsResponse> CountItems(IPlexServerApi service)
+        {
+            return service.CountSeasonChildren(seasonMetadataKey, token.AuthToken);
+        }
+
+        Task<IEnumerable<PlexEpisode>> GetItems(IPlexServerApi xmlService, IPlexServerApi _, int skip, int pageSize)
+        {
+            return xmlService.GetSeasonChildren(seasonMetadataKey, skip, pageSize, token.AuthToken)
+                .Map(r => r.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
+                .Map(list => list.Map(metadata => ProjectToEpisode(metadata, library.MediaSourceId)));
+        }
+
+        return GetPagedLibraryContents(connection, CountItems, GetItems);
+    }
+
    public async Task<Either<BaseError, MovieMetadata>> GetMovieMetadata(
        PlexLibrary library,
        string key,
@@ -254,6 +297,50 @@ public class PlexServerApiClient : IPlexServerApiClient
        }
    }

+    public async Task<Either<BaseError, int>> GetLibraryItemCount(
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            return await service.GetLibrarySection(library.Key, token.AuthToken).Map(r => r.TotalSize);
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private async IAsyncEnumerable<TItem> GetPagedLibraryContents<TItem>(
+        PlexConnection connection,
+        Func<IPlexServerApi, Task<PlexXmlMediaContainerStatsResponse>> countItems,
+        Func<IPlexServerApi, IPlexServerApi, int, int, Task<IEnumerable<TItem>>> getItems)
+    {
+        IPlexServerApi xmlService = XmlServiceFor(connection.Uri);
+
+        int size = await countItems(xmlService).Map(r => r.TotalSize);
+
+        const int PAGE_SIZE = 10;
+
+        IPlexServerApi jsonService = RestService.For<IPlexServerApi>(connection.Uri);
+        int pages = (size - 1) / PAGE_SIZE + 1;
+
+        for (var i = 0; i < pages; i++)
+        {
+            int skip = i * PAGE_SIZE;
+
+            Task<IEnumerable<TItem>> result = getItems(xmlService, jsonService, skip, PAGE_SIZE);
+
+            foreach (TItem item in await result)
+            {
+                yield return item;
+            }
+        }
+    }
+
+    // TODO: fix this with the addition of paging
    private List<PlexEpisode> ProcessMultiEpisodeFiles(IEnumerable<PlexEpisode> episodes)
    {
        // add all metadata from duplicate paths to first entry with given path
--- a/ErsatzTV/ErsatzTV.csproj
+++ b/ErsatzTV/ErsatzTV.csproj
@@ -55,10 +55,10 @@
    
    <ItemGroup>
      <PackageReference Include="Bugsnag.AspNet.Core" Version="3.0.1" />
-      <PackageReference Include="FluentValidation" Version="11.0.1" />
-      <PackageReference Include="FluentValidation.AspNetCore" Version="11.0.1" />
+      <PackageReference Include="FluentValidation" Version="11.0.2" />
+      <PackageReference Include="FluentValidation.AspNetCore" Version="11.0.2" />
      <PackageReference Include="HtmlSanitizer" Version="7.1.488" />
-      <PackageReference Include="LanguageExt.Core" Version="4.1.0" />
+      <PackageReference Include="LanguageExt.Core" Version="4.1.1" />
      <PackageReference Include="Markdig" Version="0.30.2" />
      <PackageReference Include="MediatR.Courier.DependencyInjection" Version="5.0.0" />
      <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="10.0.1" />
--- a/docker/vaapi/ffmpeg.Dockerfile
+++ b/docker/vaapi/ffmpeg.Dockerfile
@@ -10,6 +10,7 @@ RUN apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y libicu
    autoconf \
    libtool \
    libdrm-dev \
+    libmfx-dev \
    git \
    pkg-config \
    build-essential \
Author	SHA1	Message	Date
Jason Dove	0388425763	update changelog for release v0.6.0-beta [no ci]	2022-06-01 18:01:07 -05:00
Jason Dove	ca5d303ac7	fix qsv encoder regression and memory errors (#828 ) * fix qsv encoders; only use 64 extra hw frames * update changelog	2022-05-31 06:07:50 -05:00
Jason Dove	18e66a92ad	add paging to media server show and collection calls (#827 ) * add paging to media server show library calls * add paging to media server season and episode library calls * formatting * add paging to media server collection calls * add paging to media server collection item calls * update changelog	2022-05-31 05:56:48 -05:00
Jason Dove	7d0a56ab98	disable lower-power mode for qsv encoders (#826 )	2022-05-29 20:44:27 -05:00
Jason Dove	5069792d12	update dependencies	2022-05-28 20:41:54 -05:00
Jason Dove	c9789458b9	page media server movie libraries	2022-05-28 20:41:22 -05:00
Jason Dove	777a0d09ed	hls segmenter fixes (#824 ) * fix pts warning when channel first starts streaming * rework playlist filtering	2022-05-25 21:05:55 -05:00
Jason Dove	4e2ebcc48a	fix watermark opacity filter (#820 )	2022-05-23 10:29:04 -05:00
Jason Dove	90fe1d7709	fix hw accel health check for qsv in vaapi docker (#818 )	2022-05-22 19:42:14 -05:00
Jason Dove	1576dd026e	enable qsv accel for vaapi docker images (#817 )	2022-05-22 18:43:24 -05:00
Jason Dove	ee7a64eea9	fix other video libraries (#816 ) * update depdendencies * reset other video libraries	2022-05-22 12:29:35 -05:00