perf: Decode source image once per file in ImageProxyMiddleware

src/Anichron.Worker.Tests.Unit/Ingestion/Middlewares/ImageProxyMiddlewareTests.cs

@@ -8,6 +8,8 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using NodaTime;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
 using System.IO.Abstractions.TestingHelpers;
 
 namespace Anichron.Worker.Tests.Unit.Ingestion.Middlewares;
@@ -16,10 +18,20 @@ public sealed class ImageProxyMiddlewareTests
 {
     private sealed class TestFixture
     {
+        internal static readonly byte[] MinimalPng = CreateMinimalPng();
+
+        private static byte[] CreateMinimalPng()
+        {
+            using var img = new Image<Rgba32>(1, 1);
+            using var ms = new MemoryStream();
+            img.SaveAsPng(ms);
+            return ms.ToArray();
+        }
+
         public IImageProcessor ImageProcessor { get; } = Substitute.For<IImageProcessor>();
         public MockFileSystem FileSystem { get; } = new MockFileSystem(new Dictionary<string, MockFileData>
         {
-            ["/nas/photo.jpg"] = new MockFileData([0xFF, 0xD8, 0xFF, 0xD9]),
+            ["/nas/photo.jpg"] = new MockFileData(MinimalPng),
         });
         public Instant Now { get; } = Instant.FromUtc(2026, 5, 19, 10, 0, 0);
 
@@ -29,11 +41,11 @@ public TestFixture()
             clock.GetCurrentInstant().Returns(Now);
             Clock = clock;
 
-            ImageProcessor.CreateThumbnailAsync(Arg.Any<Stream>(), Arg.Any<CancellationToken>())
+            ImageProcessor.CreateThumbnailAsync(Arg.Any<Image<Rgba32>>(), Arg.Any<CancellationToken>())
                 .Returns([0x01, 0x02]);
-            ImageProcessor.CreateFullPreviewAsync(Arg.Any<Stream>(), Arg.Any<CancellationToken>())
+            ImageProcessor.CreateFullPreviewAsync(Arg.Any<Image<Rgba32>>(), Arg.Any<CancellationToken>())
                 .Returns([0x03, 0x04]);
-            ImageProcessor.ComputeBlurhashAsync(Arg.Any<Stream>(), Arg.Any<CancellationToken>())
+            ImageProcessor.ComputeBlurhashAsync(Arg.Any<Image<Rgba32>>(), Arg.Any<CancellationToken>())
                 .Returns("LGFFaXYk^6#M@-5c,1J5@[or[Q6.");
         }
 
@@ -243,7 +255,7 @@ public void CanInvoke_VideoItem_ReturnsFalse()
     public async Task InvokeAsync_LivePhotoPairItem_GeneratesProxyFilesAsync()
     {
         var fixture = new TestFixture();
-        fixture.FileSystem.AddFile("/nas/photo.heic", new MockFileData([0xFF, 0xD8, 0xFF, 0xD9]));
+        fixture.FileSystem.AddFile("/nas/photo.heic", new MockFileData(TestFixture.MinimalPng));
         var context = new IngestionContext
         {
             Item = new LivePhotoPairItem("/nas/photo.heic", "photo.heic", "/nas/photo.mov", "photo.mov"),

src/Anichron.Worker.Tests.Unit/Ingestion/Proxy/ImageProxyGeneratorsTests.cs

@@ -1,5 +1,7 @@
 using Anichron.Core.Domain;
 using Anichron.Worker.Ingestion.Proxy;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace Anichron.Worker.Tests.Unit.Ingestion.Proxy;
 
@@ -49,10 +51,11 @@ public void ThumbnailGenerator_ProxyType_IsThumbnail()
     public async Task ThumbnailGenerator_GenerateAsync_DelegatesToCreateThumbnailAsync()
     {
         var processor = Substitute.For<IImageProcessor>();
-        processor.CreateThumbnailAsync(Arg.Any<Stream>(), Arg.Any<CancellationToken>())
+        processor.CreateThumbnailAsync(Arg.Any<Image<Rgba32>>(), Arg.Any<CancellationToken>())
             .Returns([0x01, 0x02]);
+        using var image = new Image<Rgba32>(1, 1);
 
-        var bytes = await new ThumbnailGenerator(processor).GenerateAsync(Stream.Null, CancellationToken.None);
+        var bytes = await new ThumbnailGenerator(processor).GenerateAsync(image, CancellationToken.None);
 
         bytes.Should().Equal(0x01, 0x02);
     }
@@ -77,10 +80,11 @@ public void FullPreviewGenerator_ProxyType_IsFullPreview()
     public async Task FullPreviewGenerator_GenerateAsync_DelegatesToCreateFullPreviewAsync()
     {
         var processor = Substitute.For<IImageProcessor>();
-        processor.CreateFullPreviewAsync(Arg.Any<Stream>(), Arg.Any<CancellationToken>())
+        processor.CreateFullPreviewAsync(Arg.Any<Image<Rgba32>>(), Arg.Any<CancellationToken>())
             .Returns([0x03, 0x04]);
+        using var image = new Image<Rgba32>(1, 1);
 
-        var bytes = await new FullPreviewGenerator(processor).GenerateAsync(Stream.Null, CancellationToken.None);
+        var bytes = await new FullPreviewGenerator(processor).GenerateAsync(image, CancellationToken.None);
 
         bytes.Should().Equal(0x03, 0x04);
     }
@@ -93,10 +97,11 @@ public async Task FullPreviewGenerator_GenerateAsync_DelegatesToCreateFullPrevie
     public async Task GenerateAsync_ReturnsUtf8EncodedHashBytesAsync()
     {
         var processor = Substitute.For<IImageProcessor>();
-        processor.ComputeBlurhashAsync(Arg.Any<Stream>(), Arg.Any<CancellationToken>())
+        processor.ComputeBlurhashAsync(Arg.Any<Image<Rgba32>>(), Arg.Any<CancellationToken>())
             .Returns("HASH");
+        using var image = new Image<Rgba32>(1, 1);
 
-        var bytes = await new BlurhashGenerator(processor).GenerateAsync(Stream.Null, CancellationToken.None);
+        var bytes = await new BlurhashGenerator(processor).GenerateAsync(image, CancellationToken.None);
 
         bytes.Should().Equal("HASH"u8.ToArray());
     }

src/Anichron.Worker/Ingestion/Middlewares/ImageProxyMiddleware.cs

@@ -5,6 +5,8 @@
 using Anichron.Worker.Settings;
 using Microsoft.Extensions.Options;
 using NodaTime;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
 using System.IO.Abstractions;
 
 namespace Anichron.Worker.Ingestion.Middlewares;
@@ -29,6 +31,9 @@ public async Task InvokeAsync(IngestionContext context, IngestionDelegate next,
         var proxyPath = Path.Combine(proxyRoot, proxyDirectoryName);
         var sourceBytes = await fileSystem.File.ReadAllBytesAsync(context.Item.AbsolutePath, ct);
 
+        await using var ms = new MemoryStream(sourceBytes);
+        using var image = await Image.LoadAsync<Rgba32>(ms, ct);
+
         fileSystem.Directory.CreateDirectory(proxyPath);
 
         var proxyFiles = await Task.WhenAll(generators.Select(WriteProxyAsync));
@@ -41,8 +46,8 @@ public async Task InvokeAsync(IngestionContext context, IngestionDelegate next,
         async Task<ProxyFile> WriteProxyAsync(IImageProxyGenerator generator)
         {
             var relativePath = $"{proxyDirectoryName}/{generator.FileName}";
-            await using var ms = new MemoryStream(sourceBytes);
-            var bytes = await generator.GenerateAsync(ms, ct);
+            using var clone = image.Clone();
+            var bytes = await generator.GenerateAsync(clone, ct);
             await fileSystem.File.WriteAllBytesAsync(Path.Combine(proxyRoot, relativePath), bytes, ct);
             Log.ProxyWritten(logger, generator.ProxyType, bytes.Length, context.Item.RelativePath);
             return ProxyFileBuilder.Build(context, relativePath, generator.ProxyType, bytes.Length, guidFactory, clock);

src/Anichron.Worker/Ingestion/Proxy/ImageProcessor.cs

@@ -10,18 +10,17 @@ namespace Anichron.Worker.Ingestion.Proxy;
 
 internal interface IImageProcessor
 {
-    Task<byte[]> CreateThumbnailAsync(Stream source, CancellationToken ct);
-    Task<byte[]> CreateFullPreviewAsync(Stream source, CancellationToken ct);
-    Task<string> ComputeBlurhashAsync(Stream source, CancellationToken ct);
+    Task<byte[]> CreateThumbnailAsync(Image<Rgba32> image, CancellationToken ct);
+    Task<byte[]> CreateFullPreviewAsync(Image<Rgba32> image, CancellationToken ct);
+    Task<string> ComputeBlurhashAsync(Image<Rgba32> image, CancellationToken ct);
 }
 
 internal sealed class ImageSharpProcessor(IOptions<WorkerSettings> options) : IImageProcessor
 {
     private readonly WorkerSettings settings = options.Value;
 
-    public async Task<byte[]> CreateThumbnailAsync(Stream source, CancellationToken ct)
+    public async Task<byte[]> CreateThumbnailAsync(Image<Rgba32> image, CancellationToken ct)
     {
-        using var image = await Image.LoadAsync(source, ct);
         image.Mutate(x => x.Resize(new ResizeOptions
         {
             Size = new Size(settings.ThumbnailMaxWidth, 0),
@@ -33,9 +32,8 @@ public async Task<byte[]> CreateThumbnailAsync(Stream source, CancellationToken
         return ms.ToArray();
     }
 
-    public async Task<byte[]> CreateFullPreviewAsync(Stream source, CancellationToken ct)
+    public async Task<byte[]> CreateFullPreviewAsync(Image<Rgba32> image, CancellationToken ct)
     {
-        using var image = await Image.LoadAsync(source, ct);
         if (image.Width > settings.PreviewMaxWidth)
         {
             image.Mutate(x => x.Resize(new ResizeOptions
@@ -50,16 +48,15 @@ public async Task<byte[]> CreateFullPreviewAsync(Stream source, CancellationToke
         return ms.ToArray();
     }
 
-    public async Task<string> ComputeBlurhashAsync(Stream source, CancellationToken ct)
+    public Task<string> ComputeBlurhashAsync(Image<Rgba32> image, CancellationToken ct)
     {
-        using var image = await Image.LoadAsync<Rgba32>(source, ct);
         image.Mutate(x => x.Resize(new ResizeOptions
         {
             Size = new Size(settings.BlurhashSampleWidth, 0),
             Mode = ResizeMode.Max,
         }));
 
         // Blurhasher.Encode is CPU-bound and synchronous; no overload accepts a CancellationToken.
-        return Blurhasher.Encode(image, 4, 3);
+        return Task.FromResult(Blurhasher.Encode(image, 4, 3));
     }
 }

src/Anichron.Worker/Ingestion/Proxy/ImageProxyGenerators.cs

@@ -1,4 +1,6 @@
 using Anichron.Core.Domain;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
 using System.Text;
 
 namespace Anichron.Worker.Ingestion.Proxy;
@@ -7,32 +9,32 @@ internal interface IImageProxyGenerator
 {
     string FileName { get; }
     ProxyType ProxyType { get; }
-    Task<byte[]> GenerateAsync(Stream source, CancellationToken ct);
+    Task<byte[]> GenerateAsync(Image<Rgba32> image, CancellationToken ct);
 }
 
 internal sealed class ThumbnailGenerator(IImageProcessor imageProcessor) : IImageProxyGenerator
 {
     public string FileName => "thumbnail.jpg";
     public ProxyType ProxyType => ProxyType.Thumbnail;
-    public Task<byte[]> GenerateAsync(Stream source, CancellationToken ct)
-        => imageProcessor.CreateThumbnailAsync(source, ct);
+    public Task<byte[]> GenerateAsync(Image<Rgba32> image, CancellationToken ct)
+        => imageProcessor.CreateThumbnailAsync(image, ct);
 }
 
 internal sealed class FullPreviewGenerator(IImageProcessor imageProcessor) : IImageProxyGenerator
 {
     public string FileName => "preview.jpg";
     public ProxyType ProxyType => ProxyType.FullPreview;
-    public Task<byte[]> GenerateAsync(Stream source, CancellationToken ct)
-        => imageProcessor.CreateFullPreviewAsync(source, ct);
+    public Task<byte[]> GenerateAsync(Image<Rgba32> image, CancellationToken ct)
+        => imageProcessor.CreateFullPreviewAsync(image, ct);
 }
 
 internal sealed class BlurhashGenerator(IImageProcessor imageProcessor) : IImageProxyGenerator
 {
     public string FileName => "blurhash.txt";
     public ProxyType ProxyType => ProxyType.BlurHash;
-    public async Task<byte[]> GenerateAsync(Stream source, CancellationToken ct)
+    public async Task<byte[]> GenerateAsync(Image<Rgba32> image, CancellationToken ct)
     {
-        var hash = await imageProcessor.ComputeBlurhashAsync(source, ct);
+        var hash = await imageProcessor.ComputeBlurhashAsync(image, ct);
         return Encoding.UTF8.GetBytes(hash);
     }
 }