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]