From e120b7f2dd986d7f07f6814b6d987bafd46baab8 Mon Sep 17 00:00:00 2001
From: vavallee <vavallee@protonmail.com>
Date: Fri, 7 Aug 2026 12:33:37 -0300
Subject: Stop image endpoints from upscaling beyond the source resolution

ImageHelper.GetNewImageSize passed the caller-supplied width/height straight
through to SkiaEncoder.EncodeImage, which allocates an SKImageInfo of exactly
that size. Nothing bounded those values against the source image, so a request
like Items/<id>/Images/Primary?width=23100&height=23100 made the server allocate
and resample a 23100x23100 surface from, say, a 600x336 poster: the reporter
measured 100% of a core for 10-15 minutes and 6-12 GB resident per request.
The item images endpoints do not require authentication, so any caller who knows
an item id can trigger this, and varying the size by one pixel misses the cache
every time.

Add DrawingUtils.ScaleDownToFit, which scales a size down uniformly until it
fits inside a bounding box and returns it unchanged if it already does, and
apply it in GetNewImageSize against the original image dimensions. Requests
that ask for more pixels than the source now get the source resolution back,
scaled to the requested aspect ratio. Downscaling paths are untouched, and
DrawingUtils.Resize keeps its existing behaviour for the transcoding callers in
EncodingJobInfo and StreamInfo, which legitimately size video output.
ResizeFill already refused to upscale; this makes width/height consistent
with fillWidth/fillHeight.

Fixes #17056.
---
 MediaBrowser.Controller/Drawing/ImageHelper.cs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'MediaBrowser.Controller')

diff --git a/MediaBrowser.Controller/Drawing/ImageHelper.cs b/MediaBrowser.Controller/Drawing/ImageHelper.cs
index 9ef92bc981..c1d0203897 100644
--- a/MediaBrowser.Controller/Drawing/ImageHelper.cs
+++ b/MediaBrowser.Controller/Drawing/ImageHelper.cs
@@ -11,7 +11,11 @@ namespace MediaBrowser.Controller.Drawing
             // Determine the output size based on incoming parameters
             var newSize = DrawingUtils.Resize(originalImageSize, options.Width ?? 0, options.Height ?? 0, options.MaxWidth ?? 0, options.MaxHeight ?? 0);
             newSize = DrawingUtils.ResizeFill(newSize, options.FillWidth, options.FillHeight);
-            return newSize;
+
+            // Never encode larger than the source. Upscaling adds no detail, and the requested
+            // width/height are caller-controlled, so without this an unauthenticated request can
+            // pin a CPU and allocate several GB encoding a single image.
+            return DrawingUtils.ScaleDownToFit(newSize, originalImageSize);
         }
     }
 }
-- 
cgit v1.2.3


From c091ffdc6b2d8d4dd6f439d056c561bae7bd9a18 Mon Sep 17 00:00:00 2001
From: brandon <brandon@clinger.dev>
Date: Fri, 7 Aug 2026 22:51:45 -0400
Subject: Batch alternate version detection in DtoService to remove
 MediaSourceCount N+1

Browsing a page of videos with the MediaSourceCount field ran one alternate
version query per item, each opening a fresh DbContext. On a large library that
turned a single page into hundreds of sequential round trips and made the Items
endpoint take tens of seconds while holding a request thread the whole time.

Detect which videos own alternate versions once per page with a single query,
mirroring the existing people batch. Videos absent from that set have a single
media source, so the per item lookups are skipped for the common case. Behavior
is unchanged: a video with no alternates already resolved to a count of one.

Adds a regression test asserting the count resolves from the batch and the per
item lookups are never called.
---
 Emby.Server.Implementations/Dto/DtoService.cs      | 49 ++++++++++++++++------
 .../Library/LibraryManager.cs                      |  6 +++
 .../Item/LinkedChildrenService.cs                  | 21 ++++++++++
 MediaBrowser.Controller/Library/ILibraryManager.cs |  8 ++++
 .../Persistence/ILinkedChildrenService.cs          |  9 ++++
 .../Dto/DtoServiceImageInheritanceTests.cs         | 42 +++++++++++++++++++
 6 files changed, 123 insertions(+), 12 deletions(-)

(limited to 'MediaBrowser.Controller')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index da0c52df5b..062c19a1d4 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -253,6 +253,18 @@ namespace Emby.Server.Implementations.Dto
                 }
             }
 
+            // Batch-detect which videos own alternate versions to avoid the per-item alternate-version
+            // queries in MediaSourceCount. Videos absent from this set have a single media source.
+            IReadOnlySet<Guid>? alternateVersionItemIds = null;
+            if (options.ContainsField(ItemFields.MediaSourceCount))
+            {
+                var versionItemIds = accessibleItems.OfType<Video>().Select(i => i.Id).ToList();
+                if (versionItemIds.Count > 0)
+                {
+                    alternateVersionItemIds = _libraryManager.GetItemsWithAlternateVersions(versionItemIds);
+                }
+            }
+
             for (int index = 0; index < accessibleItems.Count; index++)
             {
                 var item = accessibleItems[index];
@@ -267,7 +279,8 @@ namespace Emby.Server.Implementations.Dto
                     playedCountBatch,
                     artistsBatch,
                     resumeDataBatch?.GetValueOrDefault(item.Id),
-                    peopleBatch);
+                    peopleBatch,
+                    alternateVersionItemIds);
 
                 if (item is LiveTvChannel tvChannel)
                 {
@@ -330,7 +343,8 @@ namespace Emby.Server.Implementations.Dto
             Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null,
             IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null,
             VersionResumeData? resumeData = null,
-            IReadOnlyDictionary<Guid, IReadOnlyList<PersonInfo>>? peopleBatch = null)
+            IReadOnlyDictionary<Guid, IReadOnlyList<PersonInfo>>? peopleBatch = null,
+            IReadOnlySet<Guid>? alternateVersionItemIds = null)
         {
             var dto = new BaseItemDto
             {
@@ -399,7 +413,7 @@ namespace Emby.Server.Implementations.Dto
                 AttachStudios(dto, item);
             }
 
-            AttachBasicFields(dto, item, owner, options, artistsBatch, user);
+            AttachBasicFields(dto, item, owner, options, artistsBatch, user, alternateVersionItemIds);
 
             if (options.ContainsField(ItemFields.CanDelete))
             {
@@ -984,7 +998,8 @@ namespace Emby.Server.Implementations.Dto
         /// <param name="options">The options.</param>
         /// <param name="artistsBatch">Optional pre-fetched artist lookup shared across a batch of items.</param>
         /// <param name="user">The user, for per-user values such as the accessible media source count.</param>
-        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null, User? user = null)
+        /// <param name="alternateVersionItemIds">Optional pre-fetched set of item IDs that own alternate versions, shared across a batch of items.</param>
+        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null, User? user = null, IReadOnlySet<Guid>? alternateVersionItemIds = null)
         {
             if (options.ContainsField(ItemFields.DateCreated))
             {
@@ -1298,15 +1313,25 @@ namespace Emby.Server.Implementations.Dto
 
                 if (options.ContainsField(ItemFields.MediaSourceCount))
                 {
-                    // Match the per-user filtering of the media sources: versions the user cannot
-                    // access are not selectable, so they must not count towards the badge either.
-                    var mediaSourceCount = user is null
-                        || (!video.PrimaryVersionId.HasValue && video.LinkedAlternateVersions.Length == 0 && !video.HasLocalAlternateVersions)
-                            ? video.MediaSourceCount
-                            : video.GetAllVersions().Count(v => v.Id.Equals(video.Id) || v.IsVisibleStandalone(user));
-                    if (mediaSourceCount != 1)
+                    // A video with no primary version and no alternate versions always has a single
+                    // media source. When the batch has already determined this item owns no alternate
+                    // versions, skip the per-item alternate-version queries entirely (the common case).
+                    var hasNoAlternateVersions = alternateVersionItemIds is not null
+                        && !video.PrimaryVersionId.HasValue
+                        && !alternateVersionItemIds.Contains(video.Id);
+
+                    if (!hasNoAlternateVersions)
                     {
-                        dto.MediaSourceCount = mediaSourceCount;
+                        // Match the per-user filtering of the media sources: versions the user cannot
+                        // access are not selectable, so they must not count towards the badge either.
+                        var mediaSourceCount = user is null
+                            || (!video.PrimaryVersionId.HasValue && video.LinkedAlternateVersions.Length == 0 && !video.HasLocalAlternateVersions)
+                                ? video.MediaSourceCount
+                                : video.GetAllVersions().Count(v => v.Id.Equals(video.Id) || v.IsVisibleStandalone(user));
+                        if (mediaSourceCount != 1)
+                        {
+                            dto.MediaSourceCount = mediaSourceCount;
+                        }
                     }
                 }
 
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 19371f68d7..9bb962c504 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -2234,6 +2234,12 @@ namespace Emby.Server.Implementations.Library
             return [];
         }
 
+        /// <inheritdoc />
+        public IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds)
+        {
+            return _linkedChildrenService.GetItemsWithAlternateVersions(itemIds);
+        }
+
         /// <inheritdoc />
         public void UpsertLinkedChild(Guid parentId, Guid childId, MediaBrowser.Controller.Entities.LinkedChildType childType)
         {
diff --git a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
index 5f1d9bf87a..2452f8e3c6 100644
--- a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
+++ b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
@@ -59,6 +59,27 @@ public class LinkedChildrenService : ILinkedChildrenService
             .ToArray();
     }
 
+    /// <inheritdoc/>
+    public IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds)
+    {
+        if (itemIds.Count == 0)
+        {
+            return new HashSet<Guid>();
+        }
+
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var parentIds = dbContext.LinkedChildren
+            .Where(lc => (lc.ChildType == DbLinkedChildType.LocalAlternateVersion
+                    || lc.ChildType == DbLinkedChildType.LinkedAlternateVersion)
+                && itemIds.Contains(lc.ParentId))
+            .Select(lc => lc.ParentId)
+            .Distinct()
+            .ToArray();
+
+        return parentIds.ToHashSet();
+    }
+
     /// <inheritdoc/>
     public IReadOnlyDictionary<string, MusicArtist[]> FindArtists(IReadOnlyList<string> artistNames)
     {
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 5eae6e103f..f6bd948b99 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -255,6 +255,14 @@ namespace MediaBrowser.Controller.Library
         /// <returns>Enumerable of linked Video items.</returns>
         IEnumerable<Video> GetLinkedAlternateVersions(Video video);
 
+        /// <summary>
+        /// Gets, in a single query, the subset of the supplied items that own at least one alternate
+        /// version (local or linked). Items absent from the result have no alternate versions.
+        /// </summary>
+        /// <param name="itemIds">The item IDs to check.</param>
+        /// <returns>The set of item IDs that have alternate versions.</returns>
+        IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds);
+
         /// <summary>
         /// Creates or updates a LinkedChild entry linking a parent to a child item.
         /// </summary>
diff --git a/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs b/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
index a4614fc125..c1fe3231f4 100644
--- a/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
+++ b/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
@@ -19,6 +19,15 @@ public interface ILinkedChildrenService
     /// <returns>List of child item IDs.</returns>
     IReadOnlyList<Guid> GetLinkedChildrenIds(Guid parentId, int? childType = null);
 
+    /// <summary>
+    /// Gets, in a single query, the subset of the supplied items that own at least one alternate
+    /// version (local or linked). Items absent from the result have no alternate versions, so their
+    /// media source count is one.
+    /// </summary>
+    /// <param name="itemIds">The item IDs to check.</param>
+    /// <returns>The set of item IDs that have alternate versions.</returns>
+    IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds);
+
     /// <summary>
     /// Gets all artist matches from the database.
     /// </summary>
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
index d18f8c6cff..fa94250287 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
@@ -9,6 +9,7 @@ using MediaBrowser.Controller.Drawing;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.Providers;
@@ -205,6 +206,43 @@ public class DtoServiceImageInheritanceTests
         libraryManager.Verify(x => x.GetPeople(It.IsAny<BaseItem>()), Times.Never);
     }
 
+    [Fact]
+    public void GetBaseItemDtos_Videos_ResolveMediaSourceCountFromBatch_WithoutPerItemLookup()
+    {
+        static Movie MakeMovie() => new Movie
+        {
+            Id = Guid.NewGuid(),
+            Name = "Movie",
+            ImageInfos = []
+        };
+
+        var movieOne = MakeMovie();
+        var movieTwo = MakeMovie();
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService detects which videos own alternate versions in ONE batch
+        // (GetItemsWithAlternateVersions) before the per-item loop. Videos absent from that set have a
+        // single media source, so the per-item GetLinkedAlternateVersions/GetLocalAlternateVersionIds
+        // queries (the N+1) must be skipped entirely. Here neither movie has alternate versions.
+        libraryManager
+            .Setup(x => x.GetItemsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new HashSet<Guid>());
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.MediaSourceCount] };
+        var dtos = dtoService.GetBaseItemDtos([movieOne, movieTwo], options);
+
+        Assert.Equal(2, dtos.Count);
+
+        // The alternate-version check is batched once for the whole set, and the per-item lookups are
+        // never reached because the batch already ruled out alternate versions.
+        libraryManager.Verify(x => x.GetItemsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+        libraryManager.Verify(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()), Times.Never);
+        libraryManager.Verify(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()), Times.Never);
+    }
+
     private static DtoService BuildDtoService(BaseItem displayParent)
     {
         var libraryManager = new Mock<ILibraryManager>();
@@ -231,6 +269,10 @@ public class DtoServiceImageInheritanceTests
             .Setup(x => x.GetImageCacheTag(It.IsAny<BaseItem>(), It.IsAny<ItemImageInfo>()))
             .Returns<BaseItem, ItemImageInfo>((_, image) => image.Path);
 
+        // Video.IsActiveRecording() dereferences this static during DTO building.
+        Video.RecordingsManager = recordingsManager.Object;
+        BaseItem.LibraryManager = libraryManager.Object;
+
         return new DtoService(
             logger.Object,
             libraryManager.Object,
-- 
cgit v1.2.3


From 10d108a1f453c0972b3059e10bb9b13bbcb34f63 Mon Sep 17 00:00:00 2001
From: brandon <brandon@clinger.dev>
Date: Sat, 8 Aug 2026 12:33:11 -0400
Subject: Address review on MediaSourceCount batching

Rename GetItemsWithAlternateVersions to GetItemIdsWithAlternateVersions
across the interfaces and implementations since it returns ids. Return
the hashset straight from the query instead of materializing an array
first. Rename the DtoService guard to mayHaveAlternateVersions and
invert it so the computed path is the explicit case. Assert the media
source count value in the batch skip test and add a test covering an
item that is in the returned set still resolving to the correct count.
---
 Emby.Server.Implementations/Dto/DtoService.cs      | 18 +++++----
 .../Library/LibraryManager.cs                      |  4 +-
 .../Item/LinkedChildrenService.cs                  |  8 ++--
 MediaBrowser.Controller/Library/ILibraryManager.cs |  2 +-
 .../Persistence/ILinkedChildrenService.cs          |  2 +-
 .../Dto/DtoServiceImageInheritanceTests.cs         | 47 ++++++++++++++++++++--
 6 files changed, 61 insertions(+), 20 deletions(-)

(limited to 'MediaBrowser.Controller')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 062c19a1d4..6fa057702c 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -261,7 +261,7 @@ namespace Emby.Server.Implementations.Dto
                 var versionItemIds = accessibleItems.OfType<Video>().Select(i => i.Id).ToList();
                 if (versionItemIds.Count > 0)
                 {
-                    alternateVersionItemIds = _libraryManager.GetItemsWithAlternateVersions(versionItemIds);
+                    alternateVersionItemIds = _libraryManager.GetItemIdsWithAlternateVersions(versionItemIds);
                 }
             }
 
@@ -1314,13 +1314,15 @@ namespace Emby.Server.Implementations.Dto
                 if (options.ContainsField(ItemFields.MediaSourceCount))
                 {
                     // A video with no primary version and no alternate versions always has a single
-                    // media source. When the batch has already determined this item owns no alternate
-                    // versions, skip the per-item alternate-version queries entirely (the common case).
-                    var hasNoAlternateVersions = alternateVersionItemIds is not null
-                        && !video.PrimaryVersionId.HasValue
-                        && !alternateVersionItemIds.Contains(video.Id);
-
-                    if (!hasNoAlternateVersions)
+                    // media source. Only compute the count for videos that might have more: a primary
+                    // version, or membership in the batch's set of items that own alternate versions.
+                    // Without the batch we can't rule it out, so fall back to computing (the single-item
+                    // path). Everything else is the common case and keeps the default count of one.
+                    var mayHaveAlternateVersions = alternateVersionItemIds is null
+                        || video.PrimaryVersionId.HasValue
+                        || alternateVersionItemIds.Contains(video.Id);
+
+                    if (mayHaveAlternateVersions)
                     {
                         // Match the per-user filtering of the media sources: versions the user cannot
                         // access are not selectable, so they must not count towards the badge either.
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 9bb962c504..0c7c411d0c 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -2235,9 +2235,9 @@ namespace Emby.Server.Implementations.Library
         }
 
         /// <inheritdoc />
-        public IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds)
+        public IReadOnlySet<Guid> GetItemIdsWithAlternateVersions(IReadOnlyList<Guid> itemIds)
         {
-            return _linkedChildrenService.GetItemsWithAlternateVersions(itemIds);
+            return _linkedChildrenService.GetItemIdsWithAlternateVersions(itemIds);
         }
 
         /// <inheritdoc />
diff --git a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
index 2452f8e3c6..a96e941c88 100644
--- a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
+++ b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
@@ -60,7 +60,7 @@ public class LinkedChildrenService : ILinkedChildrenService
     }
 
     /// <inheritdoc/>
-    public IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds)
+    public IReadOnlySet<Guid> GetItemIdsWithAlternateVersions(IReadOnlyList<Guid> itemIds)
     {
         if (itemIds.Count == 0)
         {
@@ -69,15 +69,13 @@ public class LinkedChildrenService : ILinkedChildrenService
 
         using var dbContext = _dbProvider.CreateDbContext();
 
-        var parentIds = dbContext.LinkedChildren
+        return dbContext.LinkedChildren
             .Where(lc => (lc.ChildType == DbLinkedChildType.LocalAlternateVersion
                     || lc.ChildType == DbLinkedChildType.LinkedAlternateVersion)
                 && itemIds.Contains(lc.ParentId))
             .Select(lc => lc.ParentId)
             .Distinct()
-            .ToArray();
-
-        return parentIds.ToHashSet();
+            .ToHashSet();
     }
 
     /// <inheritdoc/>
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index f6bd948b99..ca686fbd9d 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -261,7 +261,7 @@ namespace MediaBrowser.Controller.Library
         /// </summary>
         /// <param name="itemIds">The item IDs to check.</param>
         /// <returns>The set of item IDs that have alternate versions.</returns>
-        IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds);
+        IReadOnlySet<Guid> GetItemIdsWithAlternateVersions(IReadOnlyList<Guid> itemIds);
 
         /// <summary>
         /// Creates or updates a LinkedChild entry linking a parent to a child item.
diff --git a/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs b/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
index c1fe3231f4..79c29410e4 100644
--- a/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
+++ b/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
@@ -26,7 +26,7 @@ public interface ILinkedChildrenService
     /// </summary>
     /// <param name="itemIds">The item IDs to check.</param>
     /// <returns>The set of item IDs that have alternate versions.</returns>
-    IReadOnlySet<Guid> GetItemsWithAlternateVersions(IReadOnlyList<Guid> itemIds);
+    IReadOnlySet<Guid> GetItemIdsWithAlternateVersions(IReadOnlyList<Guid> itemIds);
 
     /// <summary>
     /// Gets all artist matches from the database.
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
index fa94250287..6a3dcab57a 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
@@ -222,11 +222,11 @@ public class DtoServiceImageInheritanceTests
         var libraryManager = new Mock<ILibraryManager>();
 
         // DtoService detects which videos own alternate versions in ONE batch
-        // (GetItemsWithAlternateVersions) before the per-item loop. Videos absent from that set have a
+        // (GetItemIdsWithAlternateVersions) before the per-item loop. Videos absent from that set have a
         // single media source, so the per-item GetLinkedAlternateVersions/GetLocalAlternateVersionIds
         // queries (the N+1) must be skipped entirely. Here neither movie has alternate versions.
         libraryManager
-            .Setup(x => x.GetItemsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Setup(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
             .Returns(new HashSet<Guid>());
 
         var dtoService = BuildDtoService(libraryManager);
@@ -236,13 +236,54 @@ public class DtoServiceImageInheritanceTests
 
         Assert.Equal(2, dtos.Count);
 
+        // A single media source is the default, so the count is left unset (the client treats null as one).
+        foreach (var dto in dtos)
+        {
+            Assert.Null(dto.MediaSourceCount);
+        }
+
         // The alternate-version check is batched once for the whole set, and the per-item lookups are
         // never reached because the batch already ruled out alternate versions.
-        libraryManager.Verify(x => x.GetItemsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+        libraryManager.Verify(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
         libraryManager.Verify(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()), Times.Never);
         libraryManager.Verify(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()), Times.Never);
     }
 
+    [Fact]
+    public void GetBaseItemDtos_VideoInAlternateVersionBatch_ResolvesRealCount()
+    {
+        var movie = new Movie
+        {
+            Id = Guid.NewGuid(),
+            Name = "Movie",
+            ImageInfos = []
+        };
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // This movie IS in the batch set, so the fast path must not short-circuit it: the per-item
+        // lookups still run and the count is computed exactly as it was before batching. Two linked
+        // alternate versions plus the movie itself is a count of three.
+        libraryManager
+            .Setup(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new HashSet<Guid> { movie.Id });
+        libraryManager
+            .Setup(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()))
+            .Returns([new Movie { Id = Guid.NewGuid() }, new Movie { Id = Guid.NewGuid() }]);
+        libraryManager
+            .Setup(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()))
+            .Returns([]);
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.MediaSourceCount] };
+        var dtos = dtoService.GetBaseItemDtos([movie], options);
+
+        Assert.Single(dtos);
+        Assert.Equal(3, dtos[0].MediaSourceCount);
+        libraryManager.Verify(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+    }
+
     private static DtoService BuildDtoService(BaseItem displayParent)
     {
         var libraryManager = new Mock<ILibraryManager>();
-- 
cgit v1.2.3


From 82ecfde2f7bdd9d91ec403749c124ef96f64cea3 Mon Sep 17 00:00:00 2001
From: Cody Robibero <cody@robibe.ro>
Date: Mon, 10 Aug 2026 16:10:08 -0400
Subject: Update MediaBrowser.Controller/Drawing/ImageHelper.cs

Co-authored-by: Tim Eisele <Tim_Eisele@web.de>
---
 MediaBrowser.Controller/Drawing/ImageHelper.cs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'MediaBrowser.Controller')

diff --git a/MediaBrowser.Controller/Drawing/ImageHelper.cs b/MediaBrowser.Controller/Drawing/ImageHelper.cs
index c1d0203897..6f26b7d912 100644
--- a/MediaBrowser.Controller/Drawing/ImageHelper.cs
+++ b/MediaBrowser.Controller/Drawing/ImageHelper.cs
@@ -12,9 +12,7 @@ namespace MediaBrowser.Controller.Drawing
             var newSize = DrawingUtils.Resize(originalImageSize, options.Width ?? 0, options.Height ?? 0, options.MaxWidth ?? 0, options.MaxHeight ?? 0);
             newSize = DrawingUtils.ResizeFill(newSize, options.FillWidth, options.FillHeight);
 
-            // Never encode larger than the source. Upscaling adds no detail, and the requested
-            // width/height are caller-controlled, so without this an unauthenticated request can
-            // pin a CPU and allocate several GB encoding a single image.
+            // Never encode larger than the source.
             return DrawingUtils.ScaleDownToFit(newSize, originalImageSize);
         }
     }
-- 
cgit v1.2.3