diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index d216a96d..b22dacd6 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -29,7 +29,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | Folder / namespace | Content | |---|---| -| `Imaging` (+ `Decoders`, `Geometry`, `Thumbnails`) | `ImageBuffer` (planar float, linear light), `IImageDecoderProvider`, `DecoderFactory` (decode tiers: native → embedded preview), `ManagedDecoderProvider`, `FrameWindow` (read-ahead, memory budget, float32 spill), resampler, thumbnail cache | +| `Imaging` (+ `Decoders`, `Geometry`, `Thumbnails`) | `ImageBuffer` (planar float, linear light), `IImageDecoderProvider`, `DecoderFactory` (decode tiers: native → embedded preview; `ImageDecoder.Probe` names a file's tier without decoding it), `ManagedDecoderProvider`, `FrameWindow` (read-ahead, memory budget, float32 spill), resampler, thumbnail cache | | `Metadata` (+ `Tiff`, `Jpeg`, `Bmff`, `Raf`, `Riff`, `Png`, `Xmp`, `MakerNotes`) | Signature sniffing, Exif/GPS/XMP/MakerNotes, ISO-BMFF (HEIF, CR3), `MetadataReader`, `MetadataBuilder` (all fallback chains), `ExifWriter` | | `Codecs` (`Jpeg`, `Png`, `Tiff`, `Dng`, `Raw`, `Gif`, `Apng`, `Ico`) | Pure managed codecs; native RAW development (DNG, CR2, NEF, ARW, PEF, RAF) | | `Analysis` (+ `Deep`) | Luminance statistics, deflicker, regions, holy grail, white balance, colour temperature, light analysis, streaming deep analysis with checkpoints | @@ -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`, `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), `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/i18n/en/Advisor.resx b/i18n/en/Advisor.resx index 7c3ab191..c76505d4 100644 --- a/i18n/en/Advisor.resx +++ b/i18n/en/Advisor.resx @@ -22,6 +22,7 @@ Only {0} of {1} frames have a capture time, so cadence and gaps cannot be measured.{0} frames with a capture time; {1} frames in total {0} frames are out of time order.{0} frame count The view drifts by {0:0.##} px per frame (pan or slider).{0} drift in source pixels per frame + Frames decoding only from their embedded preview: {0}.{0} frame count The view jumps at {0} frames (camera moved or bumped).{0} frame count Shot in {0} separate sessions.{0} session count The camera shakes by {0:0.##} px RMS; hiding it costs {1:0.#}% of the frame.{0} shake RMS in source pixels; {1} crop cost in percent of the area diff --git a/i18n/en/Export.resx b/i18n/en/Export.resx index bd544a1a..28116072 100644 --- a/i18n/en/Export.resx +++ b/i18n/en/Export.resx @@ -34,6 +34,7 @@ {0} failed: {1}long: job log line; {0} preset name; {1} reason No render node can encode {1}; {0} is rendered as {2} instead.long: job log line; {0} preset name; {1} codec asked for; {2} managed codec used {0} saved as {1}long: job log line; {0} preset name; {1} output file name + Undecodable frames shown as a neighbour: {0}.long: job log line; {0} frame numbers from 1, comma-separated Playback rate not understood; the export frame rate is used.long No capture times: frames are spaced evenly.long Every frame is excluded.long diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx index 915ab73b..09afe065 100644 --- a/i18n/en/Tooltips.resx +++ b/i18n/en/Tooltips.resx @@ -399,6 +399,8 @@ This PC has originals or settings the server does not have yet No proxies yet; editing reads the originals Not analysed yet + {0:N0} frame decodes only from its embedded preview; renders are capped at its size + {0:N0} frames decode only from their embedded previews; renders are capped at their size JPEG proxies built for fast editing Lives on the server; this PC has proxies at most Rendered once diff --git a/i18n/it/Advisor.it.resx b/i18n/it/Advisor.it.resx index c50b0774..c199c431 100644 --- a/i18n/it/Advisor.it.resx +++ b/i18n/it/Advisor.it.resx @@ -22,6 +22,7 @@ Solo {0} fotogrammi su {1} hanno un orario di scatto: cadenza e pause non sono misurabili. {0} fotogrammi sono fuori ordine temporale. L'inquadratura scorre di {0:0.##} px per fotogramma (panoramica o slider). + Fotogrammi decodificati solo dall'anteprima incorporata: {0}. L'inquadratura salta in {0} fotogrammi (fotocamera spostata o urtata). Ripreso in {0} sessioni separate. La fotocamera vibra di {0:0.##} px RMS; compensarla costa il {1:0.#}% dell'inquadratura. diff --git a/i18n/it/Export.it.resx b/i18n/it/Export.it.resx index 03ca3056..6f9dea5f 100644 --- a/i18n/it/Export.it.resx +++ b/i18n/it/Export.it.resx @@ -20,6 +20,7 @@ {0} non riuscito: {1} Nessun nodo di rendering può codificare {1}; {0} viene esportato in {2}. {0} salvato come {1} + Fotogrammi non decodificabili sostituiti da un vicino: {0}. Velocità di riproduzione non valida; viene usata la frequenza di esportazione. Nessun orario di scatto: fotogrammi distribuiti in modo uniforme. Tutti i fotogrammi sono esclusi. diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx index 634fa3ca..6af78d01 100644 --- a/i18n/it/Tooltips.it.resx +++ b/i18n/it/Tooltips.it.resx @@ -399,6 +399,8 @@ Questo PC ha originali o impostazioni che il server non ha ancora Ancora nessun proxy; la modifica legge gli originali Non ancora analizzata + {0:N0} fotogramma si decodifica solo dall'anteprima incorporata; i render sono limitati alla sua dimensione + {0:N0} fotogrammi si decodificano solo dalle anteprime incorporate; i render sono limitati alla loro dimensione Proxy JPEG pronti per una modifica veloce Si trova sul server; questo PC ne ha al massimo i proxy Esportata una volta diff --git a/src/Titano.App/DesignTime/SampleData.cs b/src/Titano.App/DesignTime/SampleData.cs index 828dcccd..eaea7d75 100644 --- a/src/Titano.App/DesignTime/SampleData.cs +++ b/src/Titano.App/DesignTime/SampleData.cs @@ -456,7 +456,7 @@ public sealed class SampleData var now = new DateTime(2026, 9, 28, 18, 2, 11); (Sequence, string[], bool) Make(string? title, string folder, string make, string model, int frames, TimeSpan span, double interval, int daysAgo, SequenceStatus status, string[] colours, int renders = 0, int warnings = 0, SequenceOrigin origin = SequenceOrigin.Local, - SyncState sync = SyncState.LocalOnly, bool raw = false) + SyncState sync = SyncState.LocalOnly, bool raw = false, int previewOnly = 0) { var start = now.AddDays(-daysAgo); return (new Sequence @@ -475,6 +475,7 @@ public sealed class SampleData Status = status, RenderedCount = renders, WarningCount = warnings, + PreviewOnlyCount = previewOnly, Origin = origin, SyncState = sync, UpdatedAt = DateTimeOffset.UtcNow, @@ -490,7 +491,7 @@ public sealed class SampleData yield return Make(null, "2026/2026-09-27 Sony ILCE-7M4", "SONY", "ILCE-7M4", 2_140, new TimeSpan(1, 11, 0), 2, 1, Analysed, ["#4A7FB5", "#A9C9E6", "#6F7D6A"]); yield return Make("Aurora, Tromsø", "2026/2026-02-20 Nikon Z 8", "NIKON CORPORATION", "NIKON Z 8", 1_860, new TimeSpan(4, 8, 0), 8, 220, Full, - ["#0C2A3A", "#1AA08C", "#0B1A26"], sync: SyncState.InSync); + ["#0C2A3A", "#1AA08C", "#0B1A26"], sync: SyncState.InSync, previewOnly: 1_860); yield return Make("Construction cam · week 38", "2026/2026-09-14 Brinno TLC2020", "Brinno", "TLC2020", 8_920, TimeSpan.FromDays(7), 60, 14, SequenceStatus.None, ["#7C8AA0", "#C9CFD6", "#4C5058"], origin: SequenceOrigin.Server, sync: SyncState.RemoteOnly); yield return Make("Milan skyline dusk", "2026/2026-06-03 Apple iPhone 16 Pro", "Apple", "iPhone 16 Pro", 2_400, new TimeSpan(1, 20, 0), 2, 117, Full, diff --git a/src/Titano.App/Editor/RemoteSequenceSource.cs b/src/Titano.App/Editor/RemoteSequenceSource.cs index c245b805..43385418 100644 --- a/src/Titano.App/Editor/RemoteSequenceSource.cs +++ b/src/Titano.App/Editor/RemoteSequenceSource.cs @@ -103,6 +103,7 @@ public sealed class RemoteSequenceSource : ISequenceSource RenderedCount = dto.RenderedCount, HeroFrameId = dto.HeroFrameId, WarningCount = dto.WarningCount, + PreviewOnlyCount = dto.PreviewOnlyCount, SettingsJson = manifest.SettingsJson, SettingsVersion = manifest.SettingsVersion, UpdatedAt = dto.UpdatedAt, diff --git a/src/Titano.App/Library/RemoteCards.cs b/src/Titano.App/Library/RemoteCards.cs index f99e4aa8..3ecc5ca7 100644 --- a/src/Titano.App/Library/RemoteCards.cs +++ b/src/Titano.App/Library/RemoteCards.cs @@ -43,6 +43,7 @@ public static class RemoteCards SettingsVersion = dto.SettingsVersion, FramesVersion = dto.FramesVersion, WarningCount = dto.WarningCount, + PreviewOnlyCount = dto.PreviewOnlyCount, OwnerUserId = dto.OwnerUserId, UpdatedAt = dto.UpdatedAt, Origin = SequenceOrigin.Server, diff --git a/src/Titano.App/Library/SequenceItem.cs b/src/Titano.App/Library/SequenceItem.cs index 3256faff..40d2d6a7 100644 --- a/src/Titano.App/Library/SequenceItem.cs +++ b/src/Titano.App/Library/SequenceItem.cs @@ -237,10 +237,13 @@ public sealed class SequenceItem : ObservableObject _ => null, }; - /// Card status row: analysed, proxies, renders, errors or warnings, sync (Main.html); the sync glyph is last so a narrow card cuts it first. + /// + /// Card status row: analysed, proxies, renders, preview-only frames (BRIEF §8.2), errors or warnings, sync (Main.html); + /// the sync glyph is last so a narrow card cuts it first. + /// public static IReadOnlyList BuildStatuses(Sequence s, bool analysing) { - var list = new List(5); + var list = new List(6); if (analysing) list.Add(new CardStatus(StatusKind.Analysing, Loc.L("Library.Status.Analysing"), Loc.L("Tooltips.Library.Status.Analysing"))); else if ((s.Status & SequenceStatus.AnalyzedLight) != 0) list.Add(new CardStatus(StatusKind.Analysed, Loc.L("Library.Status.Analysed"), Loc.L("Tooltips.Library.Status.Analysed"))); else list.Add(new CardStatus(StatusKind.NotAnalysed, Loc.L("Library.Status.Analysed"), Loc.L("Tooltips.Library.Status.NotAnalysed"))); @@ -258,6 +261,8 @@ public sealed class SequenceItem : ObservableObject if (s.RenderedCount > 0) list.Add(new CardStatus(StatusKind.Rendered, Formatting.Count(s.RenderedCount), Loc.Plural("Tooltips.Library.Status.Rendered", s.RenderedCount))); + if (s.PreviewOnlyCount > 0) + list.Add(new CardStatus(StatusKind.PreviewOnly, Formatting.Count(s.PreviewOnlyCount), Loc.Plural("Tooltips.Library.Status.PreviewOnly", s.PreviewOnlyCount))); if ((s.Status & SequenceStatus.HasErrors) != 0) list.Add(new CardStatus(StatusKind.Error, Formatting.Count(Math.Max(1, s.WarningCount)), Loc.L("Tooltips.Library.Status.Errors"))); else if (s.WarningCount > 0 || (s.Status & SequenceStatus.HasWarnings) != 0) diff --git a/src/Titano.Core/Advice/Advisor.cs b/src/Titano.Core/Advice/Advisor.cs index e1e5e38d..32217eb1 100644 --- a/src/Titano.Core/Advice/Advisor.cs +++ b/src/Titano.Core/Advice/Advisor.cs @@ -16,14 +16,17 @@ public static class Advisor { /// /// Recommendations for every parameter the rules cover (see ), in section order, plus - /// every finding of both analyses. Without a deep report, pixel-based parameters get missing-data recommendations. + /// every finding of both analyses; a finding both report (frames that cannot be decoded: the light analysis reads + /// the flags the deep pass recorded) is listed once, as the light analysis has it. Without a deep report, + /// pixel-based parameters get missing-data recommendations. /// public static AdvisorResult Recommend(LightAnalysisReport light, DeepAnalysisReport? deep, SequenceContext context) { ArgumentNullException.ThrowIfNull(light); ArgumentNullException.ThrowIfNull(context); var findings = new List(light.Findings); - if (deep is not null) findings.AddRange(deep.Findings.Select(f => f.ToFinding())); + var lightKeys = light.Findings.Select(f => f.Key).ToHashSet(StringComparer.Ordinal); + if (deep is not null) findings.AddRange(deep.Findings.Select(f => f.ToFinding()).Where(f => !lightKeys.Contains(f.Key))); return new AdvisorResult(new AdvisorRules(light, deep, context).Run(), findings); } diff --git a/src/Titano.Core/Advice/AdvisorTypes.cs b/src/Titano.Core/Advice/AdvisorTypes.cs index 59c07f63..e8b3a6d0 100644 --- a/src/Titano.Core/Advice/AdvisorTypes.cs +++ b/src/Titano.Core/Advice/AdvisorTypes.cs @@ -143,27 +143,38 @@ public sealed record SequenceContext /// Wanted video length ("fit to N seconds"), when the user set one. public double? TargetDurationSeconds { get; init; } - /// Context from the archive's frame rows: count, dominant oriented size, preview-only count, median shutter time. + /// + /// Context from the archive's frame rows: count, dominant oriented size, preview-only count with the dominant oriented + /// size of those frames' previews, median shutter time. + /// public static SequenceContext FromFrames(IReadOnlyList frames, IReadOnlyList? codecs = null) { ArgumentNullException.ThrowIfNull(frames); var sizes = new Dictionary<(int, int), int>(); + var previews = new Dictionary<(int, int), int>(); var exposures = new List(); var previewOnly = 0; foreach (var f in frames) { - var size = f.Orientation is >= 5 and <= 8 ? (f.Height, f.Width) : (f.Width, f.Height); + var rotated = f.Orientation is >= 5 and <= 8; + var size = rotated ? (f.Height, f.Width) : (f.Width, f.Height); if (size.Item1 > 0 && size.Item2 > 0) sizes[size] = sizes.GetValueOrDefault(size) + 1; if (f.ExposureTime is > 0 and var t) exposures.Add(t); - if ((f.Flags & FrameFlags.PreviewOnly) != 0) previewOnly++; + if ((f.Flags & FrameFlags.PreviewOnly) == 0) continue; + previewOnly++; + var preview = rotated ? (f.PreviewHeight, f.PreviewWidth) : (f.PreviewWidth, f.PreviewHeight); + if (preview.Item1 > 0 && preview.Item2 > 0) previews[preview] = previews.GetValueOrDefault(preview) + 1; } var (width, height) = sizes.Count > 0 ? sizes.MaxBy(kv => kv.Value).Key : (0, 0); + var (previewWidth, previewHeight) = previews.Count > 0 ? previews.MaxBy(kv => kv.Value).Key : (0, 0); return new SequenceContext { FrameCount = frames.Count, SourceWidth = width, SourceHeight = height, PreviewOnlyCount = previewOnly, + PreviewWidth = previewWidth, + PreviewHeight = previewHeight, MedianExposureSeconds = exposures.Count > 0 ? Statistics.Median(exposures.ToArray()) : null, Codecs = codecs ?? [], }; diff --git a/src/Titano.Core/Analysis/Deep/DeepAnalysisReport.cs b/src/Titano.Core/Analysis/Deep/DeepAnalysisReport.cs index 34268978..89866d9e 100644 --- a/src/Titano.Core/Analysis/Deep/DeepAnalysisReport.cs +++ b/src/Titano.Core/Analysis/Deep/DeepAnalysisReport.cs @@ -114,6 +114,7 @@ public sealed record DeepFinding(string Key, FindingSeverity Severity, double[] /// Resource keys of the findings produced by the deep analysis; arguments are numbers. public static class DeepFindingKeys { + /// Frames nothing decodes; the light analysis reports the frames flagged so under it too (format tier 3). public const string UnreadableFrames = "Advisor.Finding.UnreadableFrames"; public const string BlackFrames = "Advisor.Finding.BlackFrames"; public const string WhiteFrames = "Advisor.Finding.WhiteFrames"; diff --git a/src/Titano.Core/Analysis/Finding.cs b/src/Titano.Core/Analysis/Finding.cs index 217208d6..00b4d8e2 100644 --- a/src/Titano.Core/Analysis/Finding.cs +++ b/src/Titano.Core/Analysis/Finding.cs @@ -33,6 +33,9 @@ public static class FindingKeys public const string LensChanged = "Advisor.Finding.LensChanged"; public const string MixedResolution = "Advisor.Finding.MixedResolution"; public const string MixedOrientation = "Advisor.Finding.MixedOrientation"; + + /// Frames that decode only through their embedded preview (format tier 2); {0} frame count. + public const string PreviewOnly = "Advisor.Finding.PreviewOnly"; public const string TimeZoneEstimated = "Advisor.Finding.TimeZoneEstimated"; public const string DayNightTransition = "Advisor.Finding.DayNightTransition"; } diff --git a/src/Titano.Core/Analysis/LightAnalysisReport.cs b/src/Titano.Core/Analysis/LightAnalysisReport.cs index 501ca433..9e7fe647 100644 --- a/src/Titano.Core/Analysis/LightAnalysisReport.cs +++ b/src/Titano.Core/Analysis/LightAnalysisReport.cs @@ -131,5 +131,11 @@ public sealed record LightAnalysisReport /// Light condition per frame from GPS position and capture time; all null without GPS. public DayPhase?[] DayPhases { get; init; } = []; + /// Frames that decode only through their embedded preview (format tier 2, BRIEF §8.2). + public IReadOnlyList PreviewOnlyFrames { get; init; } = []; + + /// Frames that nothing decodes (format tier 3): renders skip them. + public IReadOnlyList UndecodableFrames { get; init; } = []; + public IReadOnlyList Findings { get; init; } = []; } diff --git a/src/Titano.Core/Analysis/LightAnalyzer.cs b/src/Titano.Core/Analysis/LightAnalyzer.cs index 0fc5dc9b..aa1f0c1a 100644 --- a/src/Titano.Core/Analysis/LightAnalyzer.cs +++ b/src/Titano.Core/Analysis/LightAnalyzer.cs @@ -1,3 +1,4 @@ +using Titano.Core.Analysis.Deep; using Titano.Core.Mathematics; using Titano.Core.Model; @@ -5,8 +6,9 @@ namespace Titano.Core.Analysis; /// /// Metadata-only sequence analysis run at import/scan (BRIEF §10.1): cadence, gaps and sessions, timestamp -/// sanity, exposure series and steps, camera/lens identity, size and orientation consistency, and day phases -/// from GPS. Linear in the number of frames apart from two medians; deterministic. +/// sanity, exposure series and steps, camera/lens identity, size and orientation consistency, format tiers (from the +/// frames' decode-tier flags) and day phases from GPS. Linear in the number of frames apart from two medians; +/// deterministic. /// public static class LightAnalyzer { @@ -31,6 +33,7 @@ public static class LightAnalyzer var exposure = AnalyzeExposure(frames, options, findings); var identity = AnalyzeIdentity(frames, findings); var (dominantSize, sizeOutliers, orientation, orientationOutliers) = AnalyzeGeometry(frames, findings); + var (previewOnly, undecodable) = AnalyzeTiers(frames, findings); var phases = AnalyzeDayPhases(frames, timing.Adjusted, findings); return new LightAnalysisReport @@ -56,6 +59,8 @@ public static class LightAnalyzer DominantOrientation = orientation, OrientationOutliers = orientationOutliers, DayPhases = phases, + PreviewOnlyFrames = previewOnly, + UndecodableFrames = undecodable, Findings = findings, }; } @@ -331,6 +336,25 @@ public static class LightAnalyzer return (dominant, sizeOutliers, orientation, orientationOutliers); } + /// + /// Format tiers (BRIEF §8.2): frames that decode only through their embedded preview, which caps the output at the + /// preview size, and frames that nothing decodes, which renders skip (a warning, under the key the deep analysis uses + /// for the frames it could not decode, so the advisor lists them once). + /// + private static (List PreviewOnly, List Undecodable) AnalyzeTiers(IReadOnlyList frames, List findings) + { + var previewOnly = new List(); + var undecodable = new List(); + for (var i = 0; i < frames.Count; i++) + { + if ((frames[i].Flags & FrameFlags.Undecodable) != 0) undecodable.Add(i); + else if ((frames[i].Flags & FrameFlags.PreviewOnly) != 0) previewOnly.Add(i); + } + if (previewOnly.Count > 0) findings.Add(new Finding(FindingKeys.PreviewOnly, FindingSeverity.Info, [previewOnly.Count], Cap(previewOnly))); + if (undecodable.Count > 0) findings.Add(new Finding(DeepFindingKeys.UnreadableFrames, FindingSeverity.Warning, [undecodable.Count], Cap(undecodable))); + return (previewOnly, undecodable); + } + private static DayPhase?[] AnalyzeDayPhases(IReadOnlyList frames, DateTime?[] adjusted, List findings) { var n = frames.Count; diff --git a/src/Titano.Core/Analysis/LightFrame.cs b/src/Titano.Core/Analysis/LightFrame.cs index 40529c0f..7a860e09 100644 --- a/src/Titano.Core/Analysis/LightFrame.cs +++ b/src/Titano.Core/Analysis/LightFrame.cs @@ -31,6 +31,9 @@ public sealed record LightFrame /// GPS (satellite) UTC time stamp, used to infer the camera clock's UTC offset. public DateTime? GpsUtc { get; init; } + /// The archived frame's flags; the decode-tier bits feed the format-tier findings. + public FrameFlags Flags { get; init; } + /// Exposure value at ISO 100: log2(N²/t) − log2(ISO/100). public double? ExposureValue => ExposureTime is > 0 && FNumber is > 0 ? Math.Log2(FNumber.Value * FNumber.Value / ExposureTime.Value) - Math.Log2((Iso is > 0 ? Iso.Value : 100) / 100.0) @@ -54,6 +57,7 @@ public sealed record LightFrame Width = frame.Width, Height = frame.Height, Orientation = frame.Orientation, + Flags = frame.Flags, }; } diff --git a/src/Titano.Core/Archiving/FrameImageRenderer.cs b/src/Titano.Core/Archiving/FrameImageRenderer.cs index 0cdbfff3..5e37bc61 100644 --- a/src/Titano.Core/Archiving/FrameImageRenderer.cs +++ b/src/Titano.Core/Archiving/FrameImageRenderer.cs @@ -8,8 +8,9 @@ namespace Titano.Core.Archiving; public sealed record EncodedImage(byte[] Jpeg, int Width, int Height, DecodeTier Tier); /// -/// Makes thumbnails and proxies of frames (BRIEF §8.5): the embedded preview or the managed JPEG decoder first, then -/// the host's decode providers (WIC on Windows); orientation applied, resampled in linear light, encoded in-house. +/// Makes thumbnails and proxies of frames (BRIEF §8.5): the managed JPEG decoder, or for thumbnails an embedded preview +/// at least 320 px long, first, then the host's decode providers (WIC on Windows); orientation applied, resampled in +/// linear light, encoded in-house. says how the pixels were obtained. /// public sealed class FrameImageRenderer(ImageDecoder decoder) { @@ -55,13 +56,37 @@ public sealed class FrameImageRenderer(ImageDecoder decoder) private static EncodedImage Encode(ImageBuffer pixels, JpegEncodeOptions options, DecodeTier tier) => new(JpegEncoder.Encode(pixels, options), pixels.Width, pixels.Height, tier); + /// + /// 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. + /// private DecodedFrame? Decode(string path, SidecarFrame frame, int maxLongEdge, DecodePurpose purpose, bool preferPreview, CancellationToken cancellationToken) { - if (frame.Format == ImageFileFormat.Jpeg) return DecodeJpeg(File.ReadAllBytes(path), maxLongEdge, frame.Orientation, DecodeTier.Native); - if (preferPreview && ReadPreview(path, frame) is { } preview) return DecodeJpeg(preview, maxLongEdge, frame.Orientation, DecodeTier.EmbeddedPreview); + 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) + && 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); if (decoder.Decode(request, cancellationToken) is { } decoded) return new DecodedFrame(decoded.Pixels, decoded.Tier); - return ReadPreview(path, frame) is { } fallback ? DecodeJpeg(fallback, maxLongEdge, frame.Orientation, DecodeTier.EmbeddedPreview) : null; + 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) + { + if (maxLongEdge <= 0) return true; + if (frame is { PreviewW: { } w, PreviewH: { } h }) return int.Max(w, h) >= maxLongEdge; + try + { + var info = JpegDecoder.ReadInfo(preview); + return int.Max(info.Width, info.Height) >= maxLongEdge; + } + catch (InvalidDataException) + { + return false; + } } private static DecodedFrame? DecodeJpeg(byte[] data, int maxLongEdge, int orientation, DecodeTier tier) diff --git a/src/Titano.Core/Archiving/SequenceFrames.cs b/src/Titano.Core/Archiving/SequenceFrames.cs index 4735e3ae..8f79a8de 100644 --- a/src/Titano.Core/Archiving/SequenceFrames.cs +++ b/src/Titano.Core/Archiving/SequenceFrames.cs @@ -1,3 +1,4 @@ +using Titano.Core.Imaging; using Titano.Core.Metadata; using Titano.Core.Model; @@ -42,9 +43,32 @@ public static class SequenceFrames Format = metadata.Format, PreviewOffset = metadata.LargestPreview?.Offset, PreviewLength = metadata.LargestPreview?.Length, + PreviewW = Positive(metadata.LargestPreview?.Width), + PreviewH = Positive(metadata.LargestPreview?.Height), }; } + /// + /// The frame with its decode tier (BRIEF §8.2) and the flags that follow it: for + /// the embedded-preview tier, for none. 's size, oriented + /// like every , replaces the stored preview size when it is a preview's. + /// + /// For the unavailable tier: whether that proves the file unreadable. False when the host has no + /// native decoder for the format, so a client or render node with one (or a proxy) may still produce its pixels: the + /// tier is kept and is left as it was. + public static SidecarFrame WithTier(SidecarFrame frame, FileTier tier, bool damaged = true) + { + var flags = frame.Flags & ~(FrameFlags.PreviewOnly | FrameFlags.Undecodable); + if (tier.Tier == DecodeTier.EmbeddedPreview) flags |= FrameFlags.PreviewOnly; + else if (tier.Tier == DecodeTier.Unavailable) flags |= damaged ? FrameFlags.Undecodable : frame.Flags & FrameFlags.Undecodable; + var (w, h) = tier.Tier == DecodeTier.EmbeddedPreview && tier.Width > 0 && tier.Height > 0 + ? PixelConvert.OrientedSize(tier.Width, tier.Height, frame.Orientation) + : (frame.PreviewW ?? 0, frame.PreviewH ?? 0); + return frame with { Tier = tier.Tier, Flags = flags, PreviewW = Positive(w), PreviewH = Positive(h) }; + } + + private static int? Positive(int? value) => value > 0 ? value : null; + /// /// Merges into the frame list by capture time (existing frames keep their relative order), /// renumbers indexes and bumps the frames version. diff --git a/src/Titano.Core/Archiving/SequenceManifest.cs b/src/Titano.Core/Archiving/SequenceManifest.cs index dbab9390..7d7c7b6f 100644 --- a/src/Titano.Core/Archiving/SequenceManifest.cs +++ b/src/Titano.Core/Archiving/SequenceManifest.cs @@ -109,6 +109,20 @@ public sealed record SidecarFrame public long? PreviewOffset { get; init; } public long? PreviewLength { get; init; } + /// Size of the largest embedded preview (or GPR companion JPEG), stored like and + /// before orientation; null when the file has none or it is not known yet. + public int? PreviewW { get; init; } + + public int? PreviewH { get; init; } + + /// + /// Decode tier of the file (BRIEF §8.2) as the host that indexed or decoded it last found it; omitted until it is + /// known. and follow it. + /// + [JsonConverter(typeof(TolerantEnumConverter))] + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)] + public DecodeTier Tier { get; init; } + /// bits, stored as a number so bits of newer builds survive. public FrameFlags Flags { get; init; } diff --git a/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs b/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs index 9b8c7e2f..4fa99fea 100644 --- a/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs +++ b/src/Titano.Core/Imaging/Decoders/ManagedDecoderProvider.cs @@ -7,19 +7,11 @@ using Titano.Core.Metadata; namespace Titano.Core.Imaging.Decoders; -/// Tier a provider would use for one specific file, with the reason when it is not native. -/// Format detected from the file's signature (extension only breaks ties). -/// Best tier available for this file. -/// Decoder that would produce it ("managed-cr2", "managed-preview"…), null when unavailable. -/// Why the native tier is not used (unsupported body or encoding), else null. -/// Full-size width that tier delivers (developed RAW, preview or image size), oriented; 0 when unknown. -/// Full-size height, oriented; 0 when unknown. -public sealed record FileTier(ImageFileFormat Format, DecodeTier Tier, string? Decoder, string? Reason, int Width, int Height); - /// /// 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; nothing for formats without either. +/// 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. /// 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. @@ -29,6 +21,7 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider private const string LogCategory = "Decode"; private const int FileBufferSize = 1 << 16; private const long MaxPreviewBytes = 256L << 20; + private static readonly string[] CompanionExtensions = [".JPG", ".jpg", ".JPEG", ".jpeg"]; public string Name => "managed"; @@ -62,6 +55,18 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider return result; } + /// + /// 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) + { + var family = ImageFormatInfo.Of(format).Family; + if (family is not (ImageFamily.Jpeg or ImageFamily.Png or ImageFamily.Tiff)) return Probe(path); + 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) { @@ -88,11 +93,32 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider reason = $"no managed decoder for {format}"; } var metadata = MetadataReader.Read(stream, path); - if (metadata.LargestPreview is not { } preview) return new FileTier(format, DecodeTier.Unavailable, null, reason + "; no embedded preview", 0, 0); - var (pw, ph) = PixelConvert.OrientedSize(preview.Width, preview.Height, metadata.Orientation); + 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 (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. + /// + internal static string? CompanionJpeg(string path) + { + var stem = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty, Path.GetFileNameWithoutExtension(path)); + foreach (var extension in CompanionExtensions) + { + if (File.Exists(stem + extension)) return stem + extension; + } + return null; + } + private static FileStream Open(string path) => new(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, FileBufferSize, FileOptions.RandomAccess); @@ -147,7 +173,37 @@ public sealed class ManagedDecoderProvider : IImageDecoderProvider Log.Debug(LogCategory, $"{Path.GetFileName(request.Path)}: native decode unavailable ({ex.Message}); trying the embedded preview"); } } - return request.AllowPreview || request.ForcePreview ? Preview(stream, request, adequateOnly: false, cancellationToken) : null; + if (!request.AllowPreview && !request.ForcePreview) return null; + if (format == ImageFileFormat.Gpr && Companion(stream, request, cancellationToken) is { } companion) return companion; + return Preview(stream, request, adequateOnly: false, cancellationToken); + } + + /// + /// 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. + /// + private static DecodedImage? Companion(Stream raw, DecodeRequest request, CancellationToken cancellationToken) + { + if (CompanionJpeg(request.Path) 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); + if (stream.Length > MaxPreviewBytes) return null; + var data = ReadAll(stream); + JpegInfo info; + try + { + info = JpegDecoder.ReadInfo(data); + } + catch (InvalidDataException ex) + { + Log.Debug(LogCategory, $"{Path.GetFileName(path)}: not a usable JPEG ({ex.Message}); using the embedded preview"); + return null; + } + if (int.Max(info.Width, info.Height) <= largestPreview) return null; + var image = JpegDecoder.DecodeToLinear(data, new JpegDecodeOptions { MaxLongEdge = request.MaxLongEdge }, expandGray: true); + var orientation = request.ApplyOrientation ? MetadataReader.Read(stream, path, cancellationToken: cancellationToken).Orientation : 1; + return Finish(image, orientation, request, info.Width, info.Height, DecodeTier.EmbeddedPreview, "managed-sidecar"); } /// Embedded-preview tier: the smallest preview whose long edge still reaches MaxLongEdge (the largest when none diff --git a/src/Titano.Core/Imaging/Decoding.cs b/src/Titano.Core/Imaging/Decoding.cs index 98f5f519..06a4c2d6 100644 --- a/src/Titano.Core/Imaging/Decoding.cs +++ b/src/Titano.Core/Imaging/Decoding.cs @@ -53,6 +53,15 @@ public sealed class DecodedImage(ImageBuffer pixels, DecodeTier tier, string dec public void Dispose() => Pixels.Dispose(); } +/// Tier a provider would use for one specific file, with the reason when it is not native. +/// Format of the file (detected from its signature; the extension only breaks ties). +/// Best tier available for this file. +/// Decoder that would produce it ("managed-cr2", "managed-preview"…), null when unavailable. +/// Why the native tier is not used (unsupported body or encoding), else null. +/// Full-size width that tier delivers (developed RAW, preview or image size), oriented; 0 when unknown. +/// Full-size height, oriented; 0 when unknown. +public sealed record FileTier(ImageFileFormat Format, DecodeTier Tier, string? Decoder, string? Reason, int Width, int Height); + /// A platform image decoder (WIC on Windows, managed codecs everywhere). public interface IImageDecoderProvider { @@ -64,6 +73,17 @@ public interface IImageDecoderProvider bool CanDecode(ImageFormatInfo format) => TierFor(format.Format) is not null; + /// + /// The tier this provider would use for the file at , whose signature says + /// , without decoding pixels. The default trusts ; a provider whose + /// support depends on the file itself (camera body, encoding, embedded previews) looks inside it. + /// + /// The file cannot be read. + /// The file is malformed where the provider looks. + FileTier Probe(string path, ImageFileFormat format) => TierFor(format) is { } tier + ? new FileTier(format, tier, Name, null, 0, 0) + : new FileTier(format, DecodeTier.Unavailable, null, $"{Name}: no decoder for {format}", 0, 0); + /// Decodes or returns null when this provider cannot handle the specific file. DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default); } @@ -84,6 +104,39 @@ public sealed class ImageDecoder(IReadOnlyList providers) return best; } + /// + /// The tier this chain would use for the file at (signature format ) + /// without decoding pixels (BRIEF §8.2): the first provider whose probe reaches the native tier, else the largest + /// embedded preview a provider offers, else unavailable with the first reason given. A provider that finds the file + /// malformed is skipped like in . + /// + /// The file cannot be read. + public FileTier Probe(string path, ImageFileFormat format) + { + FileTier? preview = null; + string? reason = null; + foreach (var provider in Providers.OrderBy(p => p.TierFor(format) ?? DecodeTier.Unavailable)) + { + if (provider.TierFor(format) is null) continue; + FileTier tier; + try + { + tier = provider.Probe(path, format); + } + catch (Exception ex) when (ex is InvalidDataException or NotSupportedException or FormatException or InvalidOperationException + or System.Runtime.InteropServices.COMException) + { + reason ??= $"{provider.Name}: {ex.Message}"; + continue; + } + if (tier.Tier == DecodeTier.Native) return tier; + if (tier.Tier == DecodeTier.EmbeddedPreview && (preview is null || long.Max(tier.Width, tier.Height) > long.Max(preview.Width, preview.Height))) + preview = tier; + reason ??= tier.Reason; + } + return preview ?? new FileTier(format, DecodeTier.Unavailable, null, reason ?? $"no decoder for {format}", 0, 0); + } + /// Decodes with the first provider that succeeds; null means . public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { diff --git a/src/Titano.Core/Model/Entities.cs b/src/Titano.Core/Model/Entities.cs index 6697f044..0cb9e600 100644 --- a/src/Titano.Core/Model/Entities.cs +++ b/src/Titano.Core/Model/Entities.cs @@ -59,6 +59,10 @@ public sealed record Sequence public int FramesVersion { get; init; } public Guid? OwnerUserId { get; init; } public int WarningCount { get; init; } + + /// Frames that decode only through their embedded preview (, BRIEF §8.2). + public int PreviewOnlyCount { get; init; } + public DateTimeOffset UpdatedAt { get; init; } /// The title, else capture date and camera, else the folder name (never empty). @@ -112,6 +116,12 @@ public sealed record Frame public long? PreviewOffset { get; init; } public long? PreviewLength { get; init; } + /// Size of the largest embedded preview like and (before orientation); + /// 0 when there is none or it is not known. + public int PreviewWidth { get; init; } + + public int PreviewHeight { get; init; } + /// Mean log2 luminance once analysed. public double? MeanLogLuminance { get; init; } diff --git a/src/Titano.Data/Archiving/ArchiveImages.cs b/src/Titano.Data/Archiving/ArchiveImages.cs index e8ae63be..c2c6e8b5 100644 --- a/src/Titano.Data/Archiving/ArchiveImages.cs +++ b/src/Titano.Data/Archiving/ArchiveImages.cs @@ -1,5 +1,6 @@ using System.Diagnostics; using Titano.Core.Archiving; +using Titano.Core.Imaging; using Titano.Core.IO; using Titano.Core.Metadata; using Titano.Core.Model; @@ -12,7 +13,8 @@ public sealed record ImagePassResult(int Built, int Reused, int Undecodable); /// /// Thumbnails (thumbs.pack) and proxies (proxies/0001.jpg) of sequences (BRIEF §8.5). Both are /// regenerable and self-validating: a thumbnail carries its source fingerprint, a proxy its capture time, so after -/// frames were renumbered the stale ones are rebuilt and the rest reused. +/// frames were renumbered the stale ones are rebuilt and the rest reused. A frame nothing decodes is flagged undecodable +/// (BRIEF §8.2 tier 3); one flagged so that decodes after all gets its tier probed again. /// public sealed class ArchiveImages { @@ -23,6 +25,7 @@ public sealed class ArchiveImages private readonly SequenceWriter _writer; private readonly ArchiveIndexer _indexer; private readonly FrameImageRenderer _renderer; + private readonly FrameTiers _tiers; internal ArchiveImages(TitanoDatabase db, SequenceWriter writer, ArchiveIndexer indexer) { @@ -30,6 +33,7 @@ public sealed class ArchiveImages _writer = writer; _indexer = indexer; _renderer = new FrameImageRenderer(writer.Options.Decoder); + _tiers = new FrameTiers(db, writer, indexer); } /// Resume point inside the sequence (frames before it were done by an earlier run). @@ -42,6 +46,7 @@ public sealed class ArchiveImages var folder = paths.Sequence(sequence.Folder); var manifest = ManifestStore.ReadSequence(folder.ManifestPath); int built = 0, reused = 0, undecodable = 0; + var tiers = new Dictionary(); // 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)) @@ -58,7 +63,7 @@ public sealed class ArchiveImages reused++; continue; } - if (Render(() => _renderer.Thumbnail(folder, frame, cancellationToken)) is { } image) + if (Render(folder, frame, tiers, () => _renderer.Thumbnail(folder, frame, cancellationToken)) is { } image) { pack.Append(frame.I, image.Width, image.Height, fingerprint, image.Jpeg); built++; @@ -75,6 +80,7 @@ public sealed class ArchiveImages } pack.Commit(); } + await _tiers.RecordAsync(archive, sequence, tiers, cancellationToken).ConfigureAwait(false); await MarkAsync(archive, paths, sequence, SequenceStatus.ThumbsBuilt, undecodable == 0, cancellationToken).ConfigureAwait(false); return new ImagePassResult(built, reused, undecodable); } @@ -91,6 +97,7 @@ public sealed class ArchiveImages var manifest = ManifestStore.ReadSequence(folder.ManifestPath); Directory.CreateDirectory(folder.Proxies); int built = 0, reused = 0, undecodable = 0; + var tiers = new Dictionary(); var cadence = new Cadence(); for (var i = startFrame; i < manifest.Frames.Count; i++) { @@ -102,7 +109,7 @@ public sealed class ArchiveImages reused++; continue; } - if (Render(() => _renderer.Proxy(folder, frame, manifest.Camera, policy, cancellationToken)) is { } image) + if (Render(folder, frame, tiers, () => _renderer.Proxy(folder, frame, manifest.Camera, policy, cancellationToken)) is { } image) { AtomicFile.WriteAllBytes(path, image.Jpeg); built++; @@ -113,6 +120,7 @@ public sealed class ArchiveImages } if (cadence.Due()) await checkpoint(i + 1, manifest.Frames.Count).ConfigureAwait(false); } + await _tiers.RecordAsync(archive, sequence, tiers, cancellationToken).ConfigureAwait(false); await MarkAsync(archive, paths, sequence, SequenceStatus.ProxiesBuilt, undecodable == 0, cancellationToken).ConfigureAwait(false); return new ImagePassResult(built, reused, undecodable); } @@ -131,18 +139,52 @@ public sealed class ArchiveImages } } - /// A frame no decoder can read is skipped and counted; it never stops the pass. - private static EncodedImage? Render(Func render) + /// + /// A frame no decoder can read is skipped and counted; it never stops the pass. What decoding found goes into + /// : 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) { + var path = folder.File(frame.File); + EncodedImage? image; try { - return render(); + image = render(); } - catch (Exception ex) when (ex is IOException or InvalidDataException or NotSupportedException) + catch (IOException ex) { Core.Diagnostics.Log.Warning("archive", "Frame image could not be rendered", ex); return null; } + catch (Exception ex) when (ex is InvalidDataException or NotSupportedException) + { + Core.Diagnostics.Log.Warning("archive", "Frame image could not be rendered", ex); + image = null; + } + if (image is null) + { + if (File.Exists(path)) tiers[frame.Id] = new FileTier(frame.Format, DecodeTier.Unavailable, null, "no decoder produced pixels", 0, 0); + } + else if ((frame.Flags & FrameFlags.Undecodable) != 0) + { + tiers[frame.Id] = Reprobe(path, frame, 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) + { + try + { + if (_writer.Options.Decoder.Probe(path, frame.Format) is { Tier: not DecodeTier.Unavailable } tier) return tier; + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Core.Diagnostics.Log.Warning("archive", $"{path} could not be probed", ex); + } + return new FileTier(frame.Format, decoded, null, null, 0, 0); } /// Commit/checkpoint rhythm: every rendered frames or . diff --git a/src/Titano.Data/Archiving/FrameTiers.cs b/src/Titano.Data/Archiving/FrameTiers.cs new file mode 100644 index 00000000..245c89e5 --- /dev/null +++ b/src/Titano.Data/Archiving/FrameTiers.cs @@ -0,0 +1,98 @@ +using Titano.Core.Archiving; +using Titano.Core.Imaging; +using Titano.Core.Model; +using Titano.Data.Repositories; + +namespace Titano.Data.Archiving; + +/// +/// Decode tiers of archived frames (BRIEF §8.2) written to the sidecar and the index together: the tier, the +/// and flags that follow it and the preview +/// size, then the sequence row (its preview-only count for the Library chip). A sequence that gains undecodable frames +/// shows a warning at once; its next light analysis lists them. Tiers describe the host that probed or decoded the files +/// last. Only a file in a format this host decodes natively is flagged undecodable (it is damaged); one beyond this +/// host's decoders (HEIF or an unsupported RAW without a preview on the server) keeps its tier but no flag, so render +/// nodes and proxies can still provide its pixels, and a host that decodes a flagged frame clears the flag. +/// +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. + /// + public Dictionary ProbeUnknown(SequencePaths folder, SequenceManifest manifest, CancellationToken cancellationToken) + { + var tiers = new Dictionary(); + foreach (var frame in manifest.Frames) + { + 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); + Core.Diagnostics.Log.Debug("archive", $"{frame.File}: {tier.Tier} via {tier.Decoder ?? "none"}{(tier.Reason is { } why ? $" ({why})" : "")}"); + tiers[frame.Id] = tier; + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Core.Diagnostics.Log.Warning("archive", $"{path} could not be probed", ex); + } + } + return tiers; + } + + /// + /// Records (by frame id) where they change what the sidecar says, and returns the frames that + /// changed as they are now. Frames no longer in the sequence are ignored. + /// + /// The archive is offline or read-only. + public async Task> RecordAsync(Archive archive, Sequence sequence, IReadOnlyDictionary tiers, + CancellationToken cancellationToken) + { + if (tiers.Count == 0) return []; + var paths = new ArchivePaths(archive.RootPath); + ArchiveVolume.EnsureWritable(paths); + var changed = new List(); + var manifest = await writer.UpdateAsync(paths, sequence.Id, sequence.Folder, m => + { + changed.Clear(); + var gained = false; + var frames = new SidecarFrame[m.Frames.Count]; + for (var i = 0; i < frames.Length; i++) + { + var frame = m.Frames[i]; + frames[i] = frame; + if (!tiers.TryGetValue(frame.Id, out var tier)) continue; + var updated = SequenceFrames.WithTier(frame, tier, DecodesNatively(frame.Format)); + if (updated.Tier == frame.Tier && updated.Flags == frame.Flags && updated.PreviewW == frame.PreviewW && updated.PreviewH == frame.PreviewH) + continue; + gained |= (updated.Flags & ~frame.Flags & FrameFlags.Undecodable) != 0; + frames[i] = updated; + changed.Add(updated); + } + if (changed.Count == 0) return null; + return m with + { + Frames = frames, + Status = gained ? m.Status | SequenceStatus.HasWarnings : m.Status, + UpdatedAt = DateTimeOffset.UtcNow, + }; + }, cancellationToken).ConfigureAwait(false); + if (changed.Count == 0) return []; + await db.Frames.UpdateTiersAsync(changed.ConvertAll(f => new FrameTierFields(f.Id, f.Flags, f.PreviewW ?? 0, f.PreviewH ?? 0)), cancellationToken) + .ConfigureAwait(false); + var folder = paths.Sequence(sequence.Folder); + if (await db.Sequences.GetAsync(sequence.Id, cancellationToken).ConfigureAwait(false) is { } existing) + await db.Sequences.UpsertAsync(SequenceMapping.ToSequence(manifest, archive.Id, folder, existing), cancellationToken).ConfigureAwait(false); + await indexer.RecordStampsAsync(archive, folder, sequence.Id, cancellationToken).ConfigureAwait(false); + return changed; + } + + /// + /// Whether this host decodes natively, so a file of it that yields no pixels is damaged + /// rather than beyond this host (JPEG always: the managed JPEG decoder is part of every host). + /// + private bool DecodesNatively(ImageFileFormat format) => + format == ImageFileFormat.Jpeg || writer.Options.Decoder.TierFor(format) == DecodeTier.Native; +} diff --git a/src/Titano.Data/Archiving/SequenceMapping.cs b/src/Titano.Data/Archiving/SequenceMapping.cs index 7439a955..a01bdb54 100644 --- a/src/Titano.Data/Archiving/SequenceMapping.cs +++ b/src/Titano.Data/Archiving/SequenceMapping.cs @@ -32,6 +32,8 @@ internal static class SequenceMapping Format = f.Format, PreviewOffset = f.PreviewOffset, PreviewLength = f.PreviewLength, + PreviewWidth = f.PreviewW ?? 0, + PreviewHeight = f.PreviewH ?? 0, Flags = f.Flags, }; @@ -76,6 +78,7 @@ internal static class SequenceMapping SyncState = existing?.SyncState ?? SyncState.LocalOnly, OwnerUserId = existing?.OwnerUserId ?? (Guid.TryParse(m.CreatedBy, out var owner) ? owner : null), WarningCount = existing?.WarningCount ?? 0, + PreviewOnlyCount = m.Frames.Count(f => (f.Flags & FrameFlags.PreviewOnly) != 0), }; } diff --git a/src/Titano.Data/Migrations/postgres/0005_decode_tiers.sql b/src/Titano.Data/Migrations/postgres/0005_decode_tiers.sql new file mode 100644 index 00000000..797cef89 --- /dev/null +++ b/src/Titano.Data/Migrations/postgres/0005_decode_tiers.sql @@ -0,0 +1,7 @@ +-- Decode tiers (BRIEF §8.2): the size of each frame's largest embedded preview (before orientation, like width and +-- height), which caps the output of sequences whose frames decode only through it, and per sequence the number of +-- those preview-only frames for the Library chip. Mirrors sqlite/0005_decode_tiers.sql. + +ALTER TABLE frames ADD COLUMN preview_width integer NOT NULL DEFAULT 0; +ALTER TABLE frames ADD COLUMN preview_height integer NOT NULL DEFAULT 0; +ALTER TABLE sequences ADD COLUMN preview_only_count integer NOT NULL DEFAULT 0; diff --git a/src/Titano.Data/Migrations/sqlite/0005_decode_tiers.sql b/src/Titano.Data/Migrations/sqlite/0005_decode_tiers.sql new file mode 100644 index 00000000..06913b19 --- /dev/null +++ b/src/Titano.Data/Migrations/sqlite/0005_decode_tiers.sql @@ -0,0 +1,7 @@ +-- Decode tiers (BRIEF §8.2): the size of each frame's largest embedded preview (before orientation, like width and +-- height), which caps the output of sequences whose frames decode only through it, and per sequence the number of +-- those preview-only frames for the Library chip. Mirrors postgres/0005_decode_tiers.sql. + +ALTER TABLE frames ADD COLUMN preview_width INTEGER NOT NULL DEFAULT 0; +ALTER TABLE frames ADD COLUMN preview_height INTEGER NOT NULL DEFAULT 0; +ALTER TABLE sequences ADD COLUMN preview_only_count INTEGER NOT NULL DEFAULT 0; diff --git a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs index 359361d5..66446574 100644 --- a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs +++ b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs @@ -6,6 +6,7 @@ using Titano.Core.Localization; using Titano.Core.Model; using Titano.Core.Project; using Titano.Core.Render; +using Titano.Data.Archiving; using Titano.Data.Jobs; namespace Titano.Data.Processing.Jobs; @@ -14,14 +15,15 @@ namespace Titano.Data.Processing.Jobs; /// on this machine (BRIEF §11.5): target = the sequence; parameters = Protocol /// RenderJobParameters whose preset JSON is the export section of a project (preset, overrides, name template, /// folder, batch). The project is the embedded one or the sequence's own; frames flagged missing, corrupt, excluded or -/// undecodable are left out. The preset and every batch preset render after one preparation pass into the sequence's -/// exports/ (or the export folder, never on a server), named by the template without taking a name another render -/// of this process is writing, and each finished output is recorded at once (its row id derives from the job and the -/// entry, so every attempt knows what is recorded). Checkpoint: the entries recorded and the output being written, so a -/// crashed attempt's leftovers are removed and only unfinished entries render again. A failed entry fails the job after -/// the others ran; retrying renders it alone. +/// undecodable are left out, and a frame found undecodable while rendering is shown as its nearest neighbour, logged +/// and (when the originals were read) flagged so later renders leave it out (BRIEF §8.2). The preset and every batch +/// preset render after one preparation pass into the sequence's exports/ (or the export folder, never on a +/// server), named by the template without taking a name another render of this process is writing, and each finished +/// output is recorded at once (its row id derives from the job and the entry, so every attempt knows what is recorded). +/// Checkpoint: the entries recorded and the output being written, so a crashed attempt's leftovers are removed and only +/// unfinished entries render again. A failed entry fails the job after the others ran; retrying renders it alone. /// -internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions options) : IJobHandler +internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions options, FrameTiers tiers) : IJobHandler { public JobKind Kind => JobKind.Render; @@ -64,7 +66,7 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti var frames = await SequenceFrames.LoadAsync(db, archive, sequence, parameters.UseProxies, cancellation).ConfigureAwait(false); IReadOnlyList outcomes; - await using (var render = new SequenceRender(frames, project, SequenceAnalyser.ReadReport(folder, frames.Count), options)) + await using (var render = new SequenceRender(frames, project, SequenceAnalyser.ReadReport(folder, frames.Count), options, originals: !parameters.UseProxies)) { outcomes = await render.RenderAllAsync( targets, @@ -87,6 +89,20 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti }, context.ReportAsync, cancellation).ConfigureAwait(false); + if (render.StandIns.Count > 0) + context.Log(Loc.L("Export.Log.StandIns", string.Join(", ", render.StandIns.Select(i => (i + 1).ToString(Loc.Culture))))); + // Recorded without the job's token: what decoding found holds even if the job is cancelled meanwhile, and a + // sidecar that cannot be written now only leaves it to the next analysis or render. + try + { + var decoded = render.Decoded.ToDictionary(kv => frames.Frames[kv.Key].Id, kv => kv.Value); + await tiers.RecordAsync(archive, sequence, decoded, CancellationToken.None).ConfigureAwait(false); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or LeaseUnavailableException + or ArchiveOfflineException) + { + Core.Diagnostics.Log.Warning("processing", $"The decode tiers of {sequence.DisplayTitle} could not be recorded", ex); + } } var failed = outcomes.Where(o => o.Error is not null).ToList(); foreach (var outcome in failed) context.Log(Loc.L("Export.Log.Failed", outcome.Target.PresetName, outcome.Error)); diff --git a/src/Titano.Data/Processing/ProcessingService.cs b/src/Titano.Data/Processing/ProcessingService.cs index 581a87b7..02019ab8 100644 --- a/src/Titano.Data/Processing/ProcessingService.cs +++ b/src/Titano.Data/Processing/ProcessingService.cs @@ -17,6 +17,7 @@ public sealed class ProcessingService : IJobHandlerProvider { private readonly TitanoDatabase _db; private readonly SequenceAnalyser _analyser; + private readonly FrameTiers _tiers; public ProcessingService(TitanoDatabase db, ProcessingOptions? options = null) { @@ -24,7 +25,9 @@ public sealed class ProcessingService : IJobHandlerProvider Options = options ?? new ProcessingOptions(); // Sidecar and project writes coordinate with the archive engine through the archive's lease files. var writer = new SequenceWriter(Options.Archive); - _analyser = new SequenceAnalyser(db, Options, writer, new ArchiveIndexer(db, writer), new ProjectStore(db, writer)); + var indexer = new ArchiveIndexer(db, writer); + _tiers = new FrameTiers(db, writer, indexer); + _analyser = new SequenceAnalyser(db, Options, writer, indexer, new ProjectStore(db, writer)); } public ProcessingOptions Options { get; } @@ -32,7 +35,7 @@ public sealed class ProcessingService : IJobHandlerProvider /// Handlers for , and . public IReadOnlyList CreateJobHandlers() { - var render = new RenderJobHandler(_db, Options); + var render = new RenderJobHandler(_db, Options, _tiers); return [ new AnalyseJobHandler(_db, _analyser, JobKind.LightAnalyse), diff --git a/src/Titano.Data/Processing/RenderNodeClient.cs b/src/Titano.Data/Processing/RenderNodeClient.cs index c8938ad7..9a23038e 100644 --- a/src/Titano.Data/Processing/RenderNodeClient.cs +++ b/src/Titano.Data/Processing/RenderNodeClient.cs @@ -464,6 +464,8 @@ public sealed class RenderNodeClient : IAsyncDisposable Height = f.Height, Format = Enum.TryParse(f.Format, ignoreCase: true, out var format) ? format : default, Flags = (FrameFlags)f.Flags, + PreviewWidth = f.PreviewWidth, + PreviewHeight = f.PreviewHeight, }; /// diff --git a/src/Titano.Data/Processing/SequenceAnalyser.cs b/src/Titano.Data/Processing/SequenceAnalyser.cs index c99cd8c7..0122627f 100644 --- a/src/Titano.Data/Processing/SequenceAnalyser.cs +++ b/src/Titano.Data/Processing/SequenceAnalyser.cs @@ -4,6 +4,7 @@ using Titano.Core.Advice; using Titano.Core.Analysis; using Titano.Core.Analysis.Deep; using Titano.Core.Archiving; +using Titano.Core.Imaging; using Titano.Core.Model; using Titano.Data.Archiving; using Titano.Data.Repositories; @@ -20,13 +21,17 @@ internal sealed record AnalysisOutcome(Sequence Sequence, int Frames, int Warnin /// /// Light (BRIEF §10.1) and deep (§10.2) analysis of archived sequences, followed by the advisor (§10.3–10.4) filling the -/// Auto values of the project. The light pass reads the index only (plus one file for the GPS fix); the deep pass decodes -/// every frame, checkpointing into .titano/analysis.partial so a cancelled, paused or crashed run resumes, and -/// saves analysis.json atomically. Results land in the sidecar status, the index (status, warning count, compact -/// summary, per-frame light statistics) and project.json. +/// Auto values of the project. The light pass reads the index, probes the decode tier (§8.2) of frames whose tier is not +/// known yet (headers only, once per frame) and reads one file for the GPS fix; the deep pass decodes every frame, +/// checkpointing into .titano/analysis.partial so a cancelled, paused or crashed run resumes, records the tier +/// each frame decoded at (or that it did not decode) and saves analysis.json atomically. Results land in the +/// sidecar (status, tiers), the index (status, warning count, compact summary, tier flags, per-frame light statistics) +/// and project.json. /// internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions options, SequenceWriter writer, ArchiveIndexer indexer, ProjectStore projects) { + private readonly FrameTiers _tiers = new(db, writer, indexer); + /// Analyses one sequence; null when it is no longer in the index. /// The archive is offline or read-only. public async Task AnalyseAsync(Guid sequenceId, bool deep, IProgress? progress, CancellationToken cancellationToken) @@ -37,12 +42,23 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti ArchiveVolume.EnsureWritable(paths); 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); + frames = WithTiers(frames, await _tiers.RecordAsync(archive, sequence, probed, cancellationToken).ConfigureAwait(false)); var metadata = frames.LightFrames(); - var light = LightAnalyzer.Analyze(metadata); - var report = deep - ? await AnalyseDeepAsync(frames, metadata, folder, progress, cancellationToken).ConfigureAwait(false) - : ReadReport(folder, frames.Count); + 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)); + metadata = [.. metadata.Select((m, i) => m with { Flags = frames.Frames[i].Flags })]; + } + else + { + report = ReadReport(folder, frames.Count); + } + var light = LightAnalyzer.Analyze(metadata); var context = SequenceContext.FromFrames(frames.Frames, options.AdvisorCodecs); bool changed, unreadable = false; @@ -100,15 +116,47 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti } } - private async Task AnalyseDeepAsync(SequenceFrames frames, IReadOnlyList metadata, SequencePaths folder, - IProgress? progress, CancellationToken cancellationToken) + /// The frame rows with the tier fields of sidecar frames. + private static SequenceFrames WithTiers(SequenceFrames frames, IReadOnlyList changed) + { + if (changed.Count == 0) return frames; + var byId = changed.ToDictionary(f => f.Id); + var rows = frames.Frames.Select(f => byId.TryGetValue(f.Id, out var s) + ? f with { Flags = s.Flags, PreviewWidth = s.PreviewW ?? 0, PreviewHeight = s.PreviewH ?? 0 } + : f).ToList(); + return frames with { Frames = rows }; + } + + /// + /// 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. + /// + private static Dictionary Decoded(SequenceFrames frames, DeepAnalysisReport report, IReadOnlyDictionary observed) + { + var tiers = new Dictionary(); + foreach (var (index, tier) in observed) tiers[frames.Frames[index].Id] = tier; + foreach (var index in report.Issues.Undecodable) + { + if (index >= frames.Count || observed.ContainsKey(index) || frames.Files[index] is null + || (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); + } + return tiers; + } + + private async Task<(DeepAnalysisReport Report, IReadOnlyDictionary Observed)> AnalyseDeepAsync(SequenceFrames frames, + IReadOnlyList metadata, SequencePaths folder, IProgress? progress, CancellationToken cancellationToken) { var file = new DeepAnalysisCheckpointFile(Path.Combine(folder.MetaDirectory, DeepAnalysisCheckpointFile.FileName)); DeepAnalysisReport report; - await using (var source = new SequenceFrameSource(frames, metadata, options.Archive.Decoder)) + IReadOnlyDictionary observed; + await using (var source = new SequenceFrameSource(frames, metadata, options.Archive.Decoder) { Originals = true }) { report = await DeepAnalyzer.AnalyzeAsync(source, options.DeepAnalysis, new FramesCheckpoint(file, ContentKey(frames)), progress, cancellationToken) .ConfigureAwait(false); + observed = source.Observed.ToDictionary(); } report.Save(folder.AnalysisPath); file.Delete(); @@ -118,7 +166,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; + return (report, observed); } /// 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 34f6a268..8fb0aaf9 100644 --- a/src/Titano.Data/Processing/SequenceFrameSource.cs +++ b/src/Titano.Data/Processing/SequenceFrameSource.cs @@ -1,3 +1,4 @@ +using System.Collections.Concurrent; using System.Globalization; using Titano.Core.Advice; using Titano.Core.Analysis; @@ -10,9 +11,11 @@ namespace Titano.Data.Processing; /// /// The frames of a decoded by the host's (oriented, linear /// light, embedded previews when nothing else decodes). For the deep analysis a frame that is missing, corrupt or -/// unreadable is null, as expects. Renders exclude flagged frames from the plan, so a -/// frame that still cannot be decoded stops the render with ; render reads go through -/// a per decode size, which decodes ahead in index order and spills under memory pressure. +/// unreadable is null, as expects. Renders exclude flagged frames from the plan; a frame that +/// 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. /// internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IAsyncDisposable { @@ -27,6 +30,9 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA private readonly FrameWindowOptions _windowOptions; private readonly Lazy<(int Width, int Height)> _size; private readonly SemaphoreSlim _gate = new(1, 1); + private readonly ConcurrentDictionary _observed = new(); + private readonly ConcurrentDictionary _standIns = new(); + private readonly ConcurrentDictionary _failed = new(); private FrameWindow? _window; private (int Edge, DecodePurpose Purpose) _windowKey; @@ -40,6 +46,24 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA _size = new Lazy<(int, int)>(MeasureSize); } + /// The files are the archive's originals, so what decoding finds describes the frames (). + public bool Originals { get; init; } + + /// + /// Positions the render plan leaves out. When set, a render frame that does not decode is replaced by the nearest + /// planned frame that does, instead of failing the render. + /// + 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 . + /// + public IReadOnlyDictionary Observed => _observed; + + /// Positions a render showed a neighbour for because they did not decode, ascending. + public IReadOnlyList StandIns => [.. _standIns.Keys.Order()]; + public int Count => _frames.Count; public int FrameCount => _frames.Count; @@ -92,35 +116,77 @@ internal sealed class SequenceFrameSource : IFrameSource, IRenderFrameSource, IA } } - private ImageBuffer DecodeForRender(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) => - Decode(index, maxLongEdge, purpose, cancellationToken)?.Pixels ?? throw Unreadable(index); + private ImageBuffer DecodeForRender(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. + _failed.TryAdd(index, 0); + for (var distance = 1; distance < Count; distance++) + { + ReadOnlySpan neighbours = [index - distance, index + distance]; + foreach (var neighbour in neighbours) + { + 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; + } + _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; + } + } + throw Unreadable(index); + } private DecodedImage? Decode(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) { if (_frames.Files[index] is not { } file) return null; + DecodedImage? decoded; try { - return _decoder.Decode(new DecodeRequest(file, maxLongEdge, purpose), cancellationToken); + decoded = _decoder.Decode(new DecodeRequest(file, maxLongEdge, purpose), cancellationToken); } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { 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); + } + return decoded; } - /// The dominant oriented size from the metadata, else the size the first renderable frame decodes to. + /// + /// The dominant oriented size from the metadata, else the size the first renderable frame decodes to (frames that do + /// not decode are passed over while a render may stand in for them). + /// private (int, int) MeasureSize() { var context = SequenceContext.FromFrames(_frames.Frames); if (context.SourceWidth > 0 && context.SourceHeight > 0) return (context.SourceWidth, context.SourceHeight); var skipped = _frames.NotRenderable().ToHashSet(); + if (RenderExcluded is { } excluded) skipped.UnionWith(excluded); + int? first = null; for (var i = 0; i < Count; i++) { if (skipped.Contains(i)) continue; - using var probe = Decode(i, ProbeLongEdge, DecodePurpose.Thumbnail, CancellationToken.None) ?? throw Unreadable(i); - return (probe.SourceWidth, probe.SourceHeight); + using var probe = Decode(i, ProbeLongEdge, DecodePurpose.Thumbnail, CancellationToken.None); + if (probe is not null) return (probe.SourceWidth, probe.SourceHeight); + first ??= i; + if (RenderExcluded is null) break; } + if (first is { } unreadable) throw Unreadable(unreadable); throw new RenderException("Export.Render.NoFrames", "Every frame is excluded."); } diff --git a/src/Titano.Data/Processing/SequenceRender.cs b/src/Titano.Data/Processing/SequenceRender.cs index 2c5e8ca4..edf29c10 100644 --- a/src/Titano.Data/Processing/SequenceRender.cs +++ b/src/Titano.Data/Processing/SequenceRender.cs @@ -1,6 +1,7 @@ using Titano.Core.Analysis; using Titano.Core.Analysis.Deep; using Titano.Core.Export; +using Titano.Core.Imaging; using Titano.Core.Localization; using Titano.Core.Model; using Titano.Core.Project; @@ -30,23 +31,36 @@ internal sealed class SequenceRender : IAsyncDisposable private readonly RenderOptions _options; /// The sequence's deep report, when current: its luminance spares the preparation a decode pass. - public SequenceRender(SequenceFrames frames, ProjectSettings project, DeepAnalysisReport? analysis, ProcessingOptions options) + /// 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) { var metadata = frames.LightFrames(); - _source = new SequenceFrameSource(frames, metadata, options.Archive.Decoder, options.FrameWindow); + var planned = project with { ExcludedFrames = [.. project.ExcludedFrames.Union(frames.NotRenderable()).Order()] }; + // A frame that turns out not to decode is shown as its nearest planned neighbour instead of failing the render. + _source = new SequenceFrameSource(frames, metadata, options.Archive.Decoder, options.FrameWindow) + { + Originals = originals, + RenderExcluded = planned.ExcludedFrames.ToHashSet(), + }; _processing = options; _options = options.Render; Input = new RenderInput { Source = _source, Frames = SourceFrameInfo.From(frames.Frames, LightAnalyzer.Analyze(metadata).AdjustedTimes), - Project = project with { ExcludedFrames = [.. project.ExcludedFrames.Union(frames.NotRenderable()).Order()] }, + Project = planned, Analysis = analysis?.FrameCount == frames.Count ? new PrecomputedAnalysis { LogLuminance = Luminance(analysis.Frames) } : null, }; } public RenderInput Input { get; } + /// Positions that did not decode during the render; a neighbour stood in for each (ascending). + public IReadOnlyList StandIns => _source.StandIns; + + /// The decode tier each frame was read at so far (unavailable when it did not decode); originals only. + public IReadOnlyDictionary Decoded => _source.Observed; + /// Encoder, geometry and plan of an export before its output is named. public RenderSetup Setup(ResolvedExport export) => Pipeline(export).Setup(Input, new RenderTarget(export, ExportNaming.FallbackName), _options); diff --git a/src/Titano.Data/Repositories/FrameRepository.cs b/src/Titano.Data/Repositories/FrameRepository.cs index cb10e5e7..bac5ed69 100644 --- a/src/Titano.Data/Repositories/FrameRepository.cs +++ b/src/Titano.Data/Repositories/FrameRepository.cs @@ -16,6 +16,9 @@ public sealed record DuplicateFrame(string Sha256, Guid FrameId, Guid SequenceId /// Light statistics of one frame, written by the analysis job. public readonly record struct FrameLightStats(Guid FrameId, double? MeanLogLuminance, double? ClipLow, double? ClipHigh); +/// Decode-tier fields of one frame (BRIEF §8.2): its flags and the stored size of its largest embedded preview. +public readonly record struct FrameTierFields(Guid FrameId, FrameFlags Flags, int PreviewWidth, int PreviewHeight); + /// Per-format totals and flagged-frame counts of one sequence. public sealed record SequenceFrameStats(IReadOnlyList ByFormat, long Missing, long Corrupt, long Duplicate, long Excluded); @@ -27,7 +30,7 @@ public sealed class FrameRepository "id", "sequence_id", "idx", "relative_path", "file_name", "original_file_name", "size", "sha256", "captured_at", "utc_offset_minutes", "timestamp_source", "exposure_time", "f_number", "iso", "focal_length", "exposure_bias", "white_balance", "orientation", "width", "height", "format", "preview_offset", "preview_length", - "mean_log_luminance", "clip_low", "clip_high", "flags", + "mean_log_luminance", "clip_low", "clip_high", "flags", "preview_width", "preview_height", ]; private static readonly string Columns = string.Join(", ", ColumnNames); @@ -37,7 +40,7 @@ public sealed class FrameRepository /// Rows per statement of the batched PostgreSQL updates (4 or fewer parameters per row). private const int Batch = 1000; - /// Rows per multi-row upsert: 30 x 27 parameters stays below SQLite's historical 999-variable limit. + /// Rows per multi-row upsert: 30 x 29 parameters stays below SQLite's historical 999-variable limit. private const int UpsertRows = 30; /// Light statistics belong to the analysis job; a sync from the sidecar never clears them. @@ -130,6 +133,19 @@ public sealed class FrameRepository return updated; }, cancellationToken); + /// Writes the decode-tier fields of many frames in one transaction; returns the number of frames updated. + public Task UpdateTiersAsync(IReadOnlyList frames, CancellationToken cancellationToken = default) => + _db.InTransactionAsync(async session => + { + var updated = 0; + 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); + /// /// Makes the frames of a sequence exactly (from its sidecar): rows are upserted by id, /// rows not listed are deleted, light statistics of kept rows survive. Indexes may be renumbered freely. @@ -239,7 +255,7 @@ public sealed class FrameRepository f.Id, f.SequenceId, f.Index, f.RelativePath, f.FileName, f.OriginalFileName, f.Size, f.Sha256?.ToLowerInvariant(), SequenceRepository.Wall(f.CapturedAt), f.UtcOffsetMinutes, (int)f.TimestampSource, f.ExposureTime, f.FNumber, f.Iso, f.FocalLength, f.ExposureBias, f.WhiteBalance, f.Orientation, f.Width, f.Height, (int)f.Format, f.PreviewOffset, - f.PreviewLength, f.MeanLogLuminance, f.ClipLow, f.ClipHigh, (int)f.Flags, + f.PreviewLength, f.MeanLogLuminance, f.ClipLow, f.ClipHigh, (int)f.Flags, f.PreviewWidth, f.PreviewHeight, ]; private static Frame Map(DbRow r) => new() @@ -271,5 +287,7 @@ public sealed class FrameRepository ClipLow = r.GetDoubleOrNull(24), ClipHigh = r.GetDoubleOrNull(25), Flags = (FrameFlags)r.GetInt32(26), + PreviewWidth = r.GetInt32(27), + PreviewHeight = r.GetInt32(28), }; } diff --git a/src/Titano.Data/Repositories/SequenceRepository.cs b/src/Titano.Data/Repositories/SequenceRepository.cs index a4735d37..a7e78308 100644 --- a/src/Titano.Data/Repositories/SequenceRepository.cs +++ b/src/Titano.Data/Repositories/SequenceRepository.cs @@ -122,7 +122,8 @@ public sealed class SequenceRepository private const string Columns = "s.id, s.archive_id, s.title, s.folder, s.camera_make, s.camera_model, s.camera_serial, s.lens, s.first_capture, s.last_capture, " + "s.frame_count, s.median_interval, s.total_bytes, s.status, s.rendered_count, s.verified_at, s.hero_frame_id, s.rating, s.notes, " + - "s.settings_json, s.analysis_json, s.origin, s.sync_state, s.settings_version, s.frames_version, s.owner_user_id, s.warning_count, s.updated_at"; + "s.settings_json, s.analysis_json, s.origin, s.sync_state, s.settings_version, s.frames_version, s.owner_user_id, s.warning_count, s.updated_at, " + + "s.preview_only_count"; /// rendered_count is owned by once the row exists. private static readonly string UpsertSql = SqlDialect.Upsert("sequences", @@ -130,12 +131,12 @@ public sealed class SequenceRepository "id", "archive_id", "title", "title_key", "search_text", "folder", "camera_make", "camera_model", "camera_serial", "lens", "first_capture", "last_capture", "frame_count", "median_interval", "total_bytes", "status", "rendered_count", "verified_at", "hero_frame_id", "rating", "notes", "settings_json", "analysis_json", "origin", "sync_state", "settings_version", - "frames_version", "owner_user_id", "warning_count", "updated_at", + "frames_version", "owner_user_id", "warning_count", "updated_at", "preview_only_count", ], 1, ["rendered_count"]); /// Ordinal of the tag list after , and of the sort key a listing appends after it. - private const int TagsOrdinal = 28; - private const int SortKeyOrdinal = 29; + private const int TagsOrdinal = 29; + private const int SortKeyOrdinal = 30; private readonly DbAccess _db; private readonly string _select; @@ -445,7 +446,7 @@ public sealed class SequenceRepository s.Id, s.ArchiveId, s.Title, s.DisplayTitle.ToLowerInvariant(), search, s.Folder, s.CameraMake, s.CameraModel, s.CameraSerial, s.Lens, Wall(s.FirstCapture), Wall(s.LastCapture), s.FrameCount, s.MedianInterval, s.TotalBytes, (int)s.Status, s.RenderedCount, s.VerifiedAt, s.HeroFrameId, s.Rating, s.Notes, DbParam.Json(s.SettingsJson), DbParam.Json(s.AnalysisJson), (int)s.Origin, (int)s.SyncState, - s.SettingsVersion, s.FramesVersion, s.OwnerUserId, s.WarningCount, s.UpdatedAt, + s.SettingsVersion, s.FramesVersion, s.OwnerUserId, s.WarningCount, s.UpdatedAt, s.PreviewOnlyCount, ], cancellationToken); } @@ -523,6 +524,7 @@ public sealed class SequenceRepository OwnerUserId = r.GetGuidOrNull(25), WarningCount = r.GetInt32(26), UpdatedAt = r.GetDateTimeOffset(27), + PreviewOnlyCount = r.GetInt32(28), Tags = tags, }; } diff --git a/src/Titano.Protocol/Sequences.cs b/src/Titano.Protocol/Sequences.cs index 8ad09422..ecc90de6 100644 --- a/src/Titano.Protocol/Sequences.cs +++ b/src/Titano.Protocol/Sequences.cs @@ -1,6 +1,7 @@ namespace Titano.Protocol; /// Sequence summary for lists (BRIEF §12.2 card data). +/// Frames that decode only through their embedded preview (BRIEF §8.2 tier 2). public sealed record SequenceDto( Guid Id, string? Title, @@ -24,7 +25,8 @@ public sealed record SequenceDto( int FramesVersion, int WarningCount, Guid? OwnerUserId, - DateTimeOffset UpdatedAt); + DateTimeOffset UpdatedAt, + int PreviewOnlyCount = 0); /// A page of results with an opaque keyset cursor; null cursor = last page. public sealed record Page(IReadOnlyList Items, string? NextCursor, long? Total); @@ -45,6 +47,8 @@ public sealed record UpdateSequenceRequest( int? ExpectedSettingsVersion, Guid? HeroFrameId = null); +/// Width of the largest embedded preview before orientation, like ; 0 when unknown. +/// Height of that preview before orientation; 0 when unknown. public sealed record FrameDto( Guid Id, Guid SequenceId, @@ -62,7 +66,9 @@ public sealed record FrameDto( int Width, int Height, string Format, - long Flags); + long Flags, + int PreviewWidth = 0, + int PreviewHeight = 0); /// GET /api/v1/sequences/{id}/manifest: what a client needs to diff a sequence (BRIEF §14.5). public sealed record SequenceManifest( diff --git a/src/Titano.Server/Api/Dto.cs b/src/Titano.Server/Api/Dto.cs index a80cf647..d3ca9e76 100644 --- a/src/Titano.Server/Api/Dto.cs +++ b/src/Titano.Server/Api/Dto.cs @@ -17,11 +17,11 @@ public static class Dto public static SequenceDto Sequence(Sequence s) => new( s.Id, s.Title, s.DisplayTitle, s.Folder, s.CameraMake, s.CameraModel, s.Lens, s.FirstCapture, s.LastCapture, s.FrameCount, s.MedianInterval, s.TotalBytes, (long)s.Status, s.RenderedCount, s.HeroFrameId, s.Tags, s.Rating, s.Notes, s.SettingsVersion, - s.FramesVersion, s.WarningCount, s.OwnerUserId, s.UpdatedAt); + s.FramesVersion, s.WarningCount, s.OwnerUserId, s.UpdatedAt, s.PreviewOnlyCount); public static FrameDto Frame(Frame f) => new( f.Id, f.SequenceId, f.Index, f.FileName, f.Size, f.Sha256, f.CapturedAt, f.UtcOffsetMinutes, f.ExposureTime, f.FNumber, f.Iso, - f.FocalLength, f.Orientation, f.Width, f.Height, f.Format.ToString().ToLowerInvariant(), (long)f.Flags); + f.FocalLength, f.Orientation, f.Width, f.Height, f.Format.ToString().ToLowerInvariant(), (long)f.Flags, f.PreviewWidth, f.PreviewHeight); public static RenderDto Render(Render r) => new(r.Id, r.PresetName, r.Codec, r.Width, r.Height, r.Fps, r.DurationSeconds, r.Bytes, r.Created, r.ProducedBy); diff --git a/src/Titano.Ui/Controls/StatusGlyph.cs b/src/Titano.Ui/Controls/StatusGlyph.cs index d5d13bc1..76f093c8 100644 --- a/src/Titano.Ui/Controls/StatusGlyph.cs +++ b/src/Titano.Ui/Controls/StatusGlyph.cs @@ -23,6 +23,9 @@ public enum StatusKind Paused, Online, Offline, + + /// Frames that decode only through their embedded preview (BRIEF §8.2 tier 2). + PreviewOnly, } /// Glyph + text in the colour of the status kind. diff --git a/src/Titano.Ui/Themes/Controls.xaml b/src/Titano.Ui/Themes/Controls.xaml index 158b26f7..044df000 100644 --- a/src/Titano.Ui/Themes/Controls.xaml +++ b/src/Titano.Ui/Themes/Controls.xaml @@ -1356,6 +1356,9 @@ + + + diff --git a/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs b/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs new file mode 100644 index 00000000..72e5c19a --- /dev/null +++ b/tests/Titano.Core.Tests/Archiving/DecodeTierTests.cs @@ -0,0 +1,198 @@ +using System.Text; +using Titano.Core.Advice; +using Titano.Core.Analysis; +using Titano.Core.Analysis.Deep; +using Titano.Core.Archiving; +using Titano.Core.Codecs.Jpeg; +using Titano.Core.Diagnostics.Synthetic; +using Titano.Core.Imaging; +using Titano.Core.Imaging.Decoders; +using Titano.Core.Metadata; +using Titano.Core.Model; +using Titano.Core.Tests.Analysis.Deep; +using Titano.Core.Tests.Raw; +using Titano.Testing; + +namespace Titano.Core.Tests.Archiving; + +/// Decode tiers of frames (BRIEF §8.2): sidecar fields, flags, thumbnails from previews, and what the advisor reads. +[Category("archive")] +public sealed class DecodeTierTests(TestContext context) +{ + private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0); + + private static SidecarFrame Sidecar(int orientation = 1, int? previewW = null, int? previewH = null) => new() + { + Id = Guid.CreateVersion7(), + File = "originals/IMG_0001.CR2", + Format = ImageFileFormat.Cr2, + W = 6000, + H = 4000, + Orientation = orientation, + PreviewW = previewW, + PreviewH = previewH, + }; + + [Test] + public void TheTierSetsItsFlagsAndThePreviewSize() + { + var frame = Sidecar(orientation: 6) with { Flags = FrameFlags.Duplicate }; + // FileTier sizes are oriented; the sidecar keeps them like W and H, before orientation. + var preview = SequenceFrames.WithTier(frame, new FileTier(ImageFileFormat.Cr2, DecodeTier.EmbeddedPreview, "managed-preview", "body", 1080, 1620)); + Assert.Equal((DecodeTier.EmbeddedPreview, FrameFlags.Duplicate | FrameFlags.PreviewOnly, (int?)1620, (int?)1080), + (preview.Tier, preview.Flags, preview.PreviewW, preview.PreviewH)); + + var none = SequenceFrames.WithTier(preview, new FileTier(ImageFileFormat.Cr2, DecodeTier.Unavailable, null, "nothing", 0, 0)); + Assert.Equal((FrameFlags.Duplicate | FrameFlags.Undecodable, (int?)1620), (none.Flags, none.PreviewW)); + + var native = SequenceFrames.WithTier(none, new FileTier(ImageFileFormat.Cr2, DecodeTier.Native, "wic", null, 4000, 6000)); + Assert.Equal((DecodeTier.Native, FrameFlags.Duplicate, (int?)1620), (native.Tier, native.Flags, native.PreviewW)); + + // A host without a native decoder for the format proves nothing about the file: tier kept, flag left as it was. + var beyond = SequenceFrames.WithTier(native, new FileTier(ImageFileFormat.Cr2, DecodeTier.Unavailable, null, "nothing here", 0, 0), damaged: false); + Assert.Equal((DecodeTier.Unavailable, FrameFlags.Duplicate), (beyond.Tier, beyond.Flags)); + Assert.Equal(FrameFlags.Duplicate | FrameFlags.Undecodable, + SequenceFrames.WithTier(none, new FileTier(ImageFileFormat.Cr2, DecodeTier.Unavailable, null, "nothing here", 0, 0), damaged: false).Flags); + } + + [Test] + public void SidecarsKeepTheTierAndThePreviewSizeAndOlderOnesReadAsUnknown() + { + var path = Path.Combine(context.CreateTempDirectory(), "sequence.json"); + var frame = SequenceFrames.WithTier(Sidecar(previewW: 1620, previewH: 1080), + new FileTier(ImageFileFormat.Cr2, DecodeTier.EmbeddedPreview, "managed-preview", null, 1620, 1080)); + ManifestStore.WriteSequence(path, new SequenceManifest { Id = Guid.CreateVersion7(), Frames = [frame] }); + var json = File.ReadAllText(path); + Assert.Contains("\"tier\":\"EmbeddedPreview\"", json); + Assert.Contains("\"previewW\":1620", json); + var read = ManifestStore.ReadSequence(path).Frames.Single(); + Assert.Equal((DecodeTier.EmbeddedPreview, FrameFlags.PreviewOnly, (int?)1620, (int?)1080), (read.Tier, read.Flags, read.PreviewW, read.PreviewH)); + + // A frame never probed writes no tier, and a sidecar from before tiers reads as unknown. + ManifestStore.WriteSequence(path, new SequenceManifest { Id = Guid.CreateVersion7(), Frames = [Sidecar()] }); + Assert.DoesNotContain("tier", File.ReadAllText(path).Split('"')); + var older = ManifestStore.ParseSequence(Encoding.UTF8.GetBytes( + """{"id":"0192f7a0-0000-7000-8000-000000000001","frames":[{"id":"0192f7a0-0000-7000-8000-000000000002","file":"a.jpg","tier":"SomethingNew"}]}"""), "test"); + Assert.Equal((DecodeTier)0, older.Frames.Single().Tier); + } + + [Test] + public void IndexingKeepsTheSizeOfTheLargestPreview() + { + var metadata = new FrameMetadata + { + Format = ImageFileFormat.Cr2, + Width = 6000, + Height = 4000, + Previews = [new EmbeddedPreview(4096, 90_000, 1620, 1080, PreviewKind.Preview), new EmbeddedPreview(100, 4000, 160, 120, PreviewKind.Thumbnail)], + }; + var frame = SequenceFrames.FromMetadata(Guid.CreateVersion7(), "a.cr2", "a.cr2", 10, null, metadata); + Assert.Equal((4096L, (int?)1620, (int?)1080, (DecodeTier)0), (frame.PreviewOffset!.Value, frame.PreviewW, frame.PreviewH, frame.Tier)); + Assert.Null(SequenceFrames.FromMetadata(Guid.CreateVersion7(), "b.jpg", "b.jpg", 10, null, new FrameMetadata { Format = ImageFileFormat.Jpeg }).PreviewW); + } + + [Test] + public void ThumbnailsUseAStoredPreviewOnlyWhenItReachesTheThumbnailSize() + { + var archive = new ArchivePaths(context.CreateTempDirectory("archive")); + var sequence = archive.Sequence("s"); + Directory.CreateDirectory(sequence.Originals); + using var scene = SyntheticRaw.Smooth(640, 480); + var dng = SyntheticDng.Write(scene, new DngSpec()); + var renderer = new FrameImageRenderer(DecoderFactory.CreateServer()); + + EncodedImage Thumbnail(string name, int previewWidth, bool sizeKnown) + { + // 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 frame = new SidecarFrame + { + Id = Guid.CreateVersion7(), + File = "originals/" + name, + Format = ImageFileFormat.Dng, + W = 640, + H = 480, + PreviewOffset = dng.Length, + PreviewLength = preview.Length, + PreviewW = sizeKnown ? previewWidth : null, + PreviewH = sizeKnown ? previewWidth * 3 / 4 : null, + }; + return renderer.Thumbnail(sequence, frame)!; + } + + // A 200 px preview would leave the thumbnail short of 320 px (ENG-10): the RAW is developed instead. + var small = Thumbnail("small.dng", 200, sizeKnown: true); + 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)); + 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); + } + + [Test] + public void TheAdvisorCapsTheOutputAtThePreviewsOfPreviewOnlyFrames() + { + var sequence = Guid.CreateVersion7(); + Frame Row(int index, FrameFlags flags, int previewW, int previewH) => new() + { + Id = Guid.CreateVersion7(), + SequenceId = sequence, + Index = index, + RelativePath = $"s/{index}.cr3", + FileName = $"{index}.cr3", + CapturedAt = Start.AddSeconds(5 * index), + ExposureTime = 1.0 / 250, + FNumber = 8, + Iso = 100, + Width = 6000, + Height = 4000, + Orientation = 6, + Flags = flags, + PreviewWidth = previewW, + PreviewHeight = previewH, + }; + var rows = Enumerable.Range(0, 20) + .Select(i => Row(i, i == 19 ? FrameFlags.Undecodable : i < 15 ? FrameFlags.PreviewOnly : FrameFlags.None, i == 3 ? 1280 : 1620, i == 3 ? 960 : 1080)) + .ToList(); + + var context = SequenceContext.FromFrames(rows); + // Portrait frames: the previews are oriented like the main image; the most common preview size wins. + Assert.Equal((4000, 6000, 15, 1080, 1620), (context.SourceWidth, context.SourceHeight, context.PreviewOnlyCount, context.PreviewWidth, context.PreviewHeight)); + + var light = LightAnalyzer.Analyze(rows); + Assert.SequenceEqual(Enumerable.Range(0, 15), light.PreviewOnlyFrames); + Assert.SequenceEqual([19], light.UndecodableFrames); + var preview = light.Findings.Single(f => f.Key == FindingKeys.PreviewOnly); + Assert.Equal((FindingSeverity.Info, (object)15), (preview.Severity, preview.Arguments[0])); + Assert.Equal(FindingSeverity.Warning, light.Findings.Single(f => f.Key == DeepFindingKeys.UnreadableFrames).Severity); + + var result = Advisor.Recommend(light, null, context); + var resolution = result.Find(AdvisorParameters.Resolution)!; + Assert.Equal(AdvisorKeys.ResolutionPreview, resolution.ReasonKey); + Assert.SequenceEqual([15, 1080, 1620], resolution.ReasonArgs.Select(Convert.ToInt32)); + } + + [Test] + public async Task FramesBothAnalysesFoundUndecodableAreListedOnce() + { + var source = new SyntheticFrameSource(SyntheticSequence.Create(new SyntheticSequenceOptions { Width = 96, Height = 64, FrameCount = 12 })) + { + Undecodable = [4], + }; + 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. + var unflagged = Advisor.Recommend(LightAnalyzer.Analyze(metadata), deep, context).Findings.Where(f => f.Key == DeepFindingKeys.UnreadableFrames).ToList(); + Assert.SequenceEqual([4], unflagged.Single().Frames); + + // Once flagged, the light analysis lists it and the deep finding is not repeated. + 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()); + } +} diff --git a/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs b/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs index bcbc861e..a3edf6a7 100644 --- a/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs +++ b/tests/Titano.Core.Tests/Decoding/ManagedDecoderProviderTests.cs @@ -5,6 +5,8 @@ using Titano.Core.Codecs.Tiff; using Titano.Core.Imaging; using Titano.Core.Imaging.Decoders; using Titano.Core.Metadata; +using Titano.Core.Metadata.Tiff; +using Titano.Core.Tests.Metadata.Builders; using Titano.Core.Tests.Raw; using Titano.Testing; using static Titano.Core.Tests.Raw.NativeRawWriters; @@ -201,6 +203,76 @@ public sealed class ManagedDecoderProviderTests(TestContext context) } } + [Test] + public void TheChainProbesEachFileForItsTier() + { + var server = DecoderFactory.CreateServer(); + // JPEG, PNG and TIFF decode natively whatever they hold: the probe does not even open them. + Assert.Equal(DecodeTier.Native, server.Probe(Path.Combine(_dir, "absent.jpg"), ImageFileFormat.Jpeg).Tier); + + var supported = server.Probe(Write("IMG_5.CR2", Cr2File("Canon EOS 5D Mark III")), ImageFileFormat.Cr2); + Assert.Equal((DecodeTier.Native, "managed-cr2"), (supported.Tier, supported.Decoder)); + + // An unsupported body decodes only through its 64×48 preview, rotated like the main image (orientation 6). + var preview = server.Probe(Write("IMG_6.CR2", Cr2File("Canon EOS R99", orientation: 6)), ImageFileFormat.Cr2); + Assert.Equal((DecodeTier.EmbeddedPreview, 48, 64), (preview.Tier, preview.Width, preview.Height)); + Assert.Contains("no colour matrix", preview.Reason); + + using var scene = SyntheticRaw.Smooth(W, H); + var nef = Nef(Sensor(scene, "Nikon D850", CfaPattern.Bayer("RGGB"), W, H, 0, 0, 600, 16383), 14, NefEncoding.Lossless); + var unknownBody = System.Text.Encoding.Latin1.GetBytes(System.Text.Encoding.Latin1.GetString(nef).Replace("NIKON D850", "NIKON Z99X")); + var none = server.Probe(Write("DSC_7.NEF", unknownBody), ImageFileFormat.Nef); + Assert.Equal(DecodeTier.Unavailable, none.Tier); + Assert.Contains("no embedded preview", none.Reason); + + // A Windows-like provider native for CR3 answers from its codec list, before the managed preview tier. + var client = DecoderFactory.CreateClient(new FakeProvider()); + var cr3 = client.Probe(Path.Combine(_dir, "absent.cr3"), ImageFileFormat.Cr3); + Assert.Equal((DecodeTier.Native, "fake"), (cr3.Tier, cr3.Decoder)); + Assert.Equal(DecodeTier.Unavailable, client.Probe(Write("y.webp", Fixtures.WebP()), ImageFileFormat.WebP).Tier); + } + + [Test] + public void GoProRawDecodesThroughTheJpegBesideIt() + { + var gpr = Write("GOPR0001.GPR", Gpr(previewWidth: 64, previewHeight: 48)); + var server = DecoderFactory.CreateServer(); + // Alone, a GPR (VC-5, out of scope) shows its embedded preview. + using (var alone = server.Decode(new DecodeRequest(gpr))) + Assert.Equal(("managed-preview", 64), (alone!.Decoder, alone.Pixels.Width)); + + Write("GOPR0001.JPG", JpegFile(160, 120, 1)); + using (var withJpeg = server.Decode(new DecodeRequest(gpr))) + { + Assert.Equal((DecodeTier.EmbeddedPreview, "managed-sidecar"), (withJpeg!.Tier, withJpeg.Decoder)); + Assert.Equal((160, 120, 160, 120), (withJpeg.Pixels.Width, withJpeg.Pixels.Height, withJpeg.SourceWidth, withJpeg.SourceHeight)); + } + using (var scaled = server.Decode(new DecodeRequest(gpr, MaxLongEdge: 40, Purpose: DecodePurpose.Thumbnail))) + Assert.Equal(40, scaled!.Pixels.Width); + var probe = new ManagedDecoderProvider().Probe(gpr); + Assert.Equal((DecodeTier.EmbeddedPreview, "managed-sidecar", 160, 120), (probe.Tier, probe.Decoder, probe.Width, probe.Height)); + + // A companion smaller than the embedded preview is not the better source. + var big = Write("GOPR0002.GPR", Gpr(previewWidth: 320, previewHeight: 240)); + Write("GOPR0002.JPG", JpegFile(160, 120, 1)); + using (var preview = server.Decode(new DecodeRequest(big))) + Assert.Equal(("managed-preview", 320), (preview!.Decoder, preview.Pixels.Width)); + Assert.Equal("managed-preview", new ManagedDecoderProvider().Probe(big).Decoder); + } + + /// 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) + { + var preview = new IfdSpec().Long(TiffTags.NewSubfileType, 1) + .Long(TiffTags.ImageWidth, (uint)previewWidth).Long(TiffTags.ImageLength, (uint)previewHeight) + .Short(TiffTags.BitsPerSample, 8, 8, 8).Short(TiffTags.Compression, 7) + .Short(TiffTags.PhotometricInterpretation, 6).Strip(JpegFile(previewWidth, previewHeight, 1)); + var ifd0 = Fixtures.Ifd0("GoPro", "HERO8 Black", 1) + .Bytes(TiffTags.DngVersion, 1, 4, 0, 0) + .Child(TiffTags.SubIfds, preview); + return TiffFile.Build(ifd0); + } + /// A Windows-like provider claiming native support for everything but declining every file. private sealed class FakeProvider : IImageDecoderProvider { diff --git a/tests/Titano.Data.Tests/Archiving/ArchiveJobTests.cs b/tests/Titano.Data.Tests/Archiving/ArchiveJobTests.cs index 91b954e3..e9131f19 100644 --- a/tests/Titano.Data.Tests/Archiving/ArchiveJobTests.cs +++ b/tests/Titano.Data.Tests/Archiving/ArchiveJobTests.cs @@ -88,6 +88,60 @@ public sealed class ArchiveJobTests(TestContext context) Assert.Contains("3 made, 3 reused", done.LogTail); } + [Test] + public async Task AThumbnailPassFlagsFramesNothingDecodesAndClearsThemOnceTheyDecode() + { + await using var fx = await CreateAsync(context); + var files = Photos.WriteSeries(Path.Combine(fx.Paths.Root, "a"), Start, 6); + await fx.ScanAsync(); + var a = (await LocationsAsync(fx))[0]; + var sequence = (await fx.Db.Sequences.GetAsync(a.Id))!; + var paths = fx.Paths.Sequence(a.Folder); + var original = await File.ReadAllBytesAsync(files[2], fx.Ct); + await File.WriteAllBytesAsync(files[2], new byte[original.Length], fx.Ct); + + var result = await fx.Service.Images.BuildThumbnailsAsync(fx.Archive, sequence, false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); + + Assert.Equal((5, 1), (result.Built, result.Undecodable)); + var frame = ManifestStore.ReadSequence(paths.ManifestPath).Frames[2]; + Assert.Equal((Titano.Core.Imaging.DecodeTier.Unavailable, FrameFlags.Undecodable), (frame.Tier, frame.Flags)); + Assert.Equal(FrameFlags.Undecodable, (await fx.Db.Frames.ListBySequenceAsync(a.Id))[2].Flags); + Assert.True((await fx.Db.Sequences.GetAsync(a.Id))!.Status.HasFlag(SequenceStatus.HasWarnings), "the sequence warns at once"); + + // Restored from a copy: the next pass decodes the frame and clears the flag; the others are reused. + await File.WriteAllBytesAsync(files[2], original, fx.Ct); + result = await fx.Service.Images.BuildThumbnailsAsync(fx.Archive, sequence, false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); + Assert.Equal((1, 5, 0), (result.Built, result.Reused, result.Undecodable)); + frame = ManifestStore.ReadSequence(paths.ManifestPath).Frames[2]; + Assert.Equal((Titano.Core.Imaging.DecodeTier.Native, FrameFlags.None), (frame.Tier, frame.Flags)); + Assert.Equal(FrameFlags.None, (await fx.Db.Frames.ListBySequenceAsync(a.Id))[2].Flags); + } + + [Test] + public async Task AHostWithoutADecoderForTheFormatRecordsTheTierWithoutFlaggingTheFrames() + { + // The fixture's decoder chain is empty: only JPEG decodes here (its decoder is built in), PNG does not. + await using var fx = await CreateAsync(context); + var folder = Path.Combine(fx.Paths.Root, "p"); + Directory.CreateDirectory(folder); + using (var image = new Titano.Core.Imaging.ImageBuffer(32, 24)) + { + for (var i = 0; i < 3; i++) File.WriteAllBytes(Path.Combine(folder, $"P{i}.png"), Titano.Core.Codecs.Png.PngEncoder.Encode(image)); + } + await fx.ScanAsync(); + var p = (await LocationsAsync(fx)).Single(); + + var result = await fx.Service.Images.BuildThumbnailsAsync(fx.Archive, (await fx.Db.Sequences.GetAsync(p.Id))!, false, 0, + (_, _) => ValueTask.CompletedTask, fx.Ct); + + // Another host (or a proxy) may still provide the pixels: the tier is recorded, the frames stay renderable. + Assert.Equal(3, result.Undecodable); + var frames = ManifestStore.ReadSequence(fx.Paths.Sequence(p.Folder).ManifestPath).Frames; + Assert.True(frames.All(f => f.Tier == Titano.Core.Imaging.DecodeTier.Unavailable && f.Flags == FrameFlags.None), "tier without flag"); + Assert.True((await fx.Db.Frames.ListBySequenceAsync(p.Id)).All(f => f.Flags == FrameFlags.None), "index flags"); + Assert.False((await fx.Db.Sequences.GetAsync(p.Id))!.Status.HasFlag(SequenceStatus.HasWarnings), "no warning"); + } + [Test] public async Task AMaintenanceJobResumesAfterItsDoneSteps() { diff --git a/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs b/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs index 8fb31ae9..c49fce15 100644 --- a/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs +++ b/tests/Titano.Data.Tests/Processing/AnalysisJobTests.cs @@ -1,6 +1,9 @@ +using Titano.Core.Advice; +using Titano.Core.Analysis; using Titano.Core.Analysis.Deep; using Titano.Core.Archiving; using Titano.Core.Diagnostics.Synthetic; +using Titano.Core.Imaging; using Titano.Core.Localization; using Titano.Core.Model; using Titano.Core.Project; @@ -62,6 +65,75 @@ public sealed class AnalysisJobTests(TestContext context) Assert.Equal(version, (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.SettingsVersion); } + [Test] + public async Task LightAnalysisRecordsFormatTiersAndTheAdvisorCapsTheOutputAtThePreviews() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Flickering(12)); + // This host reads the first ten files only through 48×32 embedded previews and cannot decode the last one. + for (var i = 0; i < 10; i++) + fx.Decoder.Tiers[ProcessingFixture.FileName(i)] = new FileTier(ImageFileFormat.Jpeg, DecodeTier.EmbeddedPreview, "test-preview", "test", 48, 32); + fx.Decoder.Tiers[ProcessingFixture.FileName(11)] = new FileTier(ImageFileFormat.Jpeg, DecodeTier.Unavailable, null, "test", 0, 0); + await fx.StartEngineAsync(); + + var job = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + await fx.WaitForAsync(job.Id, JobState.Done); + + var folder = fx.Folder(sequence); + var sidecar = ManifestStore.ReadSequence(folder.ManifestPath).Frames; + Assert.Equal((DecodeTier.EmbeddedPreview, FrameFlags.PreviewOnly, (int?)48, (int?)32), (sidecar[0].Tier, sidecar[0].Flags, sidecar[0].PreviewW, sidecar[0].PreviewH)); + Assert.Equal((DecodeTier.Native, FrameFlags.None), (sidecar[10].Tier, sidecar[10].Flags)); + Assert.Equal((DecodeTier.Unavailable, FrameFlags.Undecodable), (sidecar[11].Tier, sidecar[11].Flags)); + var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); + Assert.Equal((FrameFlags.PreviewOnly, 48, 32), (rows[3].Flags, rows[3].PreviewWidth, rows[3].PreviewHeight)); + Assert.Equal(FrameFlags.Undecodable, rows[11].Flags); + var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; + Assert.Equal(10, row.PreviewOnlyCount); + Assert.GreaterOrEqual(row.WarningCount, 1); + Assert.True(row.Status.HasFlag(SequenceStatus.HasWarnings), "the undecodable frame is a sequence warning"); + + // The advisor reads the preview size from the index and caps the output there (BRIEF §8.2 tier 2). + var tiers = SequenceContext.FromFrames(rows); + Assert.Equal((10, 48, 32), (tiers.PreviewOnlyCount, tiers.PreviewWidth, tiers.PreviewHeight)); + var light = LightAnalyzer.Analyze(rows); + var advice = Advisor.Recommend(light, null, tiers); + Assert.Equal(AdvisorKeys.ResolutionPreview, advice.Find(AdvisorParameters.Resolution)!.ReasonKey); + Assert.Contains(advice.Findings, f => f.Key == FindingKeys.PreviewOnly && Equals(f.Arguments[0], 10)); + Assert.Contains(advice.Findings, f => f.Key == DeepFindingKeys.UnreadableFrames && f.Frames.SequenceEqual([11])); + + // Probed once: a second pass opens no file for its tier and leaves the sidecar alone. + fx.Decoder.Tiers.Clear(); + var written = File.GetLastWriteTimeUtc(folder.ManifestPath); + var again = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); + await fx.WaitForAsync(again.Id, JobState.Done); + Assert.Equal(FrameFlags.PreviewOnly, ManifestStore.ReadSequence(folder.ManifestPath).Frames[0].Flags); + Assert.Equal(written, File.GetLastWriteTimeUtc(folder.ManifestPath)); + } + + [Test] + public async Task DeepAnalysisFlagsFramesItCannotDecodeAndListsThemOnce() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Flickering(12)); + // Damaged after indexing: the header probe still says JPEG, only decoding finds out. + await File.WriteAllBytesAsync(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(4)), new byte[3000], fx.Ct); + await fx.StartEngineAsync(); + + var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + var done = await fx.WaitForAsync(job.Id, JobState.Done); + + var sidecar = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; + Assert.Equal((DecodeTier.Unavailable, FrameFlags.Undecodable), (sidecar[4].Tier, sidecar[4].Flags)); + Assert.Equal(DecodeTier.Native, sidecar[5].Tier); + Assert.Equal(FrameFlags.Undecodable, (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[4].Flags); + var report = SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!; + var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); + var findings = Advisor.Recommend(LightAnalyzer.Analyze(rows), report, SequenceContext.FromFrames(rows)).Findings; + Assert.Count(1, findings.Where(f => f.Key == DeepFindingKeys.UnreadableFrames)); + Assert.True((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.WarningCount >= 1, "listed in the sequence warnings"); + Assert.Equal(JobState.Done, done.State); + } + [Test] public async Task DeepAnalysisResumesAfterCancellationWithTheSameReport() { diff --git a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs index d5b9ad90..8853d362 100644 --- a/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs +++ b/tests/Titano.Data.Tests/Processing/ProcessingFixture.cs @@ -123,8 +123,15 @@ 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). + public ConcurrentDictionary Tiers { 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 DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { Requests.Enqueue(request); diff --git a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs index 656032ef..c22757f4 100644 --- a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs +++ b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs @@ -86,18 +86,48 @@ public sealed class RenderJobTests(TestContext context) { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Scene()); - // Damaged after indexing: nothing flags the frame, so only decoding finds out. - await File.WriteAllBytesAsync(Path.Combine(fx.Archive.Paths.Root, "Synthetic", ProcessingFixture.FileName(10)), new byte[5000], fx.Ct); + // Every file damaged after indexing: nothing flags them, and no frame can stand in for another. + for (var i = 0; i < Frames; i++) + await File.WriteAllBytesAsync(Path.Combine(fx.Archive.Paths.Root, "Synthetic", ProcessingFixture.FileName(i)), new byte[5000], fx.Ct); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); var failed = await fx.WaitForAsync(job.Id, JobState.Failed); - Assert.Equal(Loc.L(SequenceFrameSource.FrameUnreadableKey, "11", ProcessingFixture.FileName(10)), failed.Error); + Assert.Equal(Loc.L(SequenceFrameSource.FrameUnreadableKey, "1", ProcessingFixture.FileName(0)), failed.Error); Assert.Empty(Entries(fx.Folder(sequence).Exports)); Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } + [Test] + public async Task AFrameThatNoLongerDecodesIsReplacedByItsNeighbourAndLeftOutNextTime() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + // Damaged after indexing: nothing flags the frame, so only decoding finds out (BRIEF §8.2 tier 3). + await File.WriteAllBytesAsync(Path.Combine(fx.Archive.Paths.Root, "Synthetic", ProcessingFixture.FileName(10)), new byte[5000], fx.Ct); + 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); + Assert.SequenceEqual(["clip-MJPEG.avi"], Entries(fx.Folder(sequence).Exports)); + var row = (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[10]; + Assert.Equal(FrameFlags.Undecodable, row.Flags); + var sidecar = Titano.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath); + Assert.Equal((DecodeTier.Unavailable, FrameFlags.Undecodable), (sidecar.Frames[10].Tier, sidecar.Frames[10].Flags)); + Assert.Equal(DecodeTier.Native, sidecar.Frames[9].Tier); + Assert.True(sidecar.Status.HasFlag(SequenceStatus.HasWarnings), "the sequence warns at once"); + Assert.True((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.HasWarnings), "index status"); + + // The next render plans without the frame, so nothing has to stand in for it. + var again = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); + var second = await fx.WaitForAsync(again.Id, JobState.Done); + Assert.False(second.LogTail?.Contains(Loc.L("Export.Log.StandIns", "11"), StringComparison.Ordinal) == true, "no stand-in"); + Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); + } + [Test] public async Task ARenderInterruptedByACrashStartsItsOutputAgainCleanly() { diff --git a/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs b/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs index 968fbcd7..0c09f672 100644 --- a/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs +++ b/tests/Titano.Data.Tests/Repositories/CatalogRepositoryTests.cs @@ -51,6 +51,7 @@ public abstract class CatalogRepositoryTests(TestContext context) : RepositoryTe FramesVersion = 7, OwnerUserId = Guid.CreateVersion7(), WarningCount = 2, + PreviewOnlyCount = 1150, Tags = ["Sunset", "harbour", "SUNSET"], }; await db.Sequences.UpsertAsync(sequence, Ct); @@ -248,6 +249,8 @@ public abstract class CatalogRepositoryTests(TestContext context) : RepositoryTe Orientation = 6, PreviewOffset = 1024, PreviewLength = 65536, + PreviewWidth = 1620, + PreviewHeight = 1080, MeanLogLuminance = -2.5, ClipLow = 0.01, ClipHigh = 0.02, @@ -307,6 +310,27 @@ public abstract class CatalogRepositoryTests(TestContext context) : RepositoryTe Assert.Equal(1200, await db.Frames.DeleteBySequenceAsync(sequence.Id, Ct)); } + [Test] + public async Task FrameTiersUpdateInBulkAndSurviveASyncFromTheSidecar() + { + var db = await OpenTitanoAsync(); + var archive = TestData.Archive(); + 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(); + 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.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))); + } + [Test] public async Task RendersKeepTheSequenceCountInStep() {