From 5599e4de894cd3bad2d86768d6225b0ca60cc408 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 11:17:49 +0000 Subject: [PATCH] fix(imaging): record only what decoding proves and find GPR JPEGs across sequences - Preview sizes come from probes and unscaled decodes: a size-limited decode picks the smallest preview that reaches its edge (CR3 PRVW 1620x1080), so renders and deep passes record its tier without a size and the output cap keeps the largest preview's. - A read error is not an undecodable file: ImageDecoder.Decode throws the IOException when a provider could not read the file and none produced pixels. Deep passes never flag frames they could not read or that vanished, and frames only an interrupted earlier run found undecodable are decoded again before they are flagged. - Renders resolve stand-ins only for frames the pipeline asks for; frames the read-ahead meets on the way (skipped by speed-ups) are left alone. - A GoPro GPR finds its JPEG in the index when an import or upload kept it in a sequence of its own (same original stem and capture time), for probes, deep analysis, renders, thumbnails, proxies and the editor; GPRs whose JPEG is indexed later are probed again. - Thumbnails judge an embedded preview by its own JPEG header. - PostgreSQL writes tier fields 1000 frames per statement. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- docs/ARCHITECTURE.md | 2 +- src/Titano.App/Editor/LocalSequenceSource.cs | 9 +- .../Archiving/FrameImageRenderer.cs | 30 ++-- .../Decoders/ManagedDecoderProvider.cs | 47 +++--- src/Titano.Core/Imaging/Decoding.cs | 29 +++- src/Titano.Data/Archiving/ArchiveImages.cs | 18 ++- src/Titano.Data/Archiving/FrameTiers.cs | 19 ++- src/Titano.Data/Archiving/GprCompanions.cs | 63 ++++++++ .../Processing/Jobs/RenderJobHandler.cs | 4 +- .../Processing/SequenceAnalyser.cs | 47 ++++-- .../Processing/SequenceFrameSource.cs | 96 ++++++++---- src/Titano.Data/Processing/SequenceRender.cs | 5 +- .../Repositories/FrameRepository.cs | 40 ++++- .../Archiving/DecodeTierTests.cs | 61 ++++++-- .../Decoding/ManagedDecoderProviderTests.cs | 54 +++++++ .../Processing/AnalysisJobTests.cs | 137 ++++++++++++++++++ .../Processing/ProcessingFixture.cs | 30 +++- .../Processing/RenderJobTests.cs | 99 +++++++++++++ .../Repositories/CatalogRepositoryTests.cs | 10 +- 19 files changed, 689 insertions(+), 111 deletions(-) create mode 100644 src/Titano.Data/Archiving/GprCompanions.cs diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index b22dacd6..08085490 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -56,7 +56,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | `Migrations/{sqlite,postgres}/NNNN_name.sql` | Embedded, applied in one transaction at open (`MigrationRunner`) | | `Repositories` | `TitanoDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit | | `Jobs` | `JobEngine`, `IJobHandler`, `IJobHandlerProvider`, `JobContext` (progress, checkpoints, follow-up jobs) | -| `Archiving` | `ArchiveService` (create/adopt/open), `ArchiveIndexer` (scan, rebuild), `ArchiveIngest` (uploads and imports), `ImportService`, `ArchiveVerifier`, `ArchiveImages`, `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `ArchiveMaintenance`, `MassRenamer`, `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails), job handlers | +| `Archiving` | `ArchiveService` (create/adopt/open), `ArchiveIndexer` (scan, rebuild), `ArchiveIngest` (uploads and imports), `ImportService`, `ArchiveVerifier`, `ArchiveImages`, `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance`, `MassRenamer`, `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails), job handlers | | `Processing` | `ProcessingService`, `SequenceAnalyser`, `SequenceRender`, `ProjectStore`, `RenderNodeClient`, job handlers | | `Sync` | `SyncService` (sync table of one server: compare, link by content, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, no I/O), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `TitanoSyncRemote` over `TitanoClient`) | diff --git a/src/Titano.App/Editor/LocalSequenceSource.cs b/src/Titano.App/Editor/LocalSequenceSource.cs index 6395d6be..cc6e98dc 100644 --- a/src/Titano.App/Editor/LocalSequenceSource.cs +++ b/src/Titano.App/Editor/LocalSequenceSource.cs @@ -37,6 +37,9 @@ public sealed class LocalSequenceSource : ISequenceSource private readonly JobEngine? _engine; private readonly ArchiveServiceOptions _lease; private string?[] _files = []; + + /// The JPEG of each GPR frame that an import keeps in another sequence (), by position. + private string?[] _companions = []; private Guid[] _frameIds = []; private ArchivePaths? _paths; private SequencePaths? _folder; @@ -81,6 +84,7 @@ public sealed class LocalSequenceSource : ISequenceSource if (page.Count < PageSize) break; } var renders = await _db.Renders.ListBySequenceAsync(_sequenceId, cancellationToken); + var companions = await GprCompanions.FindAsync(_db, archive, frames, cancellationToken); return await Task.Run(() => { var paths = new ArchivePaths(archive.RootPath); @@ -90,6 +94,7 @@ public sealed class LocalSequenceSource : ISequenceSource { if ((frames[i].Flags & FrameFlags.Missing) == 0) files[i] = paths.FromRelative(frames[i].RelativePath); } + _companions = [.. frames.Select(f => companions.GetValueOrDefault(f.Id))]; (_paths, _folder, _files, _frameIds) = (paths, folder, files, [.. frames.Select(f => f.Id)]); var context = SequenceContext.FromFrames(frames); return new SequenceContent(sequence, frames, ReadProject(sequence, folder), LightAnalyzer.Analyze(frames), ReadReport(folder, frames.Count), @@ -100,12 +105,14 @@ public sealed class LocalSequenceSource : ISequenceSource public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { if ((uint)index >= (uint)_files.Length || _files[index] is not { } file) return null; + var companions = _companions; + var companion = (uint)index < (uint)companions.Length ? companions[index] : null; return await Task.Run(() => { try { // Thumbnails take an embedded preview when it is large enough (no RAW development for a filmstrip cell). - var request = new DecodeRequest(file, maxLongEdge, purpose, ForcePreview: purpose == DecodePurpose.Thumbnail); + var request = new DecodeRequest(file, maxLongEdge, purpose, ForcePreview: purpose == DecodePurpose.Thumbnail, Companion: companion); return _decoder.Decode(request, cancellationToken)?.Pixels; } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) diff --git a/src/Titano.Core/Archiving/FrameImageRenderer.cs b/src/Titano.Core/Archiving/FrameImageRenderer.cs index 5e37bc61..fd91120d 100644 --- a/src/Titano.Core/Archiving/FrameImageRenderer.cs +++ b/src/Titano.Core/Archiving/FrameImageRenderer.cs @@ -18,19 +18,22 @@ public sealed class FrameImageRenderer(ImageDecoder decoder) public const int ThumbnailQuality = 80; /// A 320 px q80 thumbnail, or null when no decoder can read the frame. - public EncodedImage? Thumbnail(SequencePaths sequence, SidecarFrame frame, CancellationToken cancellationToken = default) + /// Where a GPR's JPEG is kept when it is not beside it (). + public EncodedImage? Thumbnail(SequencePaths sequence, SidecarFrame frame, CancellationToken cancellationToken = default, string? companion = null) { - using var decoded = Decode(sequence.File(frame.File), frame, ThumbnailLongEdge, DecodePurpose.Thumbnail, preferPreview: true, cancellationToken); + using var decoded = Decode(sequence.File(frame.File), frame, ThumbnailLongEdge, DecodePurpose.Thumbnail, preferPreview: true, companion, cancellationToken); if (decoded is null) return null; using var small = Resampler.Thumbnail(decoded.Pixels, ThumbnailLongEdge); return Encode(small, new JpegEncodeOptions { Quality = ThumbnailQuality }, decoded.Tier); } /// A proxy at the policy's long edge and quality with capture time and camera in its Exif; null when undecodable. - public EncodedImage? Proxy(SequencePaths sequence, SidecarFrame frame, SidecarCamera? camera, ProxyPolicy policy, CancellationToken cancellationToken = default) + /// Where a GPR's JPEG is kept when it is not beside it (). + public EncodedImage? Proxy(SequencePaths sequence, SidecarFrame frame, SidecarCamera? camera, ProxyPolicy policy, CancellationToken cancellationToken = default, + string? companion = null) { if (policy.LongEdge == ProxyPolicy.Disabled) throw new InvalidOperationException("Proxies are disabled for this archive."); - using var decoded = Decode(sequence.File(frame.File), frame, policy.LongEdge, DecodePurpose.Proxy, preferPreview: false, cancellationToken); + using var decoded = Decode(sequence.File(frame.File), frame, policy.LongEdge, DecodePurpose.Proxy, preferPreview: false, companion, cancellationToken); if (decoded is null) return null; var source = decoded.Pixels; var (w, h) = policy.LongEdge == ProxyPolicy.FullSize ? (source.Width, source.Height) : Resampler.FitWithin(source.Width, source.Height, policy.LongEdge); @@ -59,25 +62,30 @@ public sealed class FrameImageRenderer(ImageDecoder decoder) /// /// The frame's pixels: a JPEG through the managed decoder, the stored embedded preview when /// and it reaches (a smaller one would be upscaled or leave the thumbnail short), then - /// the host's decoders, and the stored preview as the last resort. Null when nothing decodes. + /// the host's decoders (with the GPR's ), and the stored preview as the last resort. Null + /// when nothing decodes. /// - private DecodedFrame? Decode(string path, SidecarFrame frame, int maxLongEdge, DecodePurpose purpose, bool preferPreview, CancellationToken cancellationToken) + /// The file could not be read. + private DecodedFrame? Decode(string path, SidecarFrame frame, int maxLongEdge, DecodePurpose purpose, bool preferPreview, string? companion, + CancellationToken cancellationToken) { if (frame.Format == ImageFileFormat.Jpeg && DecodeJpeg(File.ReadAllBytes(path), maxLongEdge, frame.Orientation, DecodeTier.Native) is { } jpeg) return jpeg; byte[]? preview = null; - if (preferPreview && (preview = ReadPreview(path, frame)) is not null && Reaches(preview, frame, maxLongEdge) + if (preferPreview && (preview = ReadPreview(path, frame)) is not null && Reaches(preview, maxLongEdge) && DecodeJpeg(preview, maxLongEdge, frame.Orientation, DecodeTier.EmbeddedPreview) is { } fast) return fast; - var request = new DecodeRequest(path, System.Math.Max(0, maxLongEdge), purpose, ApplyOrientation: true, AllowPreview: true); + var request = new DecodeRequest(path, System.Math.Max(0, maxLongEdge), purpose, ApplyOrientation: true, AllowPreview: true, Companion: companion); if (decoder.Decode(request, cancellationToken) is { } decoded) return new DecodedFrame(decoded.Pixels, decoded.Tier); return (preview ?? ReadPreview(path, frame)) is { } fallback ? DecodeJpeg(fallback, maxLongEdge, frame.Orientation, DecodeTier.EmbeddedPreview) : null; } - /// Whether the stored preview's long edge reaches (the sidecar's size, else the JPEG's own). - private static bool Reaches(byte[] preview, SidecarFrame frame, int maxLongEdge) + /// + /// Whether the stored preview's long edge reaches , from the JPEG's own header: the + /// sidecar's preview size may be a GPR companion's, larger than the preview embedded in the file. + /// + private static bool Reaches(byte[] preview, int maxLongEdge) { if (maxLongEdge <= 0) return true; - if (frame is { PreviewW: { } w, PreviewH: { } h }) return int.Max(w, h) >= maxLongEdge; try { var info = JpegDecoder.ReadInfo(preview); diff --git a/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs b/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs index 4fa99fea..568ccf8f 100644 --- a/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs +++ b/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs @@ -11,7 +11,8 @@ namespace Titano.Core.Imaging.Decoders; /// The managed decoder (BRIEF §8.2), available on every platform and the only one on the server: JPEG, PNG and TIFF /// natively; DNG and the supported camera RAWs (CR2, NEF, ARW, PEF, RAF) through ; every other /// RAW, CR3 and HEIF through the largest suitable embedded JPEG preview, and GoPro GPR through the JPEG the camera writes -/// beside it when that is larger (BRIEF §8.1; VC-5 is out of scope); nothing for formats without either. +/// with it (beside it, or where says an import put it) when that is larger +/// (BRIEF §8.1; VC-5 is out of scope); nothing for formats without either. /// fast paths: JPEG DCT scaling and RAW CFA binning when /// allows, bilinear demosaicing for thumbnails and analysis, and to skip native /// RAW development. Results fit within MaxLongEdge (never upscaled) and are always RGB. @@ -59,16 +60,21 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider /// The tier for a file whose signature format is already known (the index's): JPEG, PNG and TIFF decode natively /// whatever they hold (damage shows only when decoding), so only RAW and HEIF files are opened. /// - public FileTier Probe(string path, ImageFileFormat format) + public FileTier Probe(string path, ImageFileFormat format) => Probe(path, format, null); + + /// + /// Where a GPR's JPEG is kept when it is not beside it (). + public FileTier Probe(string path, ImageFileFormat format, string? companion) { var family = ImageFormatInfo.Of(format).Family; - if (family is not (ImageFamily.Jpeg or ImageFamily.Png or ImageFamily.Tiff)) return Probe(path); + if (family is not (ImageFamily.Jpeg or ImageFamily.Png or ImageFamily.Tiff)) return Probe(path, companion); var decoder = family switch { ImageFamily.Jpeg => "managed-jpeg", ImageFamily.Png => "managed-png", _ => "managed-tiff" }; return new FileTier(format, DecodeTier.Native, decoder, null, 0, 0); } /// The tier this provider would use for the file at , without decoding pixels. - public FileTier Probe(string path) + /// Where a GPR's JPEG is kept when it is not beside it (). + public FileTier Probe(string path, string? companion = null) { using var stream = Open(path); var format = ImageSignature.Detect(stream, path); @@ -94,23 +100,20 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider } var metadata = MetadataReader.Read(stream, path); var (pw, ph) = metadata.LargestPreview is { } preview ? PixelConvert.OrientedSize(preview.Width, preview.Height, metadata.Orientation) : (0, 0); - if (format == ImageFileFormat.Gpr && CompanionJpeg(path) is { } companion) - { - var jpeg = MetadataReader.Read(companion); - var (cw, ch) = jpeg.OrientedSize; - if (jpeg.Format == ImageFileFormat.Jpeg && int.Max(cw, ch) > int.Max(pw, ph)) - return new FileTier(format, DecodeTier.EmbeddedPreview, "managed-sidecar", reason, cw, ch); - } + if (format == ImageFileFormat.Gpr && CompanionSize(path, companion) is var (cw, ch) && int.Max(cw, ch) > int.Max(pw, ph)) + return new FileTier(format, DecodeTier.EmbeddedPreview, "managed-sidecar", reason, cw, ch); if (metadata.LargestPreview is null) return new FileTier(format, DecodeTier.Unavailable, null, reason + "; no embedded preview", 0, 0); return new FileTier(format, DecodeTier.EmbeddedPreview, "managed-preview", reason, pw, ph); } /// - /// The JPEG a GoPro writes beside a GPR (same name, .JPG), or null. Only the usual spellings are tried, so a - /// folder of thousands of frames is never listed once per frame. + /// The JPEG a GoPro writes with a GPR: when the caller found it elsewhere (an import + /// keeps it in a sequence of its own) and it is there, else the one beside the GPR (same name, .JPG), or + /// null. Only the usual spellings are tried, so a folder of thousands of frames is never listed once per frame. /// - internal static string? CompanionJpeg(string path) + internal static string? CompanionJpeg(string path, string? companion = null) { + if (companion is not null && File.Exists(companion)) return companion; var stem = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty, Path.GetFileNameWithoutExtension(path)); foreach (var extension in CompanionExtensions) { @@ -119,6 +122,15 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider return null; } + /// Oriented size of the GPR's JPEG (see ), or null when there is none. + /// The JPEG cannot be read. + private static (int Width, int Height)? CompanionSize(string path, string? companion) + { + if (CompanionJpeg(path, companion) is not { } file) return null; + var jpeg = MetadataReader.Read(file); + return jpeg.Format == ImageFileFormat.Jpeg ? jpeg.OrientedSize : null; + } + private static FileStream Open(string path) => new(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, FileBufferSize, FileOptions.RandomAccess); @@ -179,12 +191,13 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider } /// - /// GPR's pixel source: the GoPro's own JPEG beside it when it is larger than every embedded preview (the camera writes - /// it at full size), decoded with DCT scaling and oriented by its own Exif; null when there is none. + /// GPR's pixel source: the GoPro's own JPEG (, else beside it) when it is larger + /// than every embedded preview (the camera writes it at full size), decoded with DCT scaling and oriented by its own + /// Exif; null when there is none. /// private static DecodedImage? Companion(Stream raw, DecodeRequest request, CancellationToken cancellationToken) { - if (CompanionJpeg(request.Path) is not { } path) return null; + if (CompanionJpeg(request.Path, request.Companion) is not { } path) return null; var previews = MetadataReader.Read(raw, request.Path, cancellationToken: cancellationToken).Previews; var largestPreview = previews.Count > 0 ? int.Max(previews[0].Width, previews[0].Height) : 0; using var stream = Open(path); diff --git a/src/Titano.Core/Imaging/Decoding.cs b/src/Titano.Core/Imaging/Decoding.cs index 06a4c2d6..108831ae 100644 --- a/src/Titano.Core/Imaging/Decoding.cs +++ b/src/Titano.Core/Imaging/Decoding.cs @@ -1,3 +1,5 @@ +using System.Runtime.ExceptionServices; + namespace Titano.Core.Imaging; /// How a frame's pixels were obtained (BRIEF §8.2). Logged per frame. @@ -28,13 +30,16 @@ public enum DecodePurpose /// Rotate/flip according to the Exif orientation. /// Accept the embedded-preview tier when native decode is impossible. /// Use the embedded preview even when native decode is possible (fast paths). +/// The JPEG a GoPro wrote with this GPR when it is kept elsewhere than beside it (an import puts +/// it in a sequence of its own); null looks beside the file. Other formats ignore it. public sealed record DecodeRequest( string Path, int MaxLongEdge = 0, DecodePurpose Purpose = DecodePurpose.Render, bool ApplyOrientation = true, bool AllowPreview = true, - bool ForcePreview = false); + bool ForcePreview = false, + string? Companion = null); /// Decoded pixels plus how they were produced. Dispose to return the buffer to the pool. public sealed class DecodedImage(ImageBuffer pixels, DecodeTier tier, string decoder, int sourceWidth, int sourceHeight) : IDisposable @@ -84,6 +89,13 @@ public interface IImageDecoderProvider ? new FileTier(format, tier, Name, null, 0, 0) : new FileTier(format, DecodeTier.Unavailable, null, $"{Name}: no decoder for {format}", 0, 0); + /// + /// for a file whose camera companion (see + /// ) is kept at ; a provider that uses no + /// companion ignores it. + /// + FileTier Probe(string path, ImageFileFormat format, string? companion) => Probe(path, format); + /// Decodes or returns null when this provider cannot handle the specific file. DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default); } @@ -110,8 +122,9 @@ public sealed class ImageDecoder(IReadOnlyList providers) /// embedded preview a provider offers, else unavailable with the first reason given. A provider that finds the file /// malformed is skipped like in . /// + /// Where a GoPro GPR's JPEG is kept when it is not beside the file (). /// The file cannot be read. - public FileTier Probe(string path, ImageFileFormat format) + public FileTier Probe(string path, ImageFileFormat format, string? companion = null) { FileTier? preview = null; string? reason = null; @@ -121,7 +134,7 @@ public sealed class ImageDecoder(IReadOnlyList providers) FileTier tier; try { - tier = provider.Probe(path, format); + tier = provider.Probe(path, format, companion); } catch (Exception ex) when (ex is InvalidDataException or NotSupportedException or FormatException or InvalidOperationException or System.Runtime.InteropServices.COMException) @@ -137,11 +150,17 @@ public sealed class ImageDecoder(IReadOnlyList providers) return preview ?? new FileTier(format, DecodeTier.Unavailable, null, reason ?? $"no decoder for {format}", 0, 0); } - /// Decodes with the first provider that succeeds; null means . + /// + /// Decodes with the first provider that succeeds; null means : the providers read + /// the file and none produced pixels. When one could not read it (locked by another program, vanished, a network + /// read failed) and none produced pixels, nothing is known about the content, so that read error is thrown instead. + /// + /// The file could not be read and no provider produced pixels. public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { var format = ImageFormatInfo.FromPath(request.Path); List? errors = null; + IOException? unread = null; foreach (var provider in Providers.OrderBy(p => p.TierFor(format.Format) ?? DecodeTier.Unavailable)) { if (provider.TierFor(format.Format) is null) continue; @@ -158,8 +177,10 @@ public sealed class ImageDecoder(IReadOnlyList providers) catch (Exception ex) when (ex is IOException or InvalidDataException or NotSupportedException or FormatException or InvalidOperationException or System.Runtime.InteropServices.COMException) { (errors ??= []).Add(ex); + if (ex is IOException io) unread ??= io; } } + if (unread is not null) ExceptionDispatchInfo.Throw(unread); return null; } } diff --git a/src/Titano.Data/Archiving/ArchiveImages.cs b/src/Titano.Data/Archiving/ArchiveImages.cs index c2c6e8b5..6b11aa7a 100644 --- a/src/Titano.Data/Archiving/ArchiveImages.cs +++ b/src/Titano.Data/Archiving/ArchiveImages.cs @@ -47,6 +47,7 @@ public sealed class ArchiveImages var manifest = ManifestStore.ReadSequence(folder.ManifestPath); int built = 0, reused = 0, undecodable = 0; var tiers = new Dictionary(); + var companions = await GprCompanions.FindAsync(_db, archive, manifest.Frames, cancellationToken).ConfigureAwait(false); // Thumbnail writers exclude each other only; ingest keeps committing meanwhile. using (await LeaseFile.AcquireAsync(paths.LocksDirectory, $"thumbs-{sequence.Id:N}", _writer.Options.Owner, _writer.Options.LeaseWait, _writer.Options.LeaseDuration, cancellationToken).ConfigureAwait(false)) @@ -63,7 +64,8 @@ public sealed class ArchiveImages reused++; continue; } - if (Render(folder, frame, tiers, () => _renderer.Thumbnail(folder, frame, cancellationToken)) is { } image) + var companion = companions.GetValueOrDefault(frame.Id); + if (Render(folder, frame, companion, tiers, () => _renderer.Thumbnail(folder, frame, cancellationToken, companion)) is { } image) { pack.Append(frame.I, image.Width, image.Height, fingerprint, image.Jpeg); built++; @@ -98,6 +100,7 @@ public sealed class ArchiveImages Directory.CreateDirectory(folder.Proxies); int built = 0, reused = 0, undecodable = 0; var tiers = new Dictionary(); + var companions = await GprCompanions.FindAsync(_db, archive, manifest.Frames, cancellationToken).ConfigureAwait(false); var cadence = new Cadence(); for (var i = startFrame; i < manifest.Frames.Count; i++) { @@ -109,7 +112,8 @@ public sealed class ArchiveImages reused++; continue; } - if (Render(folder, frame, tiers, () => _renderer.Proxy(folder, frame, manifest.Camera, policy, cancellationToken)) is { } image) + var companion = companions.GetValueOrDefault(frame.Id); + if (Render(folder, frame, companion, tiers, () => _renderer.Proxy(folder, frame, manifest.Camera, policy, cancellationToken, companion)) is { } image) { AtomicFile.WriteAllBytes(path, image.Jpeg); built++; @@ -144,7 +148,7 @@ public sealed class ArchiveImages /// : unavailable when nothing decoded a file that is there (a read error proves nothing), and /// the probed tier when a frame flagged undecodable decoded after all. /// - private EncodedImage? Render(SequencePaths folder, SidecarFrame frame, Dictionary tiers, Func render) + private EncodedImage? Render(SequencePaths folder, SidecarFrame frame, string? companion, Dictionary tiers, Func render) { var path = folder.File(frame.File); EncodedImage? image; @@ -152,7 +156,7 @@ public sealed class ArchiveImages { image = render(); } - catch (IOException ex) + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { Core.Diagnostics.Log.Warning("archive", "Frame image could not be rendered", ex); return null; @@ -168,17 +172,17 @@ public sealed class ArchiveImages } else if ((frame.Flags & FrameFlags.Undecodable) != 0) { - tiers[frame.Id] = Reprobe(path, frame, image.Tier); + tiers[frame.Id] = Reprobe(path, frame, companion, image.Tier); } return image; } /// The tier of a frame that decoded after it was flagged undecodable (the image's own tier when probing finds none). - private FileTier Reprobe(string path, SidecarFrame frame, DecodeTier decoded) + private FileTier Reprobe(string path, SidecarFrame frame, string? companion, DecodeTier decoded) { try { - if (_writer.Options.Decoder.Probe(path, frame.Format) is { Tier: not DecodeTier.Unavailable } tier) return tier; + if (_writer.Options.Decoder.Probe(path, frame.Format, companion) is { Tier: not DecodeTier.Unavailable } tier) return tier; } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { diff --git a/src/Titano.Data/Archiving/FrameTiers.cs b/src/Titano.Data/Archiving/FrameTiers.cs index 245c89e5..8b7ae94d 100644 --- a/src/Titano.Data/Archiving/FrameTiers.cs +++ b/src/Titano.Data/Archiving/FrameTiers.cs @@ -17,20 +17,27 @@ namespace Titano.Data.Archiving; internal sealed class FrameTiers(TitanoDatabase db, SequenceWriter writer, ArchiveIndexer indexer) { /// - /// The tier of every frame of whose tier is not known yet, probed with the host's decoders - /// without decoding pixels; missing and unreadable files are left for later. + /// The tier of every frame of whose tier is not known yet, that decodes only through a + /// preview whose size is not known (the output cap needs it), or that is a GPR whose JPEG in another sequence + /// (; an upload may index it after the GPR was probed) is larger than its stored preview, + /// probed with the host's decoders without decoding pixels; missing and unreadable files are left for later. /// - public Dictionary ProbeUnknown(SequencePaths folder, SequenceManifest manifest, CancellationToken cancellationToken) + public async Task> ProbeUnknownAsync(Archive archive, SequencePaths folder, SequenceManifest manifest, + CancellationToken cancellationToken) { var tiers = new Dictionary(); - foreach (var frame in manifest.Frames) + var present = manifest.Frames.Where(f => (f.Flags & FrameFlags.Missing) == 0).ToList(); + var companions = await GprCompanions.FindWithSizesAsync(db, archive, present, cancellationToken).ConfigureAwait(false); + var unknown = present.Where(f => f.Tier == 0 || (f.Tier == DecodeTier.EmbeddedPreview && f.PreviewW is null) + || (companions.TryGetValue(f.Id, out var jpeg) + && int.Max(f.PreviewW ?? 0, f.PreviewH ?? 0) < int.Max(jpeg.Width, jpeg.Height))); + foreach (var frame in unknown) { - if (frame.Tier != 0 || (frame.Flags & FrameFlags.Missing) != 0) continue; cancellationToken.ThrowIfCancellationRequested(); var path = folder.File(frame.File); try { - var tier = writer.Options.Decoder.Probe(path, frame.Format); + var tier = writer.Options.Decoder.Probe(path, frame.Format, companions.TryGetValue(frame.Id, out var companion) ? companion.Path : null); Core.Diagnostics.Log.Debug("archive", $"{frame.File}: {tier.Tier} via {tier.Decoder ?? "none"}{(tier.Reason is { } why ? $" ({why})" : "")}"); tiers[frame.Id] = tier; } diff --git a/src/Titano.Data/Archiving/GprCompanions.cs b/src/Titano.Data/Archiving/GprCompanions.cs new file mode 100644 index 00000000..1f167de8 --- /dev/null +++ b/src/Titano.Data/Archiving/GprCompanions.cs @@ -0,0 +1,63 @@ +using Titano.Core.Archiving; +using Titano.Core.Imaging; +using Titano.Core.Model; + +namespace Titano.Data.Archiving; + +/// A GPR's JPEG: its absolute path and its size as the index has it (before orientation). +internal readonly record struct GprCompanion(string Path, int Width, int Height); + +/// +/// The JPEG a GoPro writes with each GPR, the server's pixel source for GPR (BRIEF §8.1; VC-5 is out of scope). In a +/// folder adopted in place it sits beside the GPR, where the decoder finds it itself. A card import or an upload splits +/// sessions per file format (DECISIONS 2026-10-02), so there it is a frame of another sequence: the archive's JPEG frame +/// whose original name has the GPR's stem and whose capture time is the GPR's (within a second). Looked up in the index +/// when frames are decoded, so renaming or moving either sequence never breaks the pair. +/// +public static class GprCompanions +{ + private static readonly TimeSpan Tolerance = TimeSpan.FromSeconds(1); + + /// + /// The absolute path of the JPEG of each GPR frame of (index rows), by frame id; frames + /// without one are left out. One index query, none when no frame is a GPR. + /// + public static async Task> FindAsync(TitanoDatabase db, Archive archive, IReadOnlyList frames, + CancellationToken cancellationToken) => + Paths(await FindAsync(db, archive, [.. frames.Where(f => f.Format == ImageFileFormat.Gpr).Select(f => (f.Id, f.OriginalFileName ?? f.FileName, f.CapturedAt))], + cancellationToken).ConfigureAwait(false)); + + /// + public static async Task> FindAsync(TitanoDatabase db, Archive archive, IReadOnlyList frames, + CancellationToken cancellationToken) => + Paths(await FindWithSizesAsync(db, archive, frames, cancellationToken).ConfigureAwait(false)); + + /// The JPEG of each GPR frame of (sidecar frames) with its indexed size, by frame id. + internal static Task> FindWithSizesAsync(TitanoDatabase db, Archive archive, IReadOnlyList frames, + CancellationToken cancellationToken) => + FindAsync(db, archive, [.. frames.Where(f => f.Format == ImageFileFormat.Gpr).Select(f => (f.Id, f.Original ?? Path.GetFileName(f.File), f.CapturedAt))], + cancellationToken); + + private static async Task> FindAsync(TitanoDatabase db, Archive archive, + List<(Guid Id, string Name, DateTime? CapturedAt)> gprs, CancellationToken cancellationToken) + { + var found = new Dictionary(); + var timed = gprs.Where(g => g.CapturedAt is not null).Select(g => (g.Id, Stem: Stem(g.Name), At: g.CapturedAt!.Value)).ToList(); + if (timed.Count == 0) return found; + var jpegs = await db.Frames.ListByCaptureRangeAsync(archive.Id, ImageFileFormat.Jpeg, timed.Min(g => g.At) - Tolerance, + timed.Max(g => g.At) + Tolerance, cancellationToken).ConfigureAwait(false); + var byStem = jpegs.Where(j => (j.Flags & FrameFlags.Missing) == 0 && j.CapturedAt is not null) + .ToLookup(j => Stem(j.OriginalFileName ?? j.FileName), StringComparer.OrdinalIgnoreCase); + var paths = new ArchivePaths(archive.RootPath); + foreach (var (id, stem, at) in timed) + { + var match = byStem[stem].Where(j => (j.CapturedAt!.Value - at).Duration() <= Tolerance).MinBy(j => (j.CapturedAt!.Value - at).Duration()); + if (match is not null) found[id] = new GprCompanion(paths.FromRelative(match.RelativePath), match.Width, match.Height); + } + return found; + } + + private static Dictionary Paths(Dictionary companions) => companions.ToDictionary(kv => kv.Key, kv => kv.Value.Path); + + private static string Stem(string fileName) => Path.GetFileNameWithoutExtension(fileName); +} diff --git a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs index 66446574..4dfb7efa 100644 --- a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs +++ b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs @@ -65,8 +65,10 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti if (targets.Count == 0) return; var frames = await SequenceFrames.LoadAsync(db, archive, sequence, parameters.UseProxies, cancellation).ConfigureAwait(false); + var companions = await GprCompanions.FindAsync(db, archive, frames.Frames, cancellation).ConfigureAwait(false); IReadOnlyList outcomes; - await using (var render = new SequenceRender(frames, project, SequenceAnalyser.ReadReport(folder, frames.Count), options, originals: !parameters.UseProxies)) + await using (var render = new SequenceRender(frames, project, SequenceAnalyser.ReadReport(folder, frames.Count), options, originals: !parameters.UseProxies, + companions)) { outcomes = await render.RenderAllAsync( targets, diff --git a/src/Titano.Data/Processing/SequenceAnalyser.cs b/src/Titano.Data/Processing/SequenceAnalyser.cs index 0122627f..4354c5d7 100644 --- a/src/Titano.Data/Processing/SequenceAnalyser.cs +++ b/src/Titano.Data/Processing/SequenceAnalyser.cs @@ -30,6 +30,9 @@ internal sealed record AnalysisOutcome(Sequence Sequence, int Frames, int Warnin /// internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions options, SequenceWriter writer, ArchiveIndexer indexer, ProjectStore projects) { + /// Long edge of the decode that confirms a frame an interrupted earlier run found undecodable. + private const int ConfirmLongEdge = 64; + private readonly FrameTiers _tiers = new(db, writer, indexer); /// Analyses one sequence; null when it is no longer in the index. @@ -43,15 +46,15 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti var folder = paths.Sequence(sequence.Folder); var frames = await SequenceFrames.LoadAsync(db, archive, sequence, useProxies: false, cancellationToken).ConfigureAwait(false); // Format tiers (BRIEF §10.1): frames indexed since the last analysis are probed with this host's decoders. - var probed = _tiers.ProbeUnknown(folder, ManifestStore.ReadSequence(folder.ManifestPath), cancellationToken); + var probed = await _tiers.ProbeUnknownAsync(archive, folder, ManifestStore.ReadSequence(folder.ManifestPath), cancellationToken).ConfigureAwait(false); frames = WithTiers(frames, await _tiers.RecordAsync(archive, sequence, probed, cancellationToken).ConfigureAwait(false)); var metadata = frames.LightFrames(); DeepAnalysisReport? report; if (deep) { - (report, var observed) = await AnalyseDeepAsync(frames, metadata, folder, progress, cancellationToken).ConfigureAwait(false); - frames = WithTiers(frames, await _tiers.RecordAsync(archive, sequence, Decoded(frames, report, observed), cancellationToken).ConfigureAwait(false)); + (report, var decoded) = await AnalyseDeepAsync(archive, frames, metadata, folder, progress, cancellationToken).ConfigureAwait(false); + frames = WithTiers(frames, await _tiers.RecordAsync(archive, sequence, decoded, cancellationToken).ConfigureAwait(false)); metadata = [.. metadata.Select((m, i) => m with { Flags = frames.Frames[i].Flags })]; } else @@ -128,35 +131,49 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti } /// - /// What the deep pass learnt about each frame's tier: the tier this run decoded it at, else (for frames analysed by - /// an interrupted earlier run) unavailable when the report says it did not decode. Missing and corrupt frames are not - /// decoded at all, so they say nothing. + /// What the deep pass learnt about each frame's tier, by frame id: the tier this run decoded it at. A frame this run + /// tried to read and recorded nothing for vanished or could not be read, which says nothing about its content. A frame + /// only an interrupted earlier run analysed and found undecodable is decoded again (small) to confirm it: that run's + /// failure may have been a read error too. Missing and corrupt frames are not decoded at all. /// - private static Dictionary Decoded(SequenceFrames frames, DeepAnalysisReport report, IReadOnlyDictionary observed) + private Dictionary Decoded(SequenceFrames frames, DeepAnalysisReport report, SequenceFrameSource source, + IReadOnlyDictionary companions, CancellationToken cancellationToken) { var tiers = new Dictionary(); - foreach (var (index, tier) in observed) tiers[frames.Frames[index].Id] = tier; + foreach (var (index, tier) in source.Observed) tiers[frames.Frames[index].Id] = tier; + var read = source.Read.ToHashSet(); foreach (var index in report.Issues.Undecodable) { - if (index >= frames.Count || observed.ContainsKey(index) || frames.Files[index] is null + if (index >= frames.Count || read.Contains(index) || frames.Files[index] is not { } path || (frames.Frames[index].Flags & SequenceFrames.NotAnalysed) != 0) continue; var frame = frames.Frames[index]; - tiers[frame.Id] = new FileTier(frame.Format, DecodeTier.Unavailable, null, "no decoder produced pixels", 0, 0); + try + { + using var decoded = options.Archive.Decoder.Decode( + new DecodeRequest(path, ConfirmLongEdge, DecodePurpose.Analysis, Companion: companions.GetValueOrDefault(frame.Id)), cancellationToken); + if (decoded is not null) tiers[frame.Id] = new FileTier(frame.Format, decoded.Tier, decoded.Decoder, null, 0, 0); + else if (File.Exists(path)) tiers[frame.Id] = new FileTier(frame.Format, DecodeTier.Unavailable, null, "no decoder produced pixels", 0, 0); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Core.Diagnostics.Log.Warning("processing", $"Frame {path} could not be read", ex); + } } return tiers; } - private async Task<(DeepAnalysisReport Report, IReadOnlyDictionary Observed)> AnalyseDeepAsync(SequenceFrames frames, + private async Task<(DeepAnalysisReport Report, Dictionary Decoded)> AnalyseDeepAsync(Archive archive, SequenceFrames frames, IReadOnlyList metadata, SequencePaths folder, IProgress? progress, CancellationToken cancellationToken) { var file = new DeepAnalysisCheckpointFile(Path.Combine(folder.MetaDirectory, DeepAnalysisCheckpointFile.FileName)); + var companions = await GprCompanions.FindAsync(db, archive, frames.Frames, cancellationToken).ConfigureAwait(false); DeepAnalysisReport report; - IReadOnlyDictionary observed; - await using (var source = new SequenceFrameSource(frames, metadata, options.Archive.Decoder) { Originals = true }) + Dictionary decoded; + await using (var source = new SequenceFrameSource(frames, metadata, options.Archive.Decoder) { Originals = true, Companions = companions }) { report = await DeepAnalyzer.AnalyzeAsync(source, options.DeepAnalysis, new FramesCheckpoint(file, ContentKey(frames)), progress, cancellationToken) .ConfigureAwait(false); - observed = source.Observed.ToDictionary(); + decoded = Decoded(frames, report, source, companions, cancellationToken); } report.Save(folder.AnalysisPath); file.Delete(); @@ -166,7 +183,7 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti for (var i = 0; i < stats.Length; i++) stats[i] = new FrameLightStats(frames.Frames[i].Id, columns.LogLuminance[i], columns.ClipLow[i], columns.ClipHigh[i]); await db.Frames.UpdateLightStatsAsync(stats, cancellationToken).ConfigureAwait(false); - return (report, observed); + return (report, decoded); } /// Identity of the analysed content: frames replaced or renumbered since a checkpoint was written (with the diff --git a/src/Titano.Data/Processing/SequenceFrameSource.cs b/src/Titano.Data/Processing/SequenceFrameSource.cs index 8fb0aaf9..17d4f5b4 100644 --- a/src/Titano.Data/Processing/SequenceFrameSource.cs +++ b/src/Titano.Data/Processing/SequenceFrameSource.cs @@ -15,7 +15,8 @@ namespace Titano.Data.Processing; /// still cannot be decoded stops the render with , unless the render gave /// : then the nearest planned frame that decodes stands in for it (BRIEF §8.2 tier 3: one /// unreadable frame never stops a render) and it is listed in . Render reads go through a -/// per decode size, which decodes ahead in index order and spills under memory pressure. +/// per decode size, which decodes ahead in index order and spills under memory pressure; only +/// frames the pipeline asks for get a stand-in, not those the read-ahead met on the way (a speed-up skips them). /// internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IAsyncDisposable { @@ -33,6 +34,7 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA private readonly ConcurrentDictionary _observed = new(); private readonly ConcurrentDictionary _standIns = new(); private readonly ConcurrentDictionary _failed = new(); + private readonly ConcurrentDictionary _read = new(); private FrameWindow? _window; private (int Edge, DecodePurpose Purpose) _windowKey; @@ -56,11 +58,24 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA public IReadOnlySet? RenderExcluded { get; init; } /// - /// Decode tier each frame decoded at, or when nothing decoded its file (sizes - /// oriented, as reports them); recorded only for . + /// The JPEG a GoPro wrote with each GPR frame that is not beside it, by frame id (). + /// + public IReadOnlyDictionary? Companions { get; init; } + + /// + /// Decode tier each frame decoded at, or when the decoders read its file and none + /// produced pixels; recorded only for . Sizes are oriented and given only where they are the + /// full size the tier delivers: a size-limited decode of a preview picks the smallest one that reaches the limit, so + /// it reports none and the stored size of the largest preview stays. /// public IReadOnlyDictionary Observed => _observed; + /// + /// Positions whose file this source tried to decode, whatever came of it (a read error or a vanished file records no + /// tier in ). + /// + public IReadOnlyCollection Read => [.. _read.Keys]; + /// Positions a render showed a neighbour for because they did not decode, ascending. public IReadOnlyList StandIns => [.. _standIns.Keys.Order()]; @@ -90,11 +105,11 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA { if (_window is not null) await _window.DisposeAsync().ConfigureAwait(false); _windowKey = (maxLongEdge, purpose); - _window = new FrameWindow(Count, (i, ct) => ValueTask.FromResult(DecodeForRender(i, maxLongEdge, purpose, ct)), _windowOptions); + _window = new FrameWindow(Count, (i, ct) => ValueTask.FromResult(Load(i, maxLongEdge, purpose, ct)), _windowOptions); } _window.MoveTo(index); - using var lease = await _window.GetAsync(index, cancellationToken).ConfigureAwait(false); - return lease.Image.Clone(); + return await ReadAsync(_window, index, cancellationToken).ConfigureAwait(false) + ?? await StandInAsync(_window, index, cancellationToken).ConfigureAwait(false); } finally { @@ -116,28 +131,50 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA } } - private ImageBuffer DecodeForRender(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) + /// + /// The window's loader, for the pipeline's reads and the read-ahead alike: the decoded frame, else + /// , remembered so the read-ahead does not decode the file again. + /// + private ImageBuffer Load(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { - if (Decode(index, maxLongEdge, purpose, cancellationToken) is { } decoded) return decoded.Pixels; - // A frame the plan leaves out is reached only by the window's read-ahead, which never hands it to the pipeline. - if (RenderExcluded is not { } excluded || excluded.Contains(index)) throw Unreadable(index); - // Flagged frames never get here, so this one became unreadable after it was last analysed (or is beyond this host's - // decoders): the nearest planned frame stands in, earlier first, and the render job records what decoding found. + if (!_failed.ContainsKey(index) && Decode(index, maxLongEdge, purpose, cancellationToken) is { } decoded) return decoded.Pixels; _failed.TryAdd(index, 0); + throw new NotDecodedException(); + } + + /// A copy of the window's frame, or null when it does not decode. + private static async ValueTask ReadAsync(FrameWindow window, int index, CancellationToken cancellationToken) + { + try + { + using var lease = await window.GetAsync(index, cancellationToken).ConfigureAwait(false); + return lease.Image.Clone(); + } + catch (NotDecodedException) + { + return null; + } + } + + /// + /// The pixels shown for a frame the pipeline asked for that does not decode. Flagged frames are not planned, so this + /// one became unreadable after it was last analysed (or is beyond this host's decoders): the nearest planned frame + /// that decodes stands in, earlier first, and the render job records what decoding found. Without + /// , or when nothing decodes, the render stops. + /// + private async ValueTask StandInAsync(FrameWindow window, int index, CancellationToken cancellationToken) + { + if (RenderExcluded is not { } excluded || excluded.Contains(index)) throw Unreadable(index); for (var distance = 1; distance < Count; distance++) { - ReadOnlySpan neighbours = [index - distance, index + distance]; - foreach (var neighbour in neighbours) + for (var side = -1; side <= 1; side += 2) { + var neighbour = index + side * distance; if (neighbour < 0 || neighbour >= Count || excluded.Contains(neighbour) || _failed.ContainsKey(neighbour)) continue; - if (Decode(neighbour, maxLongEdge, purpose, cancellationToken) is not { } standIn) - { - _failed.TryAdd(neighbour, 0); - continue; - } + if (await ReadAsync(window, neighbour, cancellationToken).ConfigureAwait(false) is not { } standIn) continue; _standIns.TryAdd(index, 0); Core.Diagnostics.Log.Warning("processing", $"Frame {index + 1} ({_frames.Frames[index].FileName}) does not decode; frame {neighbour + 1} stands in"); - return standIn.Pixels; + return standIn; } } throw Unreadable(index); @@ -146,23 +183,29 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA private DecodedImage? Decode(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { if (_frames.Files[index] is not { } file) return null; + _read.TryAdd(index, 0); + var frame = _frames.Frames[index]; DecodedImage? decoded; try { - decoded = _decoder.Decode(new DecodeRequest(file, maxLongEdge, purpose), cancellationToken); + var companion = Companions?.GetValueOrDefault(frame.Id); + decoded = _decoder.Decode(new DecodeRequest(file, maxLongEdge, purpose, Companion: companion), cancellationToken); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { + // The file was not read (locked, vanished, a network read failed): that says nothing about its content. Core.Diagnostics.Log.Warning("processing", $"Frame {file} could not be read", ex); return null; } // A file that vanished is missing, not undecodable (a verify flags it); only what decoding found is recorded. if (Originals && (decoded is not null || File.Exists(file))) { - var format = _frames.Frames[index].Format; - _observed[index] = decoded is null - ? new FileTier(format, DecodeTier.Unavailable, null, "no decoder produced pixels", 0, 0) - : new FileTier(format, decoded.Tier, decoded.Decoder, null, decoded.SourceWidth, decoded.SourceHeight); + _observed[index] = decoded switch + { + null => new FileTier(frame.Format, DecodeTier.Unavailable, null, "no decoder produced pixels", 0, 0), + { Tier: DecodeTier.EmbeddedPreview } when maxLongEdge > 0 => new FileTier(frame.Format, decoded.Tier, decoded.Decoder, null, 0, 0), + _ => new FileTier(frame.Format, decoded.Tier, decoded.Decoder, null, decoded.SourceWidth, decoded.SourceHeight), + }; } return decoded; } @@ -196,4 +239,7 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA return new RenderException(FrameUnreadableKey, $"Frame {index + 1} ({name}) could not be decoded.", [(index + 1).ToString(CultureInfo.InvariantCulture), name]); } + + /// A frame of the window that does not decode; resolves it, nothing else sees it. + private sealed class NotDecodedException : Exception; } diff --git a/src/Titano.Data/Processing/SequenceRender.cs b/src/Titano.Data/Processing/SequenceRender.cs index edf29c10..adcac592 100644 --- a/src/Titano.Data/Processing/SequenceRender.cs +++ b/src/Titano.Data/Processing/SequenceRender.cs @@ -32,7 +32,9 @@ internal sealed class SequenceRender : IAsyncDisposable /// The sequence's deep report, when current: its luminance spares the preparation a decode pass. /// The frames' files are the archive's originals (no proxies), so describes them. - public SequenceRender(SequenceFrames frames, ProjectSettings project, DeepAnalysisReport? analysis, ProcessingOptions options, bool originals = false) + /// The JPEG of each GPR frame kept in another sequence, by frame id (). + public SequenceRender(SequenceFrames frames, ProjectSettings project, DeepAnalysisReport? analysis, ProcessingOptions options, bool originals = false, + IReadOnlyDictionary? companions = null) { var metadata = frames.LightFrames(); var planned = project with { ExcludedFrames = [.. project.ExcludedFrames.Union(frames.NotRenderable()).Order()] }; @@ -41,6 +43,7 @@ internal sealed class SequenceRender : IAsyncDisposable { Originals = originals, RenderExcluded = planned.ExcludedFrames.ToHashSet(), + Companions = companions, }; _processing = options; _options = options.Render; diff --git a/src/Titano.Data/Repositories/FrameRepository.cs b/src/Titano.Data/Repositories/FrameRepository.cs index bac5ed69..c8eac1e3 100644 --- a/src/Titano.Data/Repositories/FrameRepository.cs +++ b/src/Titano.Data/Repositories/FrameRepository.cs @@ -138,10 +138,35 @@ public sealed class FrameRepository _db.InTransactionAsync(async session => { var updated = 0; - foreach (var f in frames) + if (_db.Sql.IsPostgres) { - updated += await session.ExecuteAsync("UPDATE frames SET flags = $2, preview_width = $3, preview_height = $4 WHERE id = $1", - [f.FrameId, (int)f.Flags, f.PreviewWidth, f.PreviewHeight], cancellationToken).ConfigureAwait(false); + // One UPDATE … FROM (VALUES …) per batch instead of a round trip per frame (a first analysis of a RAW sequence). + for (var start = 0; start < frames.Count; start += Batch) + { + var count = Math.Min(Batch, frames.Count - start); + var sql = new StringBuilder("UPDATE frames AS f SET flags = v.fl, preview_width = v.w, preview_height = v.h FROM (VALUES "); + var args = new DbParam[count * 4]; + for (var i = 0; i < count; i++) + { + var f = frames[start + i]; + sql.Append(i > 0 ? ", (" : "(").Append('$').Append(4 * i + 1).Append(", $").Append(4 * i + 2) + .Append(", $").Append(4 * i + 3).Append(", $").Append(4 * i + 4).Append(')'); + args[4 * i] = f.FrameId; + args[4 * i + 1] = (int)f.Flags; + args[4 * i + 2] = f.PreviewWidth; + args[4 * i + 3] = f.PreviewHeight; + } + sql.Append(") AS v(id, fl, w, h) WHERE f.id = v.id"); + updated += await session.ExecuteAsync(sql.ToString(), args, cancellationToken).ConfigureAwait(false); + } + } + else + { + foreach (var f in frames) + { + updated += await session.ExecuteAsync("UPDATE frames SET flags = $2, preview_width = $3, preview_height = $4 WHERE id = $1", + [f.FrameId, (int)f.Flags, f.PreviewWidth, f.PreviewHeight], cancellationToken).ConfigureAwait(false); + } } return updated; }, cancellationToken); @@ -189,6 +214,15 @@ public sealed class FrameRepository "WHERE s.archive_id = $1 AND f.size = $2 AND f.captured_at = $3", [archiveId, size, SequenceRepository.Wall(capturedAt)], Map, cancellationToken); + /// Frames of an archive in this format captured from to (inclusive), + /// by capture time (a GoPro GPR's JPEG in another sequence). + public Task> ListByCaptureRangeAsync(Guid archiveId, ImageFileFormat format, DateTime from, DateTime to, + CancellationToken cancellationToken = default) => + _db.ListAsync( + $"SELECT {string.Join(", ", ColumnNames.Select(c => "f." + c))} FROM frames f JOIN sequences s ON s.id = f.sequence_id " + + "WHERE s.archive_id = $1 AND f.format = $2 AND f.captured_at >= $3 AND f.captured_at <= $4 ORDER BY f.captured_at, f.id", + [archiveId, (int)format, SequenceRepository.Wall(from), SequenceRepository.Wall(to)], Map, cancellationToken); + /// Every frame of an archive whose SHA-256 occurs more than once, grouped by hash then sequence and index. public Task> ListDuplicatesAsync(Guid archiveId, CancellationToken cancellationToken = default) => _db.ListAsync( diff --git a/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs b/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs index 72e5c19a..49f548b2 100644 --- a/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs +++ b/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs @@ -9,6 +9,7 @@ using Titano.Core.Imaging; using Titano.Core.Imaging.Decoders; using Titano.Core.Metadata; using Titano.Core.Model; +using Titano.Core.Project; using Titano.Core.Tests.Analysis.Deep; using Titano.Core.Tests.Raw; using Titano.Testing; @@ -101,11 +102,12 @@ public sealed class DecodeTierTests(TestContext context) var dng = SyntheticDng.Write(scene, new DngSpec()); var renderer = new FrameImageRenderer(DecoderFactory.CreateServer()); - EncodedImage Thumbnail(string name, int previewWidth, bool sizeKnown) + EncodedImage Thumbnail(string name, int previewWidth, bool sizeKnown, int? storedWidth = null) { // The preview is appended after the DNG, which the TIFF offsets never reach. var preview = TestPhotos.Jpeg(Start, 3, width: previewWidth, height: previewWidth * 3 / 4); File.WriteAllBytes(Path.Combine(sequence.Originals, name), [.. dng, .. preview]); + var stored = storedWidth ?? previewWidth; var frame = new SidecarFrame { Id = Guid.CreateVersion7(), @@ -115,8 +117,8 @@ public sealed class DecodeTierTests(TestContext context) H = 480, PreviewOffset = dng.Length, PreviewLength = preview.Length, - PreviewW = sizeKnown ? previewWidth : null, - PreviewH = sizeKnown ? previewWidth * 3 / 4 : null, + PreviewW = sizeKnown ? stored : null, + PreviewH = sizeKnown ? stored * 3 / 4 : null, }; return renderer.Thumbnail(sequence, frame)!; } @@ -126,6 +128,9 @@ public sealed class DecodeTierTests(TestContext context) Assert.Equal((320, 240, DecodeTier.Native), (small.Width, small.Height, small.Tier)); var unknown = Thumbnail("unknown.dng", 200, sizeKnown: false); Assert.Equal((320, DecodeTier.Native), (unknown.Width, unknown.Tier)); + // The stored size can be a GPR companion's, larger than the embedded preview: the JPEG's own header decides. + var companionSized = Thumbnail("companion.dng", 200, sizeKnown: true, storedWidth: 4000); + Assert.Equal((320, DecodeTier.Native), (companionSized.Width, companionSized.Tier)); var large = Thumbnail("large.dng", 400, sizeKnown: true); Assert.Equal((320, 240, DecodeTier.EmbeddedPreview), (large.Width, large.Height, large.Tier)); Assert.Equal(320, JpegDecoder.ReadInfo(large.Jpeg).Width); @@ -177,22 +182,60 @@ public sealed class DecodeTierTests(TestContext context) [Test] public async Task FramesBothAnalysesFoundUndecodableAreListedOnce() { + // Frame 4 does not decode; frame 7 is not read either (missing, or beyond this host), which never flags it. var source = new SyntheticFrameSource(SyntheticSequence.Create(new SyntheticSequenceOptions { Width = 96, Height = 64, FrameCount = 12 })) { - Undecodable = [4], + Undecodable = [4, 7], }; var deep = await DeepAnalyzer.AnalyzeAsync(source, DeepScenes.Options); var metadata = Enumerable.Range(0, source.Count).Select(source.Metadata).ToList(); var context = new SequenceContext { FrameCount = source.Count, SourceWidth = 96, SourceHeight = 64 }; - // Before the deep pass flagged the frame, only its own finding names it. + // Before the deep pass flagged the frame, only its own finding names them. var unflagged = Advisor.Recommend(LightAnalyzer.Analyze(metadata), deep, context).Findings.Where(f => f.Key == DeepFindingKeys.UnreadableFrames).ToList(); - Assert.SequenceEqual([4], unflagged.Single().Frames); + Assert.SequenceEqual([4, 7], unflagged.Single().Frames); - // Once flagged, the light analysis lists it and the deep finding is not repeated. + // Once frame 4 is flagged both analyses report it: one finding over both lists, counted once. var flagged = metadata.Select(m => m.Index == 4 ? m with { Flags = FrameFlags.Undecodable } : m).ToList(); var light = LightAnalyzer.Analyze(flagged); - var findings = Advisor.Recommend(light, deep, context).Findings.Where(f => f.Key == DeepFindingKeys.UnreadableFrames).ToList(); - Assert.Same(light.Findings.Single(f => f.Key == DeepFindingKeys.UnreadableFrames), findings.Single()); + Assert.SequenceEqual([4], light.Findings.Single(f => f.Key == DeepFindingKeys.UnreadableFrames).Frames); + var merged = Advisor.Recommend(light, deep, context).Findings.Single(f => f.Key == DeepFindingKeys.UnreadableFrames); + Assert.SequenceEqual([4, 7], merged.Frames); + Assert.Equal((FindingSeverity.Warning, 2), (merged.Severity, Convert.ToInt32(merged.Arguments.Single()))); + + // A frame flagged since the deep pass (a render found it broken) joins the list too. + var later = LightAnalyzer.Analyze(flagged.Select(m => m.Index == 9 ? m with { Flags = FrameFlags.Undecodable } : m).ToList()); + var all = Advisor.Recommend(later, deep, context).Findings.Single(f => f.Key == DeepFindingKeys.UnreadableFrames); + Assert.Equal((3, 3), (all.Frames.Count, Convert.ToInt32(all.Arguments.Single()))); + } + + [Test] + public void FramesTheCamerasIntervalometerShotTimeTheirGapsAdaptively() + { + var metadata = new FrameMetadata { Format = ImageFileFormat.Rw2, IntervalShooting = true }; + Assert.Equal(FrameFlags.Intervalometer, SequenceFrames.FromMetadata(Guid.CreateVersion7(), "a.rw2", "a.rw2", 10, null, metadata).Flags); + Assert.Equal(FrameFlags.None, SequenceFrames.FromMetadata(Guid.CreateVersion7(), "b.rw2", "b.rw2", 10, null, metadata with { IntervalShooting = false }).Flags); + + // 60 frames 10 s apart with one 40 s gap: a sparse gap alone keeps the timing constant (motion unmeasured). + LightFrame Frame(int i, FrameFlags flags) => new() + { + Index = i, + CapturedAt = Start.AddSeconds(10 * i + (i >= 30 ? 30 : 0)), + Width = 6000, + Height = 4000, + Flags = flags, + }; + var context = new SequenceContext { FrameCount = 60, SourceWidth = 6000, SourceHeight = 4000 }; + var plain = LightAnalyzer.Analyze([.. Enumerable.Range(0, 60).Select(i => Frame(i, FrameFlags.None))]); + Assert.Equal(0, plain.IntervalometerFrames); + var free = Advisor.Recommend(plain, null, context).Find(AdvisorParameters.TimingMode)!; + Assert.Equal((AdvisorKeys.TimingSparseGaps, (object?)TimingMode.Constant), (free.ReasonKey, free.Value)); + + // The camera's own intervalometer shot them: its pause was deliberate, so adaptive timing keeps it short. + var shot = LightAnalyzer.Analyze([.. Enumerable.Range(0, 60).Select(i => Frame(i, FrameFlags.Intervalometer))]); + Assert.Equal(60, shot.IntervalometerFrames); + var advice = Advisor.Recommend(shot, null, context).Find(AdvisorParameters.TimingMode)!; + Assert.Equal((AdvisorKeys.TimingIntervalometer, (object?)TimingMode.Adaptive), (advice.ReasonKey, advice.Value)); + Assert.Equal(1, Convert.ToInt32(advice.ReasonArgs.Single())); } } diff --git a/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs b/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs index a3edf6a7..aa161f84 100644 --- a/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs +++ b/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs @@ -260,6 +260,52 @@ public sealed class ManagedDecoderProviderTests(TestContext context) Assert.Equal("managed-preview", new ManagedDecoderProvider().Probe(big).Decoder); } + [Test] + public void GoProRawDecodesThroughItsJpegWhereTheImportKeptIt() + { + // An import splits sessions per format: the JPEG lives in another sequence folder, under its imported name. + var gpr = Write("GOPR0003.GPR", Gpr(previewWidth: 64, previewHeight: 48)); + var elsewhere = Path.Combine(context.CreateTempDirectory("jpeg-sequence"), "2026-09-28_0003.JPG"); + File.WriteAllBytes(elsewhere, JpegFile(160, 120, 1)); + var server = DecoderFactory.CreateServer(); + + using (var decoded = server.Decode(new DecodeRequest(gpr, Companion: elsewhere))) + Assert.Equal(("managed-sidecar", 160, 120), (decoded!.Decoder, decoded.SourceWidth, decoded.SourceHeight)); + var probe = server.Probe(gpr, ImageFileFormat.Gpr, elsewhere); + Assert.Equal((DecodeTier.EmbeddedPreview, "managed-sidecar", 160, 120), (probe.Tier, probe.Decoder, probe.Width, probe.Height)); + + // A JPEG that is gone (deleted since) leaves the embedded preview; other formats ignore the companion. + var gone = Path.Combine(_dir, "gone.JPG"); + using (var preview = server.Decode(new DecodeRequest(gpr, Companion: gone))) + Assert.Equal(("managed-preview", 64), (preview!.Decoder, preview.Pixels.Width)); + Assert.Equal("managed-preview", server.Probe(gpr, ImageFileFormat.Gpr, gone).Decoder); + var jpeg = Write("plain.jpg", JpegFile(64, 48, 1)); + using (var plain = server.Decode(new DecodeRequest(jpeg, Companion: elsewhere))) + Assert.Equal(("managed-jpeg", 64), (plain!.Decoder, plain.SourceWidth)); + } + + [Test] + public void AFileNoProviderCouldReadIsAReadErrorNotAnUndecodableFile() + { + var path = Write("locked.jpg", JpegFile(64, 48, 1)); + // Every provider failed to read the file (locked by another program, a network read failed): nothing is known + // about its content, so the caller gets the read error instead of "nothing decodes it". + var unreadable = new ImageDecoder([new ScriptedProvider("a", _ => throw new IOException("sharing violation"))]); + Assert.Throws(() => unreadable.Decode(new DecodeRequest(path))); + // One provider read it and found nothing, another could not read it: still unproven. + var mixed = new ImageDecoder([new ScriptedProvider("a", _ => null), new ScriptedProvider("b", _ => throw new IOException("short read"))]); + Assert.Throws(() => mixed.Decode(new DecodeRequest(path))); + // A provider that produces pixels wins over one that could not read the file. + var recovered = new ImageDecoder([new ScriptedProvider("a", _ => throw new IOException("busy")), new ManagedDecoderProvider()]); + using (var image = recovered.Decode(new DecodeRequest(path))) + Assert.Equal("managed-jpeg", image!.Decoder); + // Providers that read the file and found it malformed prove it undecodable. + var damaged = new ImageDecoder([new ScriptedProvider("a", _ => throw new InvalidDataException("bad marker"))]); + Assert.Null(damaged.Decode(new DecodeRequest(path))); + Assert.Null(DecoderFactory.CreateServer().Decode(new DecodeRequest(Write("garbage.jpg", new byte[3000])))); + Assert.Throws(() => DecoderFactory.CreateServer().Decode(new DecodeRequest(Path.Combine(_dir, "vanished.jpg")))); + } + /// A GoPro GPR as far as Titano reads it: a DNG made by "GoPro" whose only decodable image is a YCbCr JPEG preview. private static byte[] Gpr(int previewWidth, int previewHeight) { @@ -286,4 +332,12 @@ public sealed class ManagedDecoderProviderTests(TestContext context) return null; } } + + /// A JPEG provider whose decode does what the test says (return nothing, or throw). + private sealed class ScriptedProvider(string name, Func decode) : IImageDecoderProvider + { + public string Name => name; + public DecodeTier? TierFor(ImageFileFormat format) => format == ImageFileFormat.Jpeg ? DecodeTier.Native : null; + public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => decode(request); + } } diff --git a/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs b/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs index c49fce15..eb531572 100644 --- a/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs +++ b/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs @@ -2,11 +2,16 @@ using Titano.Core.Advice; using Titano.Core.Analysis; using Titano.Core.Analysis.Deep; using Titano.Core.Archiving; +using Titano.Core.Codecs.Dng; +using Titano.Core.Codecs.Jpeg; using Titano.Core.Diagnostics.Synthetic; using Titano.Core.Imaging; +using Titano.Core.Import; using Titano.Core.Localization; +using Titano.Core.Metadata; using Titano.Core.Model; using Titano.Core.Project; +using Titano.Data.Archiving.Jobs; using Titano.Data.Processing; using Titano.Data.Processing.Jobs; using Titano.Data.Repositories; @@ -134,6 +139,138 @@ public sealed class AnalysisJobTests(TestContext context) Assert.Equal(JobState.Done, done.State); } + [Test] + public async Task AnImportedGoProRawDecodesThroughTheJpegItsImportKeptInAnotherSequence() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + // A GoPro card: each GPR (VC-5, without a usable embedded image here) has the camera's full-size JPEG beside it. + // An upload may send the GPRs first: they arrive as two cards here. + var raws = Path.Combine(context.CreateTempDirectory("card"), "DCIM", "100GOPRO"); + var jpegs = Path.Combine(context.CreateTempDirectory("card"), "DCIM", "100GOPRO"); + Directory.CreateDirectory(raws); + Directory.CreateDirectory(jpegs); + var start = new DateTime(2026, 9, 28, 18, 0, 0); + for (var i = 0; i < 4; i++) + { + var metadata = new FrameMetadata { Make = "GoPro", Model = "HERO12 Black", BodySerial = "C3501", CapturedAt = start.AddSeconds(5 * i) }; + using var sensor = new ImageBuffer(64, 48); + File.WriteAllBytes(Path.Combine(raws, $"GOPR{i + 1:0000}.GPR"), + LinearDngWriter.Write(sensor, new LinearDngOptions { Exif = ExifWriter.BuildTiff(metadata), TileSize = 64 })); + using var picture = new ImageBuffer(160, 120); + picture.Plane(1).Fill(0.25f * (i + 1)); + File.WriteAllBytes(Path.Combine(jpegs, $"GOPR{i + 1:0000}.JPG"), + JpegEncoder.Encode(picture, new JpegEncodeOptions { App1Segments = [ExifWriter.BuildJpegApp1(metadata)[4..]] })); + } + var service = fx.Archive.Service; + async Task ImportAsync(string card) + { + var plan = await service.PlanImportAsync(fx.Archive.Archive.Id, Path.GetDirectoryName(Path.GetDirectoryName(card))!, new ImportOptions(), + cancellationToken: fx.Ct); + await service.Imports.ExecuteAsync(new ImportJobParameters(fx.Archive.Archive.Id, plan, null, true, null), Guid.NewGuid(), 0, + _ => ValueTask.CompletedTask, null, fx.Ct); + return plan; + } + var gprSession = (await ImportAsync(raws)).Sessions.Single(); + Assert.Equal(ImageFileFormat.Gpr, gprSession.Format); + var id = await fx.Db.Sequences.FindBySessionKeyAsync(fx.Archive.Archive.Id, gprSession.SessionKey, fx.Ct); + var sequence = (await fx.Db.Sequences.GetAsync(id!.Value, fx.Ct))!; + await fx.StartEngineAsync(); + + // Alone, a GPR without an embedded preview gives no pixels here, which proves nothing about the file. + var first = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + await fx.WaitForAsync(first.Id, JobState.Done); + var alone = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; + Assert.True(alone.All(f => f is { Tier: DecodeTier.Unavailable, Flags: FrameFlags.None, PreviewW: null }), "unavailable, not flagged"); + + // The JPEGs arrive as a sequence of their own (the import splits per file format, DECISIONS 2026-10-02); the next + // probe finds each GPR's JPEG there, so the output cap is the JPEG's size. + Assert.Equal(ImageFileFormat.Jpeg, (await ImportAsync(jpegs)).Sessions.Single().Format); + var jpegFrame = (await fx.Db.Frames.ListByCaptureRangeAsync(fx.Archive.Archive.Id, ImageFileFormat.Jpeg, start, start.AddMinutes(1), fx.Ct))[0]; + Assert.NotEqual(Path.GetDirectoryName(fx.Folder(sequence).File(alone[0].File)), Path.GetDirectoryName(fx.Archive.Paths.FromRelative(jpegFrame.RelativePath)), + "not beside the GPR"); + var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + await fx.WaitForAsync(light.Id, JobState.Done); + var sidecar = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; + Assert.True(sidecar.All(f => f is { Tier: DecodeTier.EmbeddedPreview, Flags: FrameFlags.PreviewOnly, PreviewW: 160, PreviewH: 120 }), + "preview-only at the JPEG's size"); + + // The deep pass decodes the GPRs through those JPEGs (decoder "managed-sidecar"), never failing a frame. + var deep = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + await fx.WaitForAsync(deep.Id, JobState.Done); + var gprs = fx.Decoder.Decoded.Where(d => d.File.EndsWith(".GPR", StringComparison.OrdinalIgnoreCase)).ToList(); + Assert.NotEmpty(gprs); + Assert.True(gprs.All(d => d.Decoder == "managed-sidecar"), string.Join(", ", gprs.Select(d => d.Decoder).Distinct())); + Assert.Empty(SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!.Issues.Undecodable); + } + + [Test] + public async Task DeepAnalysisNeverFlagsFramesThatVanishedOrCouldNotBeRead() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Flickering(12)); + // Deleted after indexing (a verify flags it missing), and held by another program during the pass. + File.Delete(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(3))); + fx.Decoder.Unreadable[ProcessingFixture.FileName(6)] = 0; + await fx.StartEngineAsync(); + + var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + await fx.WaitForAsync(job.Id, JobState.Done); + + // The pass could not read them, so it lists them as unreadable, but nothing proves the files undecodable. + var report = SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!; + Assert.SequenceEqual([3, 6], report.Issues.Undecodable); + var sidecar = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; + foreach (var index in new[] { 3, 6 }) + { + Assert.Equal(FrameFlags.None, sidecar[index].Flags & FrameFlags.Undecodable); + Assert.NotEqual(DecodeTier.Unavailable, sidecar[index].Tier); + } + var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); + Assert.True(rows.All(f => (f.Flags & FrameFlags.Undecodable) == 0), "no frame flagged in the index"); + var unreadable = Advisor.Recommend(LightAnalyzer.Analyze(rows), report, SequenceContext.FromFrames(rows)).Findings + .Single(f => f.Key == DeepFindingKeys.UnreadableFrames); + Assert.SequenceEqual([3, 6], unreadable.Frames); + + // Back in place and readable, the next pass reads both frames. + fx.Decoder.Unreadable.Clear(); + await File.WriteAllBytesAsync(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(3)), + await File.ReadAllBytesAsync(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(2)), fx.Ct), fx.Ct); + var again = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + await fx.WaitForAsync(again.Id, JobState.Done); + Assert.Empty(SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!.Issues.Undecodable); + } + + [Test] + public async Task AResumedDeepAnalysisDecodesAgainWhatTheEarlierRunCouldNotRead() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Flickering()); + // The first run cannot read frame 12 (held by another program) and is cancelled later, at frame 26. + fx.Decoder.Unreadable[ProcessingFixture.FileName(11)] = 0; + fx.Decoder.HoldFrame(25); + await fx.StartEngineAsync(); + var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); + await fx.Engine.CancelAsync(job.Id, fx.Ct); + await fx.WaitForAsync(job.Id, JobState.Cancelled); + + // Readable again; the resumed run takes frame 12 from its checkpoint (it is not in the region sample). + fx.Decoder.Unreadable.Clear(); + fx.Decoder.Hold = null; + while (fx.Decoder.Requests.TryDequeue(out _)) + { + } + await fx.Engine.ResumeAsync(job.Id, fx.Ct); + await fx.WaitForAsync(job.Id, JobState.Done); + + Assert.Contains(11, SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!.Issues.Undecodable); + // That verdict was a read error: decoding the frame again shows it is fine, so nothing flags it. + Assert.Count(1, fx.Decoder.Requests.Where(r => Path.GetFileName(r.Path) == ProcessingFixture.FileName(11))); + var frame = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames[11]; + Assert.Equal((DecodeTier.Native, FrameFlags.None), (frame.Tier, frame.Flags & FrameFlags.Undecodable)); + Assert.Equal(FrameFlags.None, (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[11].Flags); + } + [Test] public async Task DeepAnalysisResumesAfterCancellationWithTheSameReport() { diff --git a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs index 8853d362..690ff8fd 100644 --- a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs +++ b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs @@ -123,25 +123,43 @@ internal sealed class GateDecoder : IImageDecoderProvider Hold = ProcessingFixture.FileName(index); } - /// Tiers reports per file name instead of the managed provider's (a host that reads them - /// only as previews, or not at all). + /// Tiers reports per file name instead of the managed provider's (a + /// host that reads them only as previews, or not at all). public ConcurrentDictionary Tiers { get; } = new(); + /// Files (by name) whose decodes report the embedded-preview tier from a preview of this oriented size, as + /// a size-limited decode that picked a smaller preview would. + public ConcurrentDictionary PreviewDecodes { get; } = new(); + + /// Files (by name) that cannot be read: their decodes throw (a sharing violation). + public ConcurrentDictionary Unreadable { get; } = new(); + + /// File name and decoder of every decode that produced pixels. + public ConcurrentQueue<(string File, string Decoder)> Decoded { get; } = new(); + public DecodeTier? TierFor(ImageFileFormat format) => _managed.TierFor(format); - public FileTier Probe(string path, ImageFileFormat format) => - Tiers.TryGetValue(Path.GetFileName(path), out var tier) ? tier : _managed.Probe(path, format); + public FileTier Probe(string path, ImageFileFormat format) => Probe(path, format, null); + + public FileTier Probe(string path, ImageFileFormat format, string? companion) => + Tiers.TryGetValue(Path.GetFileName(path), out var tier) ? tier : _managed.Probe(path, format, companion); public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { Requests.Enqueue(request); - if (Hold is { } hold && Path.GetFileName(request.Path) == hold && (HoldPurpose ?? request.Purpose) == request.Purpose + var name = Path.GetFileName(request.Path); + if (Hold is { } hold && name == hold && (HoldPurpose ?? request.Purpose) == request.Purpose && (HoldEdge ?? request.MaxLongEdge) == request.MaxLongEdge) { Holding.TrySetResult(); cancellationToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(30)); cancellationToken.ThrowIfCancellationRequested(); } - return _managed.Decode(request, cancellationToken); + if (Unreadable.ContainsKey(name)) throw new IOException($"The process cannot access the file '{request.Path}' because it is being used by another process."); + var decoded = _managed.Decode(request, cancellationToken); + if (decoded is null) return null; + Decoded.Enqueue((name, decoded.Decoder)); + if (!PreviewDecodes.TryGetValue(name, out var preview)) return decoded; + return new DecodedImage(decoded.Pixels, DecodeTier.EmbeddedPreview, "test-preview", preview.Width, preview.Height); } } diff --git a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs index c22757f4..9bfb19b0 100644 --- a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs +++ b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs @@ -128,6 +128,105 @@ public sealed class RenderJobTests(TestContext context) Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } + [Test] + public async Task AFrameThatCannotBeReadIsShownAsItsNeighbourButNeverFlagged() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + // Another program holds the file during the render (antivirus, backup): a read error says nothing about the file. + fx.Decoder.Unreadable[ProcessingFixture.FileName(10)] = 0; + await fx.StartEngineAsync(); + + var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); + var done = await fx.WaitForAsync(job.Id, JobState.Done); + + Assert.Contains(Loc.L("Export.Log.StandIns", "11"), done.LogTail); + var sidecar = Titano.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath); + Assert.Equal(FrameFlags.None, sidecar.Frames[10].Flags & FrameFlags.Undecodable); + Assert.NotEqual(DecodeTier.Unavailable, sidecar.Frames[10].Tier); + Assert.False(sidecar.Status.HasFlag(SequenceStatus.HasWarnings), "no warning"); + Assert.Equal(FrameFlags.None, (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[10].Flags); + } + + [Test] + public async Task ASmallRenderKeepsTheStoredSizeOfTheLargestPreview() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + // A CR3 on the server: the probe finds its full-size 6000×4000 preview, which caps the output. + for (var i = 0; i < Frames; i++) + fx.Decoder.Tiers[ProcessingFixture.FileName(i)] = new FileTier(ImageFileFormat.Jpeg, DecodeTier.EmbeddedPreview, "test-preview", "test", 6000, 4000); + await fx.StartEngineAsync(); + var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + await fx.WaitForAsync(light.Id, JobState.Done); + var probed = Titano.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames[3]; + Assert.Equal((FrameFlags.PreviewOnly, (int?)6000, (int?)4000), (probed.Flags, probed.PreviewW, probed.PreviewH)); + + // A small render decodes the smallest preview that reaches its size (1620×1080): that is not the largest. + for (var i = 0; i < Frames; i++) fx.Decoder.PreviewDecodes[ProcessingFixture.FileName(i)] = (1620, 1080); + var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); + await fx.WaitForAsync(job.Id, JobState.Done); + + var frames = Titano.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; + Assert.True(frames.All(f => f is { Tier: DecodeTier.EmbeddedPreview, PreviewW: 6000, PreviewH: 4000 }), "sidecar preview sizes kept"); + var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); + Assert.True(rows.All(f => (f.PreviewWidth, f.PreviewHeight) == (6000, 4000)), "index preview sizes kept"); + Assert.Equal((6000, 4000), (Titano.Core.Advice.SequenceContext.FromFrames(rows).PreviewWidth, Titano.Core.Advice.SequenceContext.FromFrames(rows).PreviewHeight)); + } + + [Test] + public void FramesARenderNodeReceivesKeepTheirTierFields() + { + var dto = new Titano.Protocol.FrameDto(Guid.CreateVersion7(), Guid.CreateVersion7(), 3, "IMG_0004.CR3", 25_000_000, new string('a', 64), + new DateTime(2026, 9, 28, 18, 0, 20), 120, 1.0 / 250, 8, 100, 24, 6, 6000, 4000, "cr3", + (long)(FrameFlags.PreviewOnly | FrameFlags.Intervalometer), 1620, 1080); + + var frame = RenderNodeClient.ToFrame(dto); + Assert.Equal((ImageFileFormat.Cr3, FrameFlags.PreviewOnly | FrameFlags.Intervalometer, 1620, 1080), + (frame.Format, frame.Flags, frame.PreviewWidth, frame.PreviewHeight)); + // The node's advisor caps a portrait sequence at its previews, oriented like the main image. + var tiers = Titano.Core.Advice.SequenceContext.FromFrames([frame]); + Assert.Equal((1, 1080, 1620), (tiers.PreviewOnlyCount, tiers.PreviewWidth, tiers.PreviewHeight)); + } + + [Test] + public async Task OnlyFramesTheRenderShowsGetAStandIn() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + foreach (var i in new[] { 1, 3 }) + await File.WriteAllBytesAsync(Path.Combine(fx.Archive.Paths.Root, "Synthetic", ProcessingFixture.FileName(i)), new byte[5000], fx.Ct); + var frames = await SequenceFrames.LoadAsync(fx.Db, fx.Archive.Archive, sequence, useProxies: false, fx.Ct); + + // A plan that skips the odd frames (a speed-up): the read-ahead meets frames 1 and 3, the pipeline never asks. + var source = new SequenceFrameSource(frames, frames.LightFrames(), new ImageDecoder([fx.Decoder]), new FrameWindowOptions { Ahead = 4 }) + { + Originals = true, + RenderExcluded = new HashSet(), + }; + await using (source) + { + foreach (var index in new[] { 0, 2, 4, 6 }) + { + using var frame = await source.GetFrameAsync(index, 64, DecodePurpose.Render, fx.Ct); + Assert.Equal(64, frame.Width); + } + // The read-ahead decodes in the background: wait until it has met frame 4 (index 3). + for (var waited = 0; !source.Observed.ContainsKey(3) && waited < 200; waited++) await Task.Delay(50, fx.Ct); + } + Assert.Equal(DecodeTier.Unavailable, source.Observed[3].Tier); + Assert.Empty(source.StandIns); + + // Asked for, a damaged frame shows its neighbour and is listed. + await using var asked = new SequenceFrameSource(frames, frames.LightFrames(), new ImageDecoder([fx.Decoder])) + { + RenderExcluded = new HashSet(), + }; + using (var standIn = await asked.GetFrameAsync(3, 64, DecodePurpose.Render, fx.Ct)) + Assert.Equal(64, standIn.Width); + Assert.SequenceEqual([3], asked.StandIns); + } + [Test] public async Task ARenderInterruptedByACrashStartsItsOutputAgainCleanly() { diff --git a/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs b/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs index 0c09f672..b9bd4b22 100644 --- a/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs +++ b/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs @@ -318,17 +318,19 @@ public abstract class CatalogRepositoryTests(TestContext context) : RepositoryTe await db.Archives.UpsertAsync(archive, Ct); var sequence = TestData.Sequence(archive.Id); await db.Sequences.UpsertAsync(sequence, Ct); - var frames = Enumerable.Range(0, 40).Select(i => TestData.Frame(sequence.Id, i) with { Flags = FrameFlags.Duplicate }).ToList(); + // More frames than one batched PostgreSQL statement holds. + const int count = 1205; + var frames = Enumerable.Range(0, count).Select(i => TestData.Frame(sequence.Id, i) with { Flags = FrameFlags.Duplicate }).ToList(); await db.Frames.BulkInsertAsync(frames, Ct); var tiers = frames.Select(f => new FrameTierFields(f.Id, f.Index % 2 == 0 ? FrameFlags.PreviewOnly : FrameFlags.Undecodable, 1620 + f.Index, 1080)).ToList(); - Assert.Equal(40, await db.Frames.UpdateTiersAsync(tiers, Ct)); - var read = await db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: Ct); + Assert.Equal(count, await db.Frames.UpdateTiersAsync(tiers, Ct)); + var read = await Titano.Data.Processing.SequenceFrames.ListAsync(db, sequence.Id, Ct); Assert.SequenceEqual(tiers.Select(t => (t.Flags, t.PreviewWidth, t.PreviewHeight)), read.Select(f => (f.Flags, f.PreviewWidth, f.PreviewHeight))); // A sync from the sidecar writes the tier fields like every other one. await db.Frames.SyncSequenceAsync(sequence.Id, [.. read.Select(f => f with { PreviewWidth = 4, PreviewHeight = 3, Flags = FrameFlags.None })], Ct); - Assert.True((await db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: Ct)).All(f => (f.Flags, f.PreviewWidth, f.PreviewHeight) == (FrameFlags.None, 4, 3))); + Assert.True((await Titano.Data.Processing.SequenceFrames.ListAsync(db, sequence.Id, Ct)).All(f => (f.Flags, f.PreviewWidth, f.PreviewHeight) == (FrameFlags.None, 4, 3))); } [Test]