diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx index 2f5002b7..22398fac 100644 --- a/i18n/en/Server.resx +++ b/i18n/en/Server.resx @@ -70,6 +70,8 @@ Change your password first.long This archive makes no proxies.long The proxy was made from another photo.long + The server does not need a proxy of this photo.long + The proxy is smaller than this archive's proxies.long This upload would exceed your quota.long Too many attempts; wait a minute and try again.long Choose a password different from the current one.long diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx index 4ed52416..9a74fb04 100644 --- a/i18n/it/Server.it.resx +++ b/i18n/it/Server.it.resx @@ -68,6 +68,8 @@ Cambia prima la password. Questo archivio non crea proxy. Il proxy è stato creato da un'altra foto. + Al server non serve un proxy di questa foto. + Il proxy è più piccolo dei proxy di questo archivio. Questo caricamento supererebbe la tua quota. Troppi tentativi; attendi un minuto e riprova. Scegli una password diversa da quella attuale. diff --git a/src/Titano.Data/Archiving/ArchiveImages.cs b/src/Titano.Data/Archiving/ArchiveImages.cs index f7fb6dc4..099c6333 100644 --- a/src/Titano.Data/Archiving/ArchiveImages.cs +++ b/src/Titano.Data/Archiving/ArchiveImages.cs @@ -2,6 +2,7 @@ using System.Diagnostics; using Titano.Core.Archiving; using Titano.Core.Codecs.Jpeg; using Titano.Core.Imaging; +using Titano.Core.Imaging.Decoders; using Titano.Core.IO; using Titano.Core.Metadata; using Titano.Core.Model; @@ -24,6 +25,9 @@ public enum ProxyStoreResult /// Its Exif capture time is not the frame's: it was made from another photo. WrongFrame, + + /// Smaller than the archive's proxies of that frame: made from an embedded preview, not the original. + TooSmall, } /// @@ -41,6 +45,7 @@ public sealed class ArchiveImages private const int CommitFrames = 200; private const int ProbeLongEdge = 64; private static readonly TimeSpan CommitInterval = TimeSpan.FromSeconds(10); + private static readonly ImageDecoder ServerDecoders = DecoderFactory.CreateServer(); private readonly TitanoDatabase _db; private readonly SequenceWriter _writer; @@ -72,6 +77,12 @@ public sealed class ArchiveImages /// with this archive engine's decoders. public bool NeedsProxy(ImageFileFormat format) => NeedsProxy(_writer.Options.Decoder, format); + /// + /// on a Titano Server, whose decoders are managed only (BRIEF + /// §4.2): it asks clients and render nodes for the proxies of those originals. + /// + public static bool ServerNeedsProxy(ImageFileFormat format) => NeedsProxy(ServerDecoders, format); + /// /// A proxy of the original at for a server that cannot decode it (): /// at (0 = full size) and , with 's capture @@ -109,7 +120,8 @@ public sealed class ArchiveImages /// /// Files a proxy made elsewhere (a client or render node whose decoders read the original) as the frame's proxy, /// replacing the one there: a JPEG of at most that decodes, whose Exif capture time is the - /// frame's (proxies carry it, so the proxy counts as current and cannot belong to another photo), written atomically. + /// frame's (proxies carry it, so the proxy counts as current and cannot belong to another photo) and whose size is + /// the policy's (), written atomically. /// /// The archive is offline or read-only. public ProxyStoreResult StoreProxy(Archive archive, Sequence sequence, Frame frame, byte[] jpeg) @@ -117,8 +129,11 @@ public sealed class ArchiveImages ArgumentNullException.ThrowIfNull(jpeg); var paths = new ArchivePaths(archive.RootPath); ArchiveVolume.EnsureWritable(paths); - if (ManifestStore.ReadArchive(paths.ManifestPath).ProxyPolicy.LongEdge == ProxyPolicy.Disabled) return ProxyStoreResult.Disabled; + var policy = ManifestStore.ReadArchive(paths.ManifestPath).ProxyPolicy; + if (policy.LongEdge == ProxyPolicy.Disabled) return ProxyStoreResult.Disabled; if (jpeg.Length is 0 or > (int)MaxProxyBytes || !Decodes(jpeg)) return ProxyStoreResult.Invalid; + var info = JpegDecoder.ReadInfo(jpeg); + if (TooSmall(System.Math.Max(info.Width, info.Height), frame.Width, frame.Height, policy)) return ProxyStoreResult.TooSmall; if (frame.CapturedAt is { } captured) { using var stream = new MemoryStream(jpeg, writable: false); @@ -208,8 +223,10 @@ public sealed class ArchiveImages if (NeedsProxy(frame.Format)) { // Only a client or render node that decodes the original makes this proxy: a preview would make one the - // size of a thumbnail here. One left from a frame renumbered since goes, so it is asked for again. - var check = ReadProxy(path, frame).Check; + // size of a thumbnail here. One left from a frame renumbered since goes, so it is asked for again, and so + // does one smaller than the policy's (made here from a preview by an earlier version). + var (check, longEdge) = ReadProxy(path, frame); + if (check is ProxyCheck.Current or ProxyCheck.Unverifiable && TooSmall(longEdge, frame.W, frame.H, policy)) check = ProxyCheck.Stale; if (check is ProxyCheck.Current or ProxyCheck.Unverifiable) { reused++; @@ -272,6 +289,20 @@ public sealed class ArchiveImages } } + /// + /// Whether a proxy whose long edge is falls short of the policy's for a frame of + /// × (the policy's long edge, or the frame's own when smaller or + /// at full size): one made from an embedded preview. A frame of unknown size is never judged (a small original's + /// proxy would be refused again and again); a tenth of slack spares decoders that crop a few pixels. + /// + private static bool TooSmall(int longEdge, int width, int height, ProxyPolicy policy) + { + var own = System.Math.Max(width, height); + if (own <= 0) return false; + var expected = policy.LongEdge == ProxyPolicy.FullSize ? own : System.Math.Min(own, policy.LongEdge); + return longEdge * 10L < expected * 9L; + } + /// The frame's proxy as the frame to draw: a JPEG already oriented, under proxies/. private static SidecarFrame ProxySource(SidecarFrame frame) => frame with { diff --git a/src/Titano.Data/Processing/RenderNodeClient.cs b/src/Titano.Data/Processing/RenderNodeClient.cs index 602548a4..3ca316bf 100644 --- a/src/Titano.Data/Processing/RenderNodeClient.cs +++ b/src/Titano.Data/Processing/RenderNodeClient.cs @@ -245,9 +245,13 @@ public sealed class RenderNodeClient : IAsyncDisposable var project = ProjectStore.Parse(claimed.SettingsJson) with { Export = export }; var sequence = ToSequence(await _client.GetSequenceAsync(claimed.SequenceId, cancellationToken).ConfigureAwait(false)); - // This PC's decoders judge what they can read: the server's Undecodable does not keep a frame out of the render here. + // The server's Undecodable stands, as in its own render, except for a format only its decoders lack (HEIF) that + // this PC's read: such a frame renders here from its original. One read from its proxy renders either way. + var decoder = _processing.Archive.Decoder; var frames = (await ListFramesAsync(claimed.SequenceId, cancellationToken).ConfigureAwait(false)) - .ConvertAll(f => f with { Flags = f.Flags & ~FrameFlags.Undecodable }); + .ConvertAll(f => ArchiveImages.ServerNeedsProxy(f.Format) && !ArchiveImages.NeedsProxy(decoder, f.Format) + ? f with { Flags = f.Flags & ~FrameFlags.Undecodable } + : f); var files = await DownloadAsync(claimed, frames, work, reporter, cancellationToken).ConfigureAwait(false); var input = new SequenceFrames(sequence, frames, [.. frames.Select(f => files.GetValueOrDefault(f.Id).Path)]) { @@ -357,10 +361,12 @@ public sealed class RenderNodeClient : IAsyncDisposable NodeReporter reporter, CancellationToken cancellationToken) { var formats = rows.ToDictionary(f => f.Id, f => f.Format); + var undecodable = rows.Where(f => (f.Flags & FrameFlags.Undecodable) != 0).Select(f => f.Id).ToHashSet(); bool Proxy(ManifestFrame f) => f.HasProxy && (claimed.UseProxies || (formats.TryGetValue(f.Id, out var format) && ArchiveImages.NeedsProxy(_processing.Archive.Decoder, format))); var files = new Dictionary(); - var fetched = claimed.Frames.Where(f => ((FrameFlags)f.Flags & NotFetched) == 0).ToList(); + // An original that stays undecodable would only be skipped by the render. + var fetched = claimed.Frames.Where(f => ((FrameFlags)f.Flags & NotFetched) == 0 && (Proxy(f) || !undecodable.Contains(f.Id))).ToList(); var done = 0; var total = fetched.Count; await reporter.ReportAsync(0, total, Loc.L("Export.Job.Downloading")).ConfigureAwait(false); diff --git a/src/Titano.Server/Api/FileEndpoints.cs b/src/Titano.Server/Api/FileEndpoints.cs index 42f273f7..d7090edb 100644 --- a/src/Titano.Server/Api/FileEndpoints.cs +++ b/src/Titano.Server/Api/FileEndpoints.cs @@ -58,10 +58,12 @@ public static class FileEndpoints } /// - /// Files the body (a JPEG made from the original, its Exif capture time the frame's, at most - /// ) as the frame's proxy; the sequence's thumbnails and proxy state follow as - /// background jobs. 204; 413 too_large, 422 invalid_proxy or proxy_mismatch, 409 - /// proxies_disabled, 503 archive_offline. + /// Files the body (a JPEG made from the original, its Exif capture time the frame's, as large as the archive's proxies, + /// at most ) as the proxy of a frame the server cannot decode + /// (); the sequence's thumbnails and proxy state follow as background jobs. 204; 413 + /// too_large; 422 proxy_not_wanted (the server decodes that original itself, or it is missing or + /// damaged), invalid_proxy, proxy_mismatch or proxy_too_small, which concern that proxy only; 409 + /// proxies_disabled, which concerns them all; 503 archive_offline. /// private static async Task StoreProxyAsync(HttpContext context, Guid id, TitanoDatabase db, ServerArchive archive, [FromServices] ArchiveService? archives, SequenceJobs follow) @@ -69,6 +71,9 @@ public static class FileEndpoints var ct = context.RequestAborted; if (await db.Frames.GetAsync(id, ct) is not { } frame || await db.Sequences.GetAsync(frame.SequenceId, ct) is not { } sequence) return ApiErrors.NotFound(context, "frame"); + // A proxy replaces the server's own of an original it decodes, which renders and remote views would then show. + if (!ServerProxies.CannotDecode(frame.Format) || (frame.Flags & (FrameFlags.Missing | FrameFlags.Corrupt)) != 0) + return ApiErrors.Result(context, StatusCodes.Status422UnprocessableEntity, "proxy_not_wanted"); if (context.Request.ContentLength is > ArchiveImages.MaxProxyBytes) return ApiErrors.Result(context, StatusCodes.Status413PayloadTooLarge, "too_large"); // Proxies are larger than the JSON bodies Kestrel is limited to; reading past this answers 413. if (context.Features.Get() is { IsReadOnly: false } limit) limit.MaxRequestBodySize = ArchiveImages.MaxProxyBytes; @@ -93,8 +98,11 @@ public static class FileEndpoints return ApiErrors.Result(context, StatusCodes.Status422UnprocessableEntity, "invalid_proxy"); case ProxyStoreResult.WrongFrame: return ApiErrors.Result(context, StatusCodes.Status422UnprocessableEntity, "proxy_mismatch"); + case ProxyStoreResult.TooSmall: + return ApiErrors.Result(context, StatusCodes.Status422UnprocessableEntity, "proxy_too_small"); } - await follow.ProxyArrivedAsync(sequence, ct); + // The proxy is filed: its follow-up is queued even when the sender is gone by now. + await follow.ProxyArrivedAsync(sequence, CancellationToken.None); return Results.NoContent(); } diff --git a/src/Titano.Server/Storage/ServerProxies.cs b/src/Titano.Server/Storage/ServerProxies.cs index fd70e4e5..34e73cc3 100644 --- a/src/Titano.Server/Storage/ServerProxies.cs +++ b/src/Titano.Server/Storage/ServerProxies.cs @@ -1,6 +1,5 @@ using Titano.Core.Archiving; using Titano.Core.Imaging; -using Titano.Core.Imaging.Decoders; using Titano.Core.Model; using Titano.Data; using Titano.Data.Archiving; @@ -17,11 +16,8 @@ public static class ServerProxies { private const int Page = 1000; - /// The server's decoders (BRIEF §4.2: managed only). - private static readonly ImageDecoder Decoder = DecoderFactory.CreateServer(); - - /// The server takes this format's pixels from proxies made elsewhere. - public static bool CannotDecode(ImageFileFormat format) => ArchiveImages.NeedsProxy(Decoder, format); + /// The server takes this format's pixels from proxies made elsewhere (its decoders are managed only, BRIEF §4.2). + public static bool CannotDecode(ImageFileFormat format) => ArchiveImages.ServerNeedsProxy(format); /// How proxies of the archive are made; null when it makes none (or its manifest cannot be read now). public static ProxySpec? Spec(Archive archive) diff --git a/tests/Titano.Data.Tests/Archiving/ProxyTests.cs b/tests/Titano.Data.Tests/Archiving/ProxyTests.cs index f7b86b17..0fc493fa 100644 --- a/tests/Titano.Data.Tests/Archiving/ProxyTests.cs +++ b/tests/Titano.Data.Tests/Archiving/ProxyTests.cs @@ -78,6 +78,34 @@ public sealed class ProxyTests(TestContext context) Assert.False((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.ProxiesBuilt)); } + [Test] + public async Task AProxyMadeFromAPreviewIsAskedForAgain() + { + await using var fx = await CreateAsync(context); + var (sequence, frames) = await HeifSequenceAsync(fx, 4032, 3024); + var folder = fx.Paths.Sequence(sequence.Folder); + var images = fx.Service.Images; + // An earlier version made the frame's proxy here from the original's embedded preview: the frame's capture time, + // a thumbnail's size. + Directory.CreateDirectory(folder.Proxies); + await File.WriteAllBytesAsync(folder.Proxy(0), Proxy(frames[0].CapturedAt!.Value, 5, 160, 120), fx.Ct); + await fx.Db.Sequences.UpdateStatusAsync(sequence.Id, SequenceStatus.ProxiesBuilt, SequenceStatus.None, fx.Ct); + + var proxies = await images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); + + Assert.Equal((0, 0, 2), (proxies.Built, proxies.Reused, proxies.Undecodable)); + Assert.FileMissing(folder.Proxy(0)); + Assert.False((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.ProxiesBuilt), "asked for again"); + + // A client or render node sending one that small is refused; one of the policy's size (1920 px) is kept. + var frame = frames[0] with { Width = 4032, Height = 3024 }; + Assert.Equal(ProxyStoreResult.TooSmall, images.StoreProxy(fx.Archive, sequence, frame, Proxy(frame.CapturedAt!.Value, 6, 160, 120))); + Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frame, Proxy(frame.CapturedAt!.Value, 7, 1920, 1440))); + var again = await images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); + Assert.Equal((0, 1, 1), (again.Built, again.Reused, again.Undecodable)); + Assert.FileExists(folder.Proxy(0)); + } + [Test] public async Task AnArchiveWithoutProxiesRefusesThem() { @@ -90,8 +118,11 @@ public sealed class ProxyTests(TestContext context) Assert.FileMissing(fx.Paths.Sequence(sequence.Folder).Proxy(0)); } - /// Two ingested frames whose originals the archive engine takes for HEIF (its decoders read none). - private static async Task<(Sequence Sequence, IReadOnlyList Frames)> HeifSequenceAsync(ArchiveFixture fx) + /// + /// Two ingested frames whose originals the archive engine takes for HEIF (its decoders read none), their size in the + /// sidecar × when given. + /// + private static async Task<(Sequence Sequence, IReadOnlyList Frames)> HeifSequenceAsync(ArchiveFixture fx, int? width = null, int? height = null) { Guid id = default; for (var i = 0; i < 2; i++) @@ -103,14 +134,17 @@ public sealed class ProxyTests(TestContext context) var sequence = (await fx.Db.Sequences.GetAsync(id, fx.Ct))!; var folder = fx.Paths.Sequence(sequence.Folder); var sidecar = ManifestStore.ReadSequence(folder.ManifestPath); - ManifestStore.WriteSequence(folder.ManifestPath, sidecar with { Frames = [.. sidecar.Frames.Select(f => f with { Format = ImageFileFormat.Heif })] }); + ManifestStore.WriteSequence(folder.ManifestPath, sidecar with + { + Frames = [.. sidecar.Frames.Select(f => f with { Format = ImageFileFormat.Heif, W = width ?? f.W, H = height ?? f.H })], + }); return (sequence, await fx.Db.Frames.ListBySequenceAsync(id)); } - /// A 320 × 240 JPEG proxy with in its Exif, as a client makes it. - private static byte[] Proxy(DateTime captured, int seed) + /// A JPEG proxy (320 × 240 unless sized) with in its Exif, as a client makes it. + private static byte[] Proxy(DateTime captured, int seed, int width = 320, int height = 240) { - using var image = new ImageBuffer(320, 240); + using var image = new ImageBuffer(width, height); var level = 0.2f + seed % 5 * 0.1f; for (var c = 0; c < 3; c++) image.Plane(c).Fill(level + c * 0.05f); var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { CapturedAt = captured, Software = "Titano" }); diff --git a/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs b/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs index 5b35d8a7..6f417329 100644 --- a/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs +++ b/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs @@ -69,9 +69,11 @@ public sealed class RenderNodeClientTests(TestContext context) var sequenceId = await UploadSequenceAsync(editor, Photos()[..3]); await Uploads.UploadAsync(editor, [0, 0, 0, 24, .. "ftypheic"u8, 0, 0, 0, 0, .. "mif1heic"u8, .. Uploads.Photo(2000, 9)], "IMG_0004.HEIC", sequenceId); var frames = await server.Database.Frames.ListBySequenceAsync(sequenceId); - // Frame 1 is gone from the server, frame 2 was adopted and never hashed, frame 4 is a HEIF the server cannot decode. + // Frame 1 is gone from the server, frame 2 was adopted and never hashed, frame 3 is damaged (the server could not + // decode it) and frame 4 is a HEIF the server cannot decode. File.Delete(Path.Combine(server.Options.ArchivePath, frames[0].RelativePath)); await server.Database.Frames.UpdateFlagsAsync([frames[0].Id], FrameFlags.Missing, FrameFlags.None); + await server.Database.Frames.UpdateFlagsAsync([frames[2].Id, frames[3].Id], FrameFlags.Undecodable, FrameFlags.None); await using (var session = await server.Database.Database.OpenAsync(context.Cancellation)) { await session.ExecuteAsync("UPDATE frames SET sha256 = NULL WHERE id = $1", [frames[1].Id], context.Cancellation); @@ -89,6 +91,9 @@ public sealed class RenderNodeClientTests(TestContext context) Assert.Equal("done", done.State, done.Error); Assert.DoesNotContain($"/api/v1/frames/{frames[0].Id}/original", requests.Paths); Assert.Contains($"/api/v1/frames/{frames[1].Id}/original", requests.Paths); + // The damaged frame stays out, as in the server's own render; the HEIF renders from its original here. + Assert.DoesNotContain($"/api/v1/frames/{frames[2].Id}/original", requests.Paths); + Assert.Contains($"/api/v1/frames/{frames[3].Id}/original", requests.Paths); var sequence = (await server.Database.Sequences.GetAsync(sequenceId))!; var proxy = new ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder).Proxy(frames[3].Index); Assert.Equal(frames[3].CapturedAt, MetadataReader.Read(proxy).CapturedAt, "the proxy the server asked for, with the frame's capture time"); diff --git a/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs b/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs index 688343b9..2e0811ba 100644 --- a/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs +++ b/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs @@ -70,6 +70,9 @@ public sealed class ProxyUploadTests(TestContext context) var upload = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 11)), "IMG_0001.JPG", sessionKey: "roof"); Assert.False((await ManifestAsync(editor, upload.SequenceId)).Frames.Single().WantsProxy); + // Nor takes one: renders and remote views keep the proxy the server makes itself. + using var refused = await PutAsync(editor, upload.FrameId, Proxy(new DateTime(2026, 9, 28, 18, 2, 11))); + await refused.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_not_wanted"); } /// A HEIF file as far as signature sniffing goes (an ftyp box naming heic), with no pixels the server can read.