diff --git a/i18n/en/Archive.resx b/i18n/en/Archive.resx
index 5c11be26..5486ffbe 100644
--- a/i18n/en/Archive.resx
+++ b/i18n/en/Archive.resx
@@ -132,6 +132,7 @@
Not copied: {0} ({1})long: job log line
{0} stale locks, {1} temporary files, {2} packs compacted, {3} duplicate flags changedlong: job log line
{0} unindexed photos, {1} missing photoslong: job log line
+ Proxies for the server: {0} sent, {1} not sentlong: job log line; {0} proxies sent; {1} proxies this PC could not make or the server refused
{0} folders, {1} indexed, {2} adopted, {3} removedlong: job log line
Sequence not found: {0}long: job log line
{0} photos checked, {1} intact, {2} hashed, {3} with problemslong: job log line
diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx
index 543c7626..2f5002b7 100644
--- a/i18n/en/Server.resx
+++ b/i18n/en/Server.resx
@@ -54,6 +54,7 @@
This job kind cannot be started here.long
The job parameters are not valid.long
The priority must be background, normal or user.long
+ The proxy is not a JPEG the server can read.long
The role must be admin, editor, uploader or viewer.long
The setting {0} is not valid.long
The settings must be valid JSON.long
@@ -67,6 +68,8 @@
Not found.long
That address is not a Titano Server.long
Change your password first.long
+ This archive makes no proxies.long
+ The proxy was made from another photo.long
This upload would exceed your quota.long
Too many attempts; wait a minute and try again.long
Choose a password different from the current one.long
diff --git a/i18n/it/Archive.it.resx b/i18n/it/Archive.it.resx
index 06606110..27a8eca6 100644
--- a/i18n/it/Archive.it.resx
+++ b/i18n/it/Archive.it.resx
@@ -127,6 +127,7 @@
Non copiata: {0} ({1})
{0} blocchi scaduti, {1} file temporanei, {2} pacchetti compattati, {3} segni di duplicato cambiati
{0} foto non indicizzate, {1} foto mancanti
+ Proxy per il server: {0} inviati, {1} non inviati
{0} cartelle, {1} indicizzate, {2} adottate, {3} rimosse
Sequenza non trovata: {0}
{0} foto controllate, {1} integre, {2} con impronta nuova, {3} con problemi
diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx
index 8baccf97..4ed52416 100644
--- a/i18n/it/Server.it.resx
+++ b/i18n/it/Server.it.resx
@@ -52,6 +52,7 @@
Questo tipo di job non si può avviare qui.
I parametri del job non sono validi.
La priorità deve essere background, normal o user.
+ Il proxy non è un JPEG che il server sa leggere.
Il ruolo deve essere admin, editor, uploader o viewer.
L'impostazione {0} non è valida.
Le impostazioni devono essere JSON valido.
@@ -65,6 +66,8 @@
Non trovato.
Questo indirizzo non è un Titano Server.
Cambia prima la password.
+ Questo archivio non crea proxy.
+ Il proxy è stato creato da un'altra foto.
Questo caricamento supererebbe la tua quota.
Troppi tentativi; attendi un minuto e riprova.
Scegli una password diversa da quella attuale.
diff --git a/src/Titano.Data/Archiving/ArchiveImages.cs b/src/Titano.Data/Archiving/ArchiveImages.cs
index e8ae63be..f7fb6dc4 100644
--- a/src/Titano.Data/Archiving/ArchiveImages.cs
+++ b/src/Titano.Data/Archiving/ArchiveImages.cs
@@ -1,5 +1,7 @@
using System.Diagnostics;
using Titano.Core.Archiving;
+using Titano.Core.Codecs.Jpeg;
+using Titano.Core.Imaging;
using Titano.Core.IO;
using Titano.Core.Metadata;
using Titano.Core.Model;
@@ -9,14 +11,35 @@ namespace Titano.Data.Archiving;
/// Frames processed by one thumbnail or proxy pass over a sequence.
public sealed record ImagePassResult(int Built, int Reused, int Undecodable);
+/// What became of a proxy sent by a client or render node ().
+public enum ProxyStoreResult
+{
+ Stored,
+
+ /// The archive's proxy policy makes no proxies.
+ Disabled,
+
+ /// Not a JPEG that decodes, or larger than .
+ Invalid,
+
+ /// Its Exif capture time is not the frame's: it was made from another photo.
+ WrongFrame,
+}
+
///
/// 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 whose original this host cannot
+/// decode () gets its proxy from a client or render node that can
+/// (, BRIEF §2.3) and its thumbnail from that proxy.
///
public sealed class ArchiveImages
{
+ /// Largest proxy a client or render node may send: a full-size proxy of a large sensor at q92 fits.
+ public const long MaxProxyBytes = 64L << 20;
+
private const int CommitFrames = 200;
+ private const int ProbeLongEdge = 64;
private static readonly TimeSpan CommitInterval = TimeSpan.FromSeconds(10);
private readonly TitanoDatabase _db;
@@ -32,6 +55,81 @@ public sealed class ArchiveImages
_renderer = new FrameImageRenderer(writer.Options.Decoder);
}
+ ///
+ /// Whether a host with takes the pixels of a original from its
+ /// proxy: no decoder reads the format, or only previews of a HEIF, which embeds thumbnails at best (BRIEF §2.3,
+ /// §8.1: the server keeps HEIF originals and relies on proxies made by a Windows client or render node). Never for a
+ /// JPEG (proxies are JPEGs: a host that reads them reads it) or a file no format was recognised in.
+ ///
+ public static bool NeedsProxy(ImageDecoder decoder, ImageFileFormat format)
+ {
+ ArgumentNullException.ThrowIfNull(decoder);
+ if (format is ImageFileFormat.Unknown or ImageFileFormat.Jpeg) return false;
+ var tier = decoder.TierFor(format);
+ return tier == DecodeTier.Unavailable || (tier != DecodeTier.Native && ImageFormatInfo.Of(format).Family == ImageFamily.Heif);
+ }
+
+ /// with this archive engine's decoders.
+ public bool NeedsProxy(ImageFileFormat format) => NeedsProxy(_writer.Options.Decoder, format);
+
+ ///
+ /// A proxy of the original at for a server that cannot decode it ():
+ /// at (0 = full size) and , with 's capture
+ /// data (the server's record, which it checks) and in its Exif. Null when
+ /// cannot decode the original either.
+ ///
+ /// The original cannot be read.
+ public static byte[]? MakeProxy(ImageDecoder decoder, string path, Frame frame, SidecarCamera? camera, int longEdge, int quality,
+ CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(frame);
+ if (NeedsProxy(decoder, frame.Format)) return null;
+ // The original's folder stands in for a sequence folder: the renderer reads frames relative to one.
+ var folder = new ArchivePaths(Path.GetDirectoryName(Path.GetFullPath(path))!).Sequence(string.Empty);
+ var source = new SidecarFrame
+ {
+ Id = frame.Id,
+ I = frame.Index,
+ File = Path.GetFileName(path),
+ Size = frame.Size,
+ CapturedAt = frame.CapturedAt,
+ UtcOffset = frame.UtcOffsetMinutes,
+ Exposure = frame.ExposureTime,
+ FNumber = frame.FNumber,
+ Iso = frame.Iso,
+ Focal = frame.FocalLength,
+ Bias = frame.ExposureBias,
+ Orientation = frame.Orientation,
+ Format = frame.Format,
+ };
+ var policy = new ProxyPolicy { LongEdge = longEdge, Quality = quality };
+ return new FrameImageRenderer(decoder).Proxy(folder, source, camera, policy, cancellationToken)?.Jpeg;
+ }
+
+ ///
+ /// Files a proxy made elsewhere (a client or render node whose decoders read the original) as the frame's proxy,
+ /// replacing the one there: a JPEG of at most that decodes, whose Exif capture time is the
+ /// frame's (proxies carry it, so the proxy counts as current and cannot belong to another photo), written atomically.
+ ///
+ /// The archive is offline or read-only.
+ public ProxyStoreResult StoreProxy(Archive archive, Sequence sequence, Frame frame, byte[] jpeg)
+ {
+ ArgumentNullException.ThrowIfNull(jpeg);
+ var paths = new ArchivePaths(archive.RootPath);
+ ArchiveVolume.EnsureWritable(paths);
+ if (ManifestStore.ReadArchive(paths.ManifestPath).ProxyPolicy.LongEdge == ProxyPolicy.Disabled) return ProxyStoreResult.Disabled;
+ if (jpeg.Length is 0 or > (int)MaxProxyBytes || !Decodes(jpeg)) return ProxyStoreResult.Invalid;
+ if (frame.CapturedAt is { } captured)
+ {
+ using var stream = new MemoryStream(jpeg, writable: false);
+ if (MetadataReader.Read(stream, "proxy.jpg").CapturedAt != captured) return ProxyStoreResult.WrongFrame;
+ }
+ var folder = paths.Sequence(sequence.Folder);
+ Directory.CreateDirectory(folder.Proxies);
+ AtomicFile.WriteAllBytes(folder.Proxy(frame.Index), jpeg);
+ return ProxyStoreResult.Stored;
+ }
+
/// Resume point inside the sequence (frames before it were done by an earlier run).
/// Called with the next frame index whenever the pack has been committed.
public async Task BuildThumbnailsAsync(Archive archive, Sequence sequence, bool force, int startFrame,
@@ -53,12 +151,22 @@ public sealed class ArchiveImages
cancellationToken.ThrowIfCancellationRequested();
var frame = manifest.Frames[i];
var fingerprint = ThumbPack.Fingerprint(frame.Sha256, frame.File, frame.Size);
- if (!force && pack.Entries.TryGetValue(frame.I, out var entry) && entry.SourceHash.AsSpan().SequenceEqual(fingerprint))
+ var entry = pack.Entries.GetValueOrDefault(frame.I);
+ var edge = entry is null ? 0 : System.Math.Max(entry.Width, entry.Height);
+ var current = !force && entry is not null && entry.SourceHash.AsSpan().SequenceEqual(fingerprint);
+ // A frame this host cannot decode shows its proxy once one arrived; until then its original's embedded
+ // preview, whose smaller thumbnail the proxy's replaces.
+ var fromProxy = false;
+ if (NeedsProxy(frame.Format) && !(current && edge >= FrameImageRenderer.ThumbnailLongEdge)
+ && ReadProxy(folder.Proxy(frame.I), frame) is { Check: ProxyCheck.Current or ProxyCheck.Unverifiable } proxy)
+ fromProxy = !current || edge < System.Math.Min(FrameImageRenderer.ThumbnailLongEdge, proxy.LongEdge);
+ if (current && !fromProxy)
{
reused++;
continue;
}
- if (Render(() => _renderer.Thumbnail(folder, frame, cancellationToken)) is { } image)
+ var source = fromProxy ? ProxySource(frame) : frame;
+ if (Render(() => _renderer.Thumbnail(folder, source, cancellationToken)) is { } image)
{
pack.Append(frame.I, image.Width, image.Height, fingerprint, image.Jpeg);
built++;
@@ -97,12 +205,27 @@ public sealed class ArchiveImages
cancellationToken.ThrowIfCancellationRequested();
var frame = manifest.Frames[i];
var path = folder.Proxy(frame.I);
- if (!force && IsCurrent(path, frame))
+ if (NeedsProxy(frame.Format))
+ {
+ // Only a client or render node that decodes the original makes this proxy: a preview would make one the
+ // size of a thumbnail here. One left from a frame renumbered since goes, so it is asked for again.
+ var check = ReadProxy(path, frame).Check;
+ if (check is ProxyCheck.Current or ProxyCheck.Unverifiable)
+ {
+ reused++;
+ }
+ else
+ {
+ if (check == ProxyCheck.Stale) File.Delete(path);
+ undecodable++;
+ }
+ }
+ else if (!force && ReadProxy(path, frame).Check == ProxyCheck.Current)
{
reused++;
continue;
}
- if (Render(() => _renderer.Proxy(folder, frame, manifest.Camera, policy, cancellationToken)) is { } image)
+ else if (Render(() => _renderer.Proxy(folder, frame, manifest.Camera, policy, cancellationToken)) is { } image)
{
AtomicFile.WriteAllBytes(path, image.Jpeg);
built++;
@@ -117,15 +240,59 @@ public sealed class ArchiveImages
return new ImagePassResult(built, reused, undecodable);
}
- /// A proxy is current when its Exif capture time is the frame's (frames renumbered since make it stale).
- private static bool IsCurrent(string proxy, SidecarFrame frame)
+ /// Where a frame's proxy stands; only a capture time tells whether it is the frame's.
+ private enum ProxyCheck
{
- if (!File.Exists(proxy)) return false;
+ Missing,
+
+ /// Its Exif capture time is the frame's.
+ Current,
+
+ /// The frame has no capture time to compare with.
+ Unverifiable,
+
+ /// Made from another frame (frames were renumbered since).
+ Stale,
+ }
+
+ /// Where the proxy at stands for , and its long edge.
+ private static (ProxyCheck Check, int LongEdge) ReadProxy(string proxy, SidecarFrame frame)
+ {
+ if (!File.Exists(proxy)) return (ProxyCheck.Missing, 0);
try
{
- return MetadataReader.Read(proxy).CapturedAt == frame.CapturedAt && frame.CapturedAt is not null;
+ var metadata = MetadataReader.Read(proxy);
+ var (width, height) = metadata.OrientedSize;
+ var check = frame.CapturedAt is null ? ProxyCheck.Unverifiable : metadata.CapturedAt == frame.CapturedAt ? ProxyCheck.Current : ProxyCheck.Stale;
+ return (check, System.Math.Max(width, height));
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ return (ProxyCheck.Missing, 0);
+ }
+ }
+
+ /// The frame's proxy as the frame to draw: a JPEG already oriented, under proxies/.
+ private static SidecarFrame ProxySource(SidecarFrame frame) => frame with
+ {
+ File = ArchiveLayout.ProxiesFolder + "/" + ArchiveLayout.ProxyFileName(frame.I),
+ Format = ImageFileFormat.Jpeg,
+ Orientation = 1,
+ PreviewOffset = null,
+ PreviewLength = null,
+ };
+
+ /// A colour or grey JPEG whose headers parse and whose scans decode (at a small DCT-scaled size).
+ private static bool Decodes(byte[] jpeg)
+ {
+ try
+ {
+ var info = JpegDecoder.ReadInfo(jpeg);
+ if (info.Process == JpegProcess.Lossless || info.Components is not (1 or 3) || info.Width < 1 || info.Height < 1) return false;
+ using var probe = JpegDecoder.DecodeToLinear(jpeg, new JpegDecodeOptions { MaxLongEdge = ProbeLongEdge });
+ return true;
+ }
+ catch (Exception ex) when (ex is InvalidDataException or NotSupportedException)
{
return false;
}
diff --git a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs
index 359361d5..8c1f1145 100644
--- a/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs
+++ b/src/Titano.Data/Processing/Jobs/RenderJobHandler.cs
@@ -62,7 +62,7 @@ internal sealed class RenderJobHandler(TitanoDatabase db, ProcessingOptions opti
var targets = all.Select((t, i) => (i, t)).Where(t => !done.Contains(t.i)).Select(t => (t.i, adapt(t.t))).ToList();
if (targets.Count == 0) return;
- var frames = await SequenceFrames.LoadAsync(db, archive, sequence, parameters.UseProxies, cancellation).ConfigureAwait(false);
+ var frames = await SequenceFrames.LoadAsync(db, archive, sequence, parameters.UseProxies, options.Archive.Decoder, cancellation).ConfigureAwait(false);
IReadOnlyList outcomes;
await using (var render = new SequenceRender(frames, project, SequenceAnalyser.ReadReport(folder, frames.Count), options))
{
diff --git a/src/Titano.Data/Processing/RenderNodeClient.cs b/src/Titano.Data/Processing/RenderNodeClient.cs
index c8938ad7..602548a4 100644
--- a/src/Titano.Data/Processing/RenderNodeClient.cs
+++ b/src/Titano.Data/Processing/RenderNodeClient.cs
@@ -1,6 +1,7 @@
using System.Diagnostics;
using System.Net;
using System.Text.Json;
+using Titano.Core.Archiving;
using Titano.Core.Diagnostics;
using Titano.Core.Export;
using Titano.Core.Imaging;
@@ -8,6 +9,7 @@ using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Render;
using Titano.Core.Video;
+using Titano.Data.Archiving;
using Titano.Protocol;
using Titano.Protocol.Client;
@@ -47,8 +49,10 @@ public sealed record RenderNodeOptions
///
/// "Offer this PC as render node" (BRIEF §14.7): registers this machine's single-file encoders with the server,
/// heart-beats, claims one render job at a time that it can encode, downloads the frames it needs (originals
-/// hash-verified into a content-addressed cache, or proxies when the job asks; a dropped download resumes), renders the
-/// job's preset with the host's encoders and uploads the output, which the server files as a render of the sequence.
+/// hash-verified into a content-addressed cache, or proxies when the job asks or this PC cannot decode the original; a
+/// dropped download resumes; frames missing, corrupt or excluded on the server are left out), renders the job's preset
+/// with the host's encoders and uploads the output, which the server files as a render of the sequence. Then it sends
+/// the proxies the server asks for, made from the originals it fetched (BRIEF §2.3: the server cannot decode HEIF).
/// Progress and render remarks go to the server; a job cancelled or reassigned there stops here; a failure is reported
/// with its reason. Stopping abandons the job in flight without reporting it: the server requeues it when the node
/// registers again or its heartbeats stop. Image sequences are not offered and batches are refused: the protocol uploads
@@ -58,6 +62,12 @@ public sealed class RenderNodeClient : IAsyncDisposable
{
private const string LogCategory = "render-node";
+ ///
+ /// Frames no node renders: absent on the server, not the archived file, or excluded. Undecodable is the server's
+ /// verdict on its own decoders, so this PC's decoders try those frames.
+ ///
+ internal const FrameFlags NotFetched = FrameFlags.Missing | FrameFlags.Corrupt | FrameFlags.Excluded;
+
private readonly TitanoClient _client;
private readonly ProcessingOptions _processing;
private readonly RenderNodeOptions _options;
@@ -127,7 +137,9 @@ public sealed class RenderNodeClient : IAsyncDisposable
try
{
Directory.CreateDirectory(work);
- await RenderAsync(claimed, work, reporter, job.Token).ConfigureAwait(false);
+ var input = await RenderAsync(claimed, work, reporter, job.Token).ConfigureAwait(false);
+ // The job is done on the server; the proxies it asked for follow, on the node's own time.
+ await SendProxiesAsync(claimed, input, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex) when (job.IsCancellationRequested)
{
@@ -221,7 +233,8 @@ public sealed class RenderNodeClient : IAsyncDisposable
}
}
- private async Task RenderAsync(ClaimedJob claimed, string work, NodeReporter reporter, CancellationToken cancellationToken)
+ /// Renders the job and uploads its output; returns the frames it read.
+ private async Task RenderAsync(ClaimedJob claimed, string work, NodeReporter reporter, CancellationToken cancellationToken)
{
var export = ProcessingJobs.ReadExport(claimed.PresetJson);
var resolved = ExportResolver.Resolve(export);
@@ -232,9 +245,14 @@ public sealed class RenderNodeClient : IAsyncDisposable
var project = ProjectStore.Parse(claimed.SettingsJson) with { Export = export };
var sequence = ToSequence(await _client.GetSequenceAsync(claimed.SequenceId, cancellationToken).ConfigureAwait(false));
- var frames = await ListFramesAsync(claimed.SequenceId, cancellationToken).ConfigureAwait(false);
- var files = await DownloadAsync(claimed, work, reporter, cancellationToken).ConfigureAwait(false);
- var input = new SequenceFrames(sequence, frames, [.. frames.Select(f => files.GetValueOrDefault(f.Id))]);
+ // This PC's decoders judge what they can read: the server's Undecodable does not keep a frame out of the render here.
+ var frames = (await ListFramesAsync(claimed.SequenceId, cancellationToken).ConfigureAwait(false))
+ .ConvertAll(f => f with { Flags = f.Flags & ~FrameFlags.Undecodable });
+ var files = await DownloadAsync(claimed, frames, work, reporter, cancellationToken).ConfigureAwait(false);
+ var input = new SequenceFrames(sequence, frames, [.. frames.Select(f => files.GetValueOrDefault(f.Id).Path)])
+ {
+ Proxied = [.. frames.Select(f => files.GetValueOrDefault(f.Id).Proxy)],
+ };
IReadOnlyList outcomes;
await using (var render = new SequenceRender(input, project, null, _processing))
@@ -253,6 +271,56 @@ public sealed class RenderNodeClient : IAsyncDisposable
cancellationToken).ConfigureAwait(false);
}
if (outcomes[0].Error is { } error) throw new InvalidOperationException(error);
+ return input;
+ }
+
+ ///
+ /// Sends the proxies the server asks for () that this PC can make from the
+ /// originals it fetched, as the server's proxy policy says; a failure is logged and never fails the finished job.
+ ///
+ private async Task SendProxiesAsync(ClaimedJob claimed, SequenceFrames input, CancellationToken cancellationToken)
+ {
+ if (claimed.Proxies is not { } spec) return;
+ var wanted = claimed.Frames.Where(f => f.WantsProxy).Select(f => f.Id).ToHashSet();
+ if (wanted.Count == 0) return;
+ var camera = new SidecarCamera { Make = input.Sequence.CameraMake, Model = input.Sequence.CameraModel };
+ int sent = 0, unsent = 0;
+ for (var i = 0; i < input.Count; i++)
+ {
+ var frame = input.Frames[i];
+ if (!wanted.Remove(frame.Id)) continue;
+ if (input.Proxied?[i] == true || input.Files[i] is not { } original)
+ {
+ unsent++;
+ continue;
+ }
+ try
+ {
+ var jpeg = await Task.Run(() => ArchiveImages.MakeProxy(_processing.Archive.Decoder, original, frame, camera, spec.LongEdge, spec.Quality,
+ cancellationToken), cancellationToken).ConfigureAwait(false);
+ if (jpeg is null)
+ {
+ unsent++;
+ continue;
+ }
+ await _client.UploadProxyAsync(frame.Id, jpeg, cancellationToken).ConfigureAwait(false);
+ sent++;
+ }
+ catch (TitanoApiException ex) when (ex.Status is HttpStatusCode.Conflict or HttpStatusCode.Forbidden)
+ {
+ // Proxies turned off on the server, or this account may no longer send them: none of the rest would go either.
+ Log.Warning(LogCategory, $"The server refused the proxies of job {claimed.Job.Id}", ex);
+ return;
+ }
+ catch (Exception ex) when (!cancellationToken.IsCancellationRequested)
+ {
+ // Best effort (a timed-out upload included): the job is done, and a proxy the server still lacks is asked for
+ // again with the next job.
+ Log.Warning(LogCategory, $"The proxy of {frame.FileName} could not be sent", ex);
+ unsent++;
+ }
+ }
+ Log.Info(LogCategory, $"Proxies of job {claimed.Job.Id}: {sent} sent, {unsent + wanted.Count} not");
}
private async Task UploadAsync(Guid nodeId, Guid jobId, ExportTarget target, RenderResult result, CancellationToken cancellationToken)
@@ -280,27 +348,33 @@ public sealed class RenderNodeClient : IAsyncDisposable
}
///
- /// The files of the job's frames: originals verified against their SHA-256 into the content-addressed cache (reused
- /// across jobs, fetched once per content), or proxies into the job folder when the job asks for them and the server
- /// has them.
+ /// The files of the job's frames (none for frames missing, corrupt or excluded on the server): originals verified
+ /// against their SHA-256 into the content-addressed cache (reused across jobs, fetched once per content), originals the
+ /// server has not hashed yet into the job folder, or proxies into the job folder when the job asks for them or this PC
+ /// cannot decode the original, and the server has them.
///
- private async Task> DownloadAsync(ClaimedJob claimed, string work, NodeReporter reporter, CancellationToken cancellationToken)
+ private async Task> DownloadAsync(ClaimedJob claimed, IReadOnlyList rows, string work,
+ NodeReporter reporter, CancellationToken cancellationToken)
{
- var files = new Dictionary();
+ var formats = rows.ToDictionary(f => f.Id, f => f.Format);
+ bool Proxy(ManifestFrame f) =>
+ f.HasProxy && (claimed.UseProxies || (formats.TryGetValue(f.Id, out var format) && ArchiveImages.NeedsProxy(_processing.Archive.Decoder, format)));
+ var files = new Dictionary();
+ var fetched = claimed.Frames.Where(f => ((FrameFlags)f.Flags & NotFetched) == 0).ToList();
var done = 0;
- var total = claimed.Frames.Count;
+ var total = fetched.Count;
await reporter.ReportAsync(0, total, Loc.L("Export.Job.Downloading")).ConfigureAwait(false);
- var downloads = claimed.Frames.GroupBy(f => claimed.UseProxies && f.HasProxy ? f.Id.ToString("N") : f.Sha256.ToLowerInvariant()).ToList();
+ var downloads = fetched.GroupBy(f => Proxy(f) || f.Sha256.Length == 0 ? f.Id.ToString("N") : f.Sha256.ToLowerInvariant()).ToList();
await Parallel.ForEachAsync(downloads, new ParallelOptions { MaxDegreeOfParallelism = _options.Downloads, CancellationToken = cancellationToken },
async (frames, ct) =>
{
var frame = frames.First();
- var path = claimed.UseProxies && frame.HasProxy
+ var file = Proxy(frame)
? await DownloadProxyAsync(frame, work, ct).ConfigureAwait(false)
- : await DownloadOriginalAsync(frame, ct).ConfigureAwait(false);
+ : (await DownloadOriginalAsync(frame, work, ct).ConfigureAwait(false), false);
lock (files)
{
- foreach (var f in frames) files[f.Id] = path;
+ foreach (var f in frames) files[f.Id] = file;
}
await reporter.ReportAsync(Interlocked.Add(ref done, frames.Count()), total, null).ConfigureAwait(false);
}).ConfigureAwait(false);
@@ -312,25 +386,29 @@ public sealed class RenderNodeClient : IAsyncDisposable
/// fetches it whole, since a proxy rebuilt meanwhile must not be resumed from the old one); the original when the server
/// has none for the frame.
///
- private async Task DownloadProxyAsync(ManifestFrame frame, string work, CancellationToken cancellationToken)
+ private async Task<(string Path, bool Proxy)> DownloadProxyAsync(ManifestFrame frame, string work, CancellationToken cancellationToken)
{
var path = Path.Combine(work, "proxies", frame.Id.ToString("N") + ".jpg");
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
try
{
await FetchAsync(frame, "proxy", path, resume: false, cancellationToken).ConfigureAwait(false);
- return path;
+ return (path, true);
}
catch (TitanoApiException ex) when (ex.Status == HttpStatusCode.NotFound)
{
File.Delete(path);
- return await DownloadOriginalAsync(frame, cancellationToken).ConfigureAwait(false);
+ return (await DownloadOriginalAsync(frame, work, cancellationToken).ConfigureAwait(false), false);
}
}
- /// A cached copy, or a download (resumed from a partial one) that must hash to the manifest's SHA-256.
- private async Task DownloadOriginalAsync(ManifestFrame frame, CancellationToken cancellationToken)
+ ///
+ /// A cached copy, or a download (resumed from a partial one) that must hash to the manifest's SHA-256; an original the
+ /// server has not hashed yet goes into the job folder and must have the manifest's size.
+ ///
+ private async Task DownloadOriginalAsync(ManifestFrame frame, string work, CancellationToken cancellationToken)
{
+ if (frame.Sha256.Length == 0) return await DownloadUnhashedAsync(frame, work, cancellationToken).ConfigureAwait(false);
var sha = frame.Sha256.ToLowerInvariant();
if (sha.Length != 64 || !sha.All(char.IsAsciiHexDigitLower)) throw new InvalidDataException(Loc.L("Errors.Render.Download", frame.FileName));
var path = Path.Combine(_options.CacheDirectory, "originals", sha[..2], sha + Path.GetExtension(frame.FileName).ToLowerInvariant());
@@ -355,6 +433,23 @@ public sealed class RenderNodeClient : IAsyncDisposable
}
}
+ ///
+ /// An original without a SHA-256 on the server (adopted, not verified yet): nothing to check it against but its size,
+ /// so it is neither cached nor shared with other frames; a copy of another size is fetched again once.
+ ///
+ private async Task DownloadUnhashedAsync(ManifestFrame frame, string work, CancellationToken cancellationToken)
+ {
+ var path = Path.Combine(work, "originals", frame.Id.ToString("N") + Path.GetExtension(frame.FileName).ToLowerInvariant());
+ Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+ for (var attempt = 1; ; attempt++)
+ {
+ if (!File.Exists(path) || new FileInfo(path).Length < frame.Size) await FetchAsync(frame, "original", path, resume: true, cancellationToken).ConfigureAwait(false);
+ if (new FileInfo(path).Length == frame.Size) return path;
+ File.Delete(path);
+ if (attempt == 2) throw new InvalidDataException(Loc.L("Errors.Render.Download", frame.FileName));
+ }
+ }
+
///
/// Fetches a frame resource into . A dropped connection or a busy server is retried (up to
/// times, the wait doubling from );
diff --git a/src/Titano.Data/Processing/SequenceAnalyser.cs b/src/Titano.Data/Processing/SequenceAnalyser.cs
index c99cd8c7..cfd48a58 100644
--- a/src/Titano.Data/Processing/SequenceAnalyser.cs
+++ b/src/Titano.Data/Processing/SequenceAnalyser.cs
@@ -36,7 +36,7 @@ internal sealed class SequenceAnalyser(TitanoDatabase db, ProcessingOptions opti
var paths = new ArchivePaths(archive.RootPath);
ArchiveVolume.EnsureWritable(paths);
var folder = paths.Sequence(sequence.Folder);
- var frames = await SequenceFrames.LoadAsync(db, archive, sequence, useProxies: false, cancellationToken).ConfigureAwait(false);
+ var frames = await SequenceFrames.LoadAsync(db, archive, sequence, useProxies: false, options.Archive.Decoder, cancellationToken).ConfigureAwait(false);
var metadata = frames.LightFrames();
var light = LightAnalyzer.Analyze(metadata);
diff --git a/src/Titano.Data/Processing/SequenceFrames.cs b/src/Titano.Data/Processing/SequenceFrames.cs
index 6d9f7cc0..98ea6134 100644
--- a/src/Titano.Data/Processing/SequenceFrames.cs
+++ b/src/Titano.Data/Processing/SequenceFrames.cs
@@ -1,8 +1,10 @@
using Titano.Core.Analysis;
using Titano.Core.Archiving;
using Titano.Core.Diagnostics;
+using Titano.Core.Imaging;
using Titano.Core.Metadata;
using Titano.Core.Model;
+using Titano.Data.Archiving;
namespace Titano.Data.Processing;
@@ -20,22 +22,39 @@ internal sealed record SequenceFrames(Sequence Sequence, IReadOnlyList Fr
public int Count => Frames.Count;
- /// Every frame row of with its archive file (the proxy when asked and built).
- public static async Task LoadAsync(TitanoDatabase db, Archive archive, Sequence sequence, bool useProxies,
+ ///
+ /// Per frame, whether its file is its proxy. is this host's verdict on the
+ /// original, so it does not keep a frame read from its proxy out of a render. Null: none is.
+ ///
+ public IReadOnlyList? Proxied { get; init; }
+
+ /// The originals, for metadata (proxies carry no GPS); null when are the originals.
+ public IReadOnlyList? Originals { get; init; }
+
+ ///
+ /// Every frame row of with its archive file: the proxy when asked, and whenever the
+ /// original is one cannot decode (:
+ /// HEIF on the server, BRIEF §2.3, §8.5), as long as the proxy exists; else the original.
+ ///
+ public static async Task LoadAsync(TitanoDatabase db, Archive archive, Sequence sequence, bool useProxies, ImageDecoder decoder,
CancellationToken cancellationToken)
{
var frames = await ListAsync(db, sequence.Id, cancellationToken).ConfigureAwait(false);
var paths = new ArchivePaths(archive.RootPath);
var folder = paths.Sequence(sequence.Folder);
var files = new string?[frames.Count];
+ var originals = new string?[frames.Count];
+ var proxied = new bool[frames.Count];
for (var i = 0; i < files.Length; i++)
{
var frame = frames[i];
if ((frame.Flags & FrameFlags.Missing) != 0) continue;
- var proxy = useProxies ? folder.Proxy(frame.Index) : null;
- files[i] = proxy is not null && File.Exists(proxy) ? proxy : paths.FromRelative(frame.RelativePath);
+ originals[i] = paths.FromRelative(frame.RelativePath);
+ var proxy = useProxies || ArchiveImages.NeedsProxy(decoder, frame.Format) ? folder.Proxy(frame.Index) : null;
+ proxied[i] = proxy is not null && File.Exists(proxy);
+ files[i] = proxied[i] ? proxy : originals[i];
}
- return new SequenceFrames(sequence, frames, files);
+ return new SequenceFrames(sequence, frames, files) { Proxied = proxied, Originals = originals };
}
public static async Task> ListAsync(TitanoDatabase db, Guid sequenceId, CancellationToken cancellationToken)
@@ -80,15 +99,17 @@ internal sealed record SequenceFrames(Sequence Sequence, IReadOnlyList Fr
{
for (var i = 0; i < Frames.Count; i++)
{
- if (Files[i] is null || (Frames[i].Flags & NotRendered) != 0) yield return i;
+ var skip = Proxied is { } proxied && proxied[i] ? NotRendered & ~FrameFlags.Undecodable : NotRendered;
+ if (Files[i] is null || (Frames[i].Flags & skip) != 0) yield return i;
}
}
private (int Index, GpsPosition Gps)? FirstGpsFix()
{
- for (var i = 0; i < Files.Count; i++)
+ var files = Originals ?? Files;
+ for (var i = 0; i < files.Count; i++)
{
- if (Files[i] is not { } file || (Frames[i].Flags & NotAnalysed) != 0) continue;
+ if (files[i] is not { } file || (Frames[i].Flags & NotAnalysed) != 0) continue;
try
{
return MetadataReader.Read(file).Gps is { } gps ? (i, gps) : null;
diff --git a/src/Titano.Data/Sync/SyncModel.cs b/src/Titano.Data/Sync/SyncModel.cs
index ca465d6c..eb842ff5 100644
--- a/src/Titano.Data/Sync/SyncModel.cs
+++ b/src/Titano.Data/Sync/SyncModel.cs
@@ -91,7 +91,10 @@ public sealed record SyncLink
public int? DiffLocalRenders { get; init; }
public int? DiffRemoteRenders { get; init; }
- /// Local originals the server does not have.
+ ///
+ /// Local originals the server does not have, and proxies it asks for that this PC can make (it cannot decode those
+ /// originals): an upload sends both.
+ ///
public int MissingRemote { get; init; }
/// Server originals this PC does not have.
diff --git a/src/Titano.Data/Sync/SyncRemote.cs b/src/Titano.Data/Sync/SyncRemote.cs
index 76268b4f..08537a27 100644
--- a/src/Titano.Data/Sync/SyncRemote.cs
+++ b/src/Titano.Data/Sync/SyncRemote.cs
@@ -42,6 +42,13 @@ public interface ISyncRemote : IDisposable
/// Streams a frame's original, proxy or thumb, resuming with Range from the destination's length.
Task DownloadFrameAsync(Guid frameId, string kind, Stream destination, CancellationToken cancellationToken);
+ ///
+ /// Sends the proxy of a frame the server cannot decode (); a 422
+ /// means it was refused (not a JPEG of that frame), 409 that the server makes no
+ /// proxies. A remote without the call (the screenshots' sample server) throws .
+ ///
+ Task UploadProxyAsync(Guid frameId, byte[] jpeg, CancellationToken cancellationToken) => throw new NotSupportedException();
+
/// Streams a render's file, resuming with Range from the destination's length; returns the file name the server gives it.
Task DownloadRenderAsync(Guid renderId, Stream destination, CancellationToken cancellationToken);
@@ -116,6 +123,8 @@ public sealed class TitanoSyncRemote(TitanoClient client, bool ownsClient) : ISy
public Task DownloadFrameAsync(Guid frameId, string kind, Stream destination, CancellationToken cancellationToken) =>
client.DownloadFrameAsync(frameId, kind, destination, null, cancellationToken);
+ public Task UploadProxyAsync(Guid frameId, byte[] jpeg, CancellationToken cancellationToken) => client.UploadProxyAsync(frameId, jpeg, cancellationToken);
+
public Task DownloadRenderAsync(Guid renderId, Stream destination, CancellationToken cancellationToken) =>
client.DownloadRenderAsync(renderId, destination, cancellationToken);
diff --git a/src/Titano.Data/Sync/SyncRules.cs b/src/Titano.Data/Sync/SyncRules.cs
index a8aa0e12..ccda9f46 100644
--- a/src/Titano.Data/Sync/SyncRules.cs
+++ b/src/Titano.Data/Sync/SyncRules.cs
@@ -2,8 +2,10 @@ using System.Globalization;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
+using Titano.Core.Imaging;
using Titano.Core.Model;
using Titano.Core.Project;
+using Titano.Data.Archiving;
using Titano.Protocol;
namespace Titano.Data.Sync;
@@ -130,6 +132,18 @@ public static class SyncRules
return (hashed.Count - matched + Math.Max(0, unhashed - unmatchedRemote), Math.Max(0, unmatchedRemote - unhashed));
}
+ ///
+ /// Frames whose proxy the server asks for (it cannot decode their originals, BRIEF §2.3) that this PC holds and its
+ /// reads: an upload makes and sends them.
+ ///
+ public static int ProxiesToSend(SequenceManifest manifest, IReadOnlyCollection local, ImageDecoder decoder)
+ {
+ ArgumentNullException.ThrowIfNull(manifest);
+ var readable = local.Where(f => !string.IsNullOrEmpty(f.Sha256) && !ArchiveImages.NeedsProxy(decoder, f.Format))
+ .Select(f => f.Sha256!.ToLowerInvariant()).ToHashSet(StringComparer.Ordinal);
+ return manifest.Frames.Count(f => f.WantsProxy && readable.Contains(f.Sha256.ToLowerInvariant()));
+ }
+
internal static string Blank(string? text) => text?.Trim() ?? string.Empty;
private static JsonNode? Parse(string json)
diff --git a/src/Titano.Data/Sync/SyncService.cs b/src/Titano.Data/Sync/SyncService.cs
index 7f8763e3..a1e655f7 100644
--- a/src/Titano.Data/Sync/SyncService.cs
+++ b/src/Titano.Data/Sync/SyncService.cs
@@ -43,8 +43,9 @@ public sealed record SyncOptions
/// conflict the user settles with , against the versions the user was shown. Uploads and
/// downloads run as jobs (): uploads use the chunked, hash-verified, resumable protocol;
/// downloaded originals are verified and committed through the archive ingest, so sidecars stay right; proxies go to a
-/// cache and open as a ; renders travel on request. Proxies and thumbnails never travel
-/// upward. A local copy and a server sequence holding the same originals are linked by content when no link joins
+/// cache and open as a ; renders travel on request. Thumbnails never travel upward, and
+/// proxies only for originals the server cannot decode (BRIEF §2.3: HEIF), made here and counted with the originals the
+/// server lacks. A local copy and a server sequence holding the same originals are linked by content when no link joins
/// them. The state of each local sequence is written to its sync_state for the Library. A failure while
/// comparing one sequence is recorded on its link and does not stop the others.
///
@@ -494,8 +495,10 @@ public sealed class SyncService
manifest = await remote.GetManifestAsync(link.RemoteId, cancellationToken).ConfigureAwait(false);
var frames = await SequenceFrames.ListAsync(_db, local.Id, cancellationToken).ConfigureAwait(false);
// A frame flagged missing here counts as absent: downloading the originals restores it from the server.
- var (missingRemote, missingLocal) = SyncRules.CompareOriginals(
- [.. frames.Where(f => (f.Flags & FrameFlags.Missing) == 0).Select(f => f.Sha256)], [.. manifest.Frames.Select(f => f.Sha256)]);
+ var present = frames.Where(f => (f.Flags & FrameFlags.Missing) == 0).ToList();
+ var (missingRemote, missingLocal) = SyncRules.CompareOriginals([.. present.Select(f => f.Sha256)], [.. manifest.Frames.Select(f => f.Sha256)]);
+ // Proxies the server asks for that this PC can make from its originals travel with an upload too (BRIEF §2.3).
+ if (policy.CanEdit && manifest.Proxies is not null) missingRemote += SyncRules.ProxiesToSend(manifest, present, Options.Archive.Decoder);
link = await CompareExportsAsync(link, local, manifest.Renders, cancellationToken).ConfigureAwait(false) with
{
DiffLocalFrames = local.FramesVersion,
diff --git a/src/Titano.Data/Sync/SyncTransfers.cs b/src/Titano.Data/Sync/SyncTransfers.cs
index d4f2d7a7..95e42f10 100644
--- a/src/Titano.Data/Sync/SyncTransfers.cs
+++ b/src/Titano.Data/Sync/SyncTransfers.cs
@@ -16,7 +16,8 @@ namespace Titano.Data.Sync;
///
/// The work of upload and download jobs. Uploads send every local original the server lacks through the chunked,
/// resumable protocol after hashing it again (an original that no longer matches its archived hash is never sent),
-/// creating the server sequence first and sending its settings when the upload made it. Downloads fetch originals the
+/// creating the server sequence first and sending its settings when the upload made it, then the proxies the server asks
+/// for (originals it cannot decode, BRIEF §2.3), made here from this PC's originals. Downloads fetch originals the
/// local copy lacks into the archive's staging folder (resuming with Range), require the manifest's SHA-256 and commit
/// them through the archive ingest, which names them and writes the sidecar; the first original creates the local
/// sequence, which then takes the server's settings. Frames of the local copy not hashed yet are hashed first (so the
@@ -73,12 +74,90 @@ internal sealed class SyncTransfers(SyncService sync)
Interlocked.Increment(ref skipped);
await progress.StepAsync().ConfigureAwait(false);
}).ConfigureAwait(false);
+ await SendProxiesAsync(context, remote, target, local, paths, frames).ConfigureAwait(false);
if (created) await sync.PushAllAsync(remote, target, ct).ConfigureAwait(false);
await sync.RecompareAsync(remote, target, ct).ConfigureAwait(false);
if (skipped > 0) throw new InvalidDataException(Loc.Plural("Errors.Sync.Unreadable", skipped));
}
+ ///
+ /// The proxies the server asks for () that this PC's decoders can make from its
+ /// originals, made as the server's proxy policy says with the server's capture data, and sent. One the server refuses
+ /// is counted in the job log; a server that makes no proxies, or an account that may not send them, ends the pass; a
+ /// server busy or out of reach fails the job like an original would.
+ ///
+ private async Task SendProxiesAsync(JobContext context, ISyncRemote remote, Guid remoteId, Sequence local, ArchivePaths paths, IReadOnlyList frames)
+ {
+ var ct = context.Cancellation;
+ var manifest = await remote.GetManifestAsync(remoteId, ct).ConfigureAwait(false);
+ var wanted = manifest.Frames.Where(f => f.WantsProxy).ToList();
+ if (manifest.Proxies is not { } spec || wanted.Count == 0) return;
+ var originals = frames.Where(f => f.Sha256 is not null).GroupBy(f => f.Sha256!.ToLowerInvariant()).ToDictionary(g => g.Key, g => g.First(), StringComparer.Ordinal);
+ var records = (await remote.ListFramesAsync(remoteId, ct).ConfigureAwait(false)).ToDictionary(f => f.Id);
+ var camera = new SidecarCamera { Make = local.CameraMake, Model = local.CameraModel, Serial = local.CameraSerial };
+ var decoder = sync.Options.Archive.Decoder;
+ var progress = new TransferProgress(context, wanted.Count, 0);
+ await progress.ReportAsync().ConfigureAwait(false);
+ int sent = 0, unsent = 0;
+ using var refused = CancellationTokenSource.CreateLinkedTokenSource(ct);
+ try
+ {
+ await Parallel.ForEachAsync(wanted, Workers(sync.Options.Uploads, refused.Token), async (frame, token) =>
+ {
+ var jpeg = originals.TryGetValue(frame.Sha256.ToLowerInvariant(), out var original) && records.TryGetValue(frame.Id, out var record)
+ ? await Task.Run(() => MakeProxy(decoder, paths.FromRelative(original.RelativePath), RenderNodeClient.ToFrame(record), camera, spec, frame.FileName,
+ token), token).ConfigureAwait(false)
+ : null;
+ try
+ {
+ if (jpeg is not null)
+ {
+ await remote.UploadProxyAsync(frame.Id, jpeg, token).ConfigureAwait(false);
+ Interlocked.Increment(ref sent);
+ }
+ else
+ {
+ Interlocked.Increment(ref unsent);
+ }
+ }
+ catch (Exception ex) when (ex is NotSupportedException or TitanoApiException { Status: HttpStatusCode.Conflict or HttpStatusCode.Forbidden })
+ {
+ // The server takes no proxies (or none from this account): nothing more to send.
+ Core.Diagnostics.Log.Info("sync", $"Proxies of {local.DisplayTitle} not sent: {ex.Message}");
+ await refused.CancelAsync().ConfigureAwait(false);
+ }
+ catch (TitanoApiException ex) when (!ex.IsTransient)
+ {
+ // This proxy only (not a JPEG of that frame, a frame gone meanwhile): the others still go.
+ Core.Diagnostics.Log.Warning("sync", $"The proxy of {frame.FileName} was refused", ex);
+ Interlocked.Increment(ref unsent);
+ }
+ await progress.StepAsync().ConfigureAwait(false);
+ }).ConfigureAwait(false);
+ }
+ catch (OperationCanceledException) when (refused.IsCancellationRequested && !ct.IsCancellationRequested)
+ {
+ unsent = wanted.Count - sent;
+ }
+ context.Log(Loc.L("Archive.Log.ProxiesSent", sent, unsent));
+ }
+
+ /// A proxy made here for the server; null (logged) when this PC cannot decode or read the original either.
+ private static byte[]? MakeProxy(Core.Imaging.ImageDecoder decoder, string path, Frame frame, SidecarCamera camera, ProxySpec spec, string name,
+ CancellationToken cancellationToken)
+ {
+ try
+ {
+ return ArchiveImages.MakeProxy(decoder, path, frame, camera, spec.LongEdge, spec.Quality, cancellationToken);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or NotSupportedException)
+ {
+ Core.Diagnostics.Log.Warning("sync", $"No proxy of {name} could be made", ex);
+ return null;
+ }
+ }
+
public async Task DownloadOriginalsAsync(JobContext context, ISyncRemote remote, Guid remoteId, Guid? targetArchive)
{
var ct = context.Cancellation;
diff --git a/src/Titano.Protocol/Client/TitanoClient.cs b/src/Titano.Protocol/Client/TitanoClient.cs
index 704ab62a..2d8c3dfa 100644
--- a/src/Titano.Protocol/Client/TitanoClient.cs
+++ b/src/Titano.Protocol/Client/TitanoClient.cs
@@ -142,6 +142,25 @@ public sealed class TitanoClient : IDisposable
}
}
+ ///
+ /// Sends the proxy of a frame whose original the server cannot decode (): a JPEG
+ /// with the frame's capture time in its Exif, replacing the server's. A transient failure is retried.
+ ///
+ public Task UploadProxyAsync(Guid frameId, byte[] jpeg, CancellationToken ct = default)
+ {
+ ArgumentNullException.ThrowIfNull(jpeg);
+ return RetryAsync(async () =>
+ {
+ await Bandwidth.AcquireAsync(jpeg.Length, ct).ConfigureAwait(false);
+ using var content = new ByteArrayContent(jpeg);
+ content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
+ using var response = await SendRawAsync(new HttpRequestMessage(HttpMethod.Put, $"api/v1/frames/{frameId}/proxy") { Content = content }, ct)
+ .ConfigureAwait(false);
+ await EnsureSuccessAsync(response, ct).ConfigureAwait(false);
+ return true;
+ }, ct);
+ }
+
// ---------------- Uploads ----------------
///
diff --git a/src/Titano.Protocol/Jobs.cs b/src/Titano.Protocol/Jobs.cs
index 38ba16cf..398b4d73 100644
--- a/src/Titano.Protocol/Jobs.cs
+++ b/src/Titano.Protocol/Jobs.cs
@@ -37,7 +37,10 @@ public sealed record NodeEncoder(string Codec, string Name, bool Hardware, bool
public sealed record RenderNodeDto(Guid Id, string ClientName, string Username, IReadOnlyList Encoders, DateTimeOffset LastHeartbeat, string State);
/// POST /api/v1/nodes/{id}/claim: the job and everything needed to run it, or 204 when none matches.
-public sealed record ClaimedJob(JobDto Job, Guid SequenceId, string SettingsJson, string PresetJson, bool UseProxies, IReadOnlyList Frames);
+/// Every frame of the sequence; a node renders none flagged missing, corrupt or excluded.
+/// How to make the proxies the server asks for (); null when it makes none.
+public sealed record ClaimedJob(JobDto Job, Guid SequenceId, string SettingsJson, string PresetJson, bool UseProxies, IReadOnlyList Frames,
+ ProxySpec? Proxies = null);
/// POST /api/v1/nodes/{id}/jobs/{jobId}/progress.
public sealed record NodeProgress(long Done, long Total, double? ItemsPerSecond, string? LogLine);
diff --git a/src/Titano.Protocol/Sequences.cs b/src/Titano.Protocol/Sequences.cs
index 8ad09422..45a91f17 100644
--- a/src/Titano.Protocol/Sequences.cs
+++ b/src/Titano.Protocol/Sequences.cs
@@ -65,6 +65,7 @@ public sealed record FrameDto(
long Flags);
/// GET /api/v1/sequences/{id}/manifest: what a client needs to diff a sequence (BRIEF §14.5).
+/// How to make the proxies the server asks for (); null when it makes none.
public sealed record SequenceManifest(
Guid SequenceId,
int FramesVersion,
@@ -72,9 +73,21 @@ public sealed record SequenceManifest(
string? SettingsJson,
IReadOnlyList Tags,
IReadOnlyList Frames,
- IReadOnlyList Renders);
+ IReadOnlyList Renders,
+ ProxySpec? Proxies = null);
-public sealed record ManifestFrame(Guid Id, int Index, string FileName, long Size, string Sha256, bool HasProxy, bool HasThumb);
+/// One frame of a manifest: its content, whether the server has a proxy and thumbnail of it, and its flags.
+/// Lower-case hex SHA-256; empty while the server has not hashed it (a folder adopted and not verified yet).
+/// The frame's FrameFlags bits (missing, corrupt, excluded…).
+///
+/// The server cannot decode this original and has no proxy of it (BRIEF §2.3, §8.1: HEIF): a client or render node that
+/// decodes it sends one with PUT /api/v1/frames/{id}/proxy, made as says.
+///
+public sealed record ManifestFrame(Guid Id, int Index, string FileName, long Size, string Sha256, bool HasProxy, bool HasThumb, long Flags = 0,
+ bool WantsProxy = false);
+
+/// How the server's proxies are made (BRIEF §8.5): long edge in pixels (0 = full size) and JPEG quality.
+public sealed record ProxySpec(int LongEdge, int Quality);
public sealed record RenderDto(
Guid Id,
diff --git a/src/Titano.Server/Api/FileEndpoints.cs b/src/Titano.Server/Api/FileEndpoints.cs
index 76cf182f..42f273f7 100644
--- a/src/Titano.Server/Api/FileEndpoints.cs
+++ b/src/Titano.Server/Api/FileEndpoints.cs
@@ -1,6 +1,12 @@
using System.Globalization;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.Mvc;
+using Titano.Core.Archiving;
+using Titano.Core.Imaging.Decoders;
using Titano.Core.Model;
using Titano.Data;
+using Titano.Data.Archiving;
+using Titano.Server.Jobs;
using Titano.Server.Security;
using Titano.Server.Storage;
@@ -8,7 +14,8 @@ namespace Titano.Server.Api;
///
/// Streamed archive files with Range support (BRIEF §14.3): originals, proxies, thumbnails and exports. Paths come
-/// from the database by id and are resolved under the archive root only.
+/// from the database by id and are resolved under the archive root only. Proxies of frames the server cannot decode
+/// arrive from clients and render nodes (PUT /frames/{id}/proxy, BRIEF §2.3).
///
public static class FileEndpoints
{
@@ -21,6 +28,8 @@ public static class FileEndpoints
api.MapGet("/frames/{id:guid}/original", OriginalAsync).Requires(Permissions.Edit | Permissions.RenderNode);
api.MapGet("/frames/{id:guid}/proxy", (HttpContext c, Guid id, TitanoDatabase db, ServerArchive a, IFrameAssetLocator l) => AssetAsync(c, id, FrameAsset.Proxy, db, a, l))
.Requires(Permissions.Read | Permissions.RenderNode);
+ // Made by clients that edit and by render nodes, which decode what the server cannot.
+ api.MapPut("/frames/{id:guid}/proxy", StoreProxyAsync).Requires(Permissions.Edit | Permissions.RenderNode);
api.MapGet("/frames/{id:guid}/thumb", (HttpContext c, Guid id, TitanoDatabase db, ServerArchive a, IFrameAssetLocator l) => AssetAsync(c, id, FrameAsset.Thumbnail, db, a, l))
.Requires(Permissions.Read);
api.MapGet("/renders/{id:guid}/file", RenderAsync).Requires(Permissions.Read);
@@ -48,6 +57,47 @@ public static class FileEndpoints
?? ApiErrors.NotFound(context, "asset_missing");
}
+ ///
+ /// Files the body (a JPEG made from the original, its Exif capture time the frame's, at most
+ /// ) as the frame's proxy; the sequence's thumbnails and proxy state follow as
+ /// background jobs. 204; 413 too_large, 422 invalid_proxy or proxy_mismatch, 409
+ /// proxies_disabled, 503 archive_offline.
+ ///
+ private static async Task StoreProxyAsync(HttpContext context, Guid id, TitanoDatabase db, ServerArchive archive,
+ [FromServices] ArchiveService? archives, SequenceJobs follow)
+ {
+ var ct = context.RequestAborted;
+ if (await db.Frames.GetAsync(id, ct) is not { } frame || await db.Sequences.GetAsync(frame.SequenceId, ct) is not { } sequence)
+ return ApiErrors.NotFound(context, "frame");
+ if (context.Request.ContentLength is > ArchiveImages.MaxProxyBytes) return ApiErrors.Result(context, StatusCodes.Status413PayloadTooLarge, "too_large");
+ // Proxies are larger than the JSON bodies Kestrel is limited to; reading past this answers 413.
+ if (context.Features.Get() is { IsReadOnly: false } limit) limit.MaxRequestBodySize = ArchiveImages.MaxProxyBytes;
+ using var body = new MemoryStream();
+ await context.Request.Body.CopyToAsync(body, ct);
+
+ var images = (archives ?? new ArchiveService(db, new ArchiveServiceOptions { Decoder = DecoderFactory.CreateServer(), Owner = ArchiveModule.Owner })).Images;
+ ProxyStoreResult result;
+ try
+ {
+ result = images.StoreProxy(archive.Current, sequence, frame, body.ToArray());
+ }
+ catch (ArchiveOfflineException)
+ {
+ return ApiErrors.Result(context, StatusCodes.Status503ServiceUnavailable, "archive_offline");
+ }
+ switch (result)
+ {
+ case ProxyStoreResult.Disabled:
+ return ApiErrors.Conflict(context, "proxies_disabled");
+ case ProxyStoreResult.Invalid:
+ return ApiErrors.Result(context, StatusCodes.Status422UnprocessableEntity, "invalid_proxy");
+ case ProxyStoreResult.WrongFrame:
+ return ApiErrors.Result(context, StatusCodes.Status422UnprocessableEntity, "proxy_mismatch");
+ }
+ await follow.ProxyArrivedAsync(sequence, ct);
+ return Results.NoContent();
+ }
+
private static async Task RenderAsync(HttpContext context, Guid id, TitanoDatabase db, ServerArchive archive)
{
if (await db.Renders.GetAsync(id, context.RequestAborted) is not { } render) return ApiErrors.NotFound(context, "render");
diff --git a/src/Titano.Server/Api/SequenceEndpoints.cs b/src/Titano.Server/Api/SequenceEndpoints.cs
index c84b82ad..f3ec9993 100644
--- a/src/Titano.Server/Api/SequenceEndpoints.cs
+++ b/src/Titano.Server/Api/SequenceEndpoints.cs
@@ -213,29 +213,24 @@ public static class SequenceEndpoints
_ => ApiErrors.Conflict(context, "folder_missing"),
};
- /// Everything a client needs to mirror a sequence and detect changes (BRIEF §14.5); ETag over the version counters.
- private static async Task ManifestAsync(HttpContext context, Guid id, TitanoDatabase db)
+ ///
+ /// Everything a client needs to mirror a sequence and detect changes (BRIEF §14.5), with the proxies the server asks
+ /// for (); ETag over the version counters and the number of proxies asked for.
+ ///
+ private static async Task ManifestAsync(HttpContext context, Guid id, TitanoDatabase db, ServerArchive archive)
{
var ct = context.RequestAborted;
if (await db.Sequences.GetAsync(id, ct) is not { } sequence) return ApiErrors.NotFound(context, "sequence");
- var etag = string.Create(CultureInfo.InvariantCulture, $"\"m{sequence.SettingsVersion}-{sequence.FramesVersion}-{sequence.RenderedCount}\"");
+ var spec = ServerProxies.Spec(archive.Current);
+ var frames = await ServerProxies.FramesAsync(db, archive.Current, sequence, spec, ct);
+ var etag = string.Create(CultureInfo.InvariantCulture,
+ $"\"m{sequence.SettingsVersion}-{sequence.FramesVersion}-{sequence.RenderedCount}-{frames.Count(f => f.WantsProxy)}\"");
if (context.Request.Headers.IfNoneMatch == etag) return Results.StatusCode(StatusCodes.Status304NotModified);
- var hasProxy = sequence.Status.HasFlag(SequenceStatus.ProxiesBuilt);
- var hasThumb = sequence.Status.HasFlag(SequenceStatus.ThumbsBuilt);
- var frames = new List(sequence.FrameCount);
- var after = -1;
- while (true)
- {
- var batch = await db.Frames.ListBySequenceAsync(id, after, 1000, ct);
- frames.AddRange(batch.Select(f => new ManifestFrame(f.Id, f.Index, f.FileName, f.Size, f.Sha256 ?? string.Empty, hasProxy, hasThumb)));
- if (batch.Count < 1000) break;
- after = batch[^1].Index;
- }
var renders = await db.Renders.ListBySequenceAsync(id, ct);
context.Response.Headers.ETag = etag;
return Results.Json(new SequenceManifest(id, sequence.FramesVersion, sequence.SettingsVersion, sequence.SettingsJson, sequence.Tags, frames,
- [.. renders.Select(Dto.Render)]), ProtocolJson.Default.SequenceManifest);
+ [.. renders.Select(Dto.Render)], spec), ProtocolJson.Default.SequenceManifest);
}
private static async Task FramesAsync(HttpContext context, Guid id, string? cursor, int? limit, TitanoDatabase db)
diff --git a/src/Titano.Server/Jobs/RenderNodeService.cs b/src/Titano.Server/Jobs/RenderNodeService.cs
index b9f22d6f..4bb8a0d8 100644
--- a/src/Titano.Server/Jobs/RenderNodeService.cs
+++ b/src/Titano.Server/Jobs/RenderNodeService.cs
@@ -16,11 +16,14 @@ namespace Titano.Server.Jobs;
///
/// Render nodes (BRIEF §14.7): clients with the render-node right register their encoders, heartbeat, claim queued
/// render jobs they can encode, report progress, and upload the output in resumable chunks that become a render of
-/// the sequence. A node that stops heart-beating loses its jobs to the queue ().
+/// the sequence. A claimed job lists every frame with its flags (a node renders none missing, corrupt or excluded) and
+/// the proxies the server asks for (), which the node sends from the originals it fetched.
+/// A node that stops heart-beating loses its jobs to the queue ().
///
public sealed class RenderNodeService(
TitanoDatabase db,
ServerOptions options,
+ ServerArchive archive,
UploadService uploads,
UploadStore store,
RenderStore renders,
@@ -84,8 +87,9 @@ public sealed class RenderNodeService(
continue;
}
await TouchAsync(node, cancellationToken);
+ var spec = ServerProxies.Spec(archive.Current);
return new ClaimedJob(Dto.Job(job), sequence.Id, parameters.SettingsJson ?? sequence.SettingsJson ?? "{}", parameters.PresetJson,
- parameters.UseProxies, await ManifestFramesAsync(sequence, cancellationToken));
+ parameters.UseProxies, await ServerProxies.FramesAsync(db, archive.Current, sequence, spec, cancellationToken), spec);
}
await TouchAsync(node, cancellationToken);
return (ClaimedJob?)null;
@@ -234,22 +238,6 @@ public sealed class RenderNodeService(
if (state != node.State) events.Publish(new NodeStateEvent(node.Id, node.ClientName, state));
}
- private async Task> ManifestFramesAsync(Sequence sequence, CancellationToken cancellationToken)
- {
- var hasProxy = sequence.Status.HasFlag(SequenceStatus.ProxiesBuilt);
- var hasThumb = sequence.Status.HasFlag(SequenceStatus.ThumbsBuilt);
- var frames = new List(sequence.FrameCount);
- var after = -1;
- while (true)
- {
- var batch = await db.Frames.ListBySequenceAsync(sequence.Id, after, 1000, cancellationToken);
- frames.AddRange(batch.Where(f => !f.Flags.HasFlag(FrameFlags.Excluded))
- .Select(f => new ManifestFrame(f.Id, f.Index, f.FileName, f.Size, f.Sha256 ?? string.Empty, hasProxy, hasThumb)));
- if (batch.Count < 1000) return frames;
- after = batch[^1].Index;
- }
- }
-
///
/// The node has an encoder for the job's codec that handles its resolution: the encoder's own limit, else the node's
/// (0 = no announced limit).
diff --git a/src/Titano.Server/Jobs/SequenceJobs.cs b/src/Titano.Server/Jobs/SequenceJobs.cs
index f53c962f..d1743b04 100644
--- a/src/Titano.Server/Jobs/SequenceJobs.cs
+++ b/src/Titano.Server/Jobs/SequenceJobs.cs
@@ -4,21 +4,27 @@ using Titano.Data;
namespace Titano.Server.Jobs;
///
-/// Follow-up work after frames arrive (BRIEF §14.4): thumbnails, proxies and light analysis of the sequence, queued at
-/// background priority once per sequence while one is still waiting, and only for kinds this server can run.
+/// Follow-up work after frames arrive (BRIEF §14.4): thumbnails, proxies and light analysis of the sequence; after a
+/// proxy sent by a client or render node arrives, the thumbnails and the sequence's proxy state. Queued at background
+/// priority once per sequence while one is still waiting, and only for kinds this server can run.
///
public sealed class SequenceJobs(TitanoDatabase db, JobEngineHost jobs)
{
private static readonly JobKind[] AfterNewFrames = [JobKind.Thumbs, JobKind.Proxies, JobKind.LightAnalyse];
+ private static readonly JobKind[] AfterProxy = [JobKind.Thumbs, JobKind.Proxies];
private readonly SemaphoreSlim _gate = new(1, 1);
- public async Task FramesAddedAsync(Sequence sequence, CancellationToken cancellationToken)
+ public Task FramesAddedAsync(Sequence sequence, CancellationToken cancellationToken) => QueueAsync(sequence, AfterNewFrames, cancellationToken);
+
+ public Task ProxyArrivedAsync(Sequence sequence, CancellationToken cancellationToken) => QueueAsync(sequence, AfterProxy, cancellationToken);
+
+ private async Task QueueAsync(Sequence sequence, JobKind[] kinds, CancellationToken cancellationToken)
{
await _gate.WaitAsync(cancellationToken);
try
{
- foreach (var kind in AfterNewFrames)
+ foreach (var kind in kinds)
{
if (!jobs.CanRun(kind) || await db.Jobs.IsQueuedAsync(kind, sequence.Id, cancellationToken)) continue;
await jobs.Engine.EnqueueAsync(kind, [sequence.Id], sequence.DisplayTitle, priority: JobPriority.Background, cancellationToken: cancellationToken);
diff --git a/src/Titano.Server/Storage/ServerProxies.cs b/src/Titano.Server/Storage/ServerProxies.cs
new file mode 100644
index 00000000..fd70e4e5
--- /dev/null
+++ b/src/Titano.Server/Storage/ServerProxies.cs
@@ -0,0 +1,66 @@
+using Titano.Core.Archiving;
+using Titano.Core.Imaging;
+using Titano.Core.Imaging.Decoders;
+using Titano.Core.Model;
+using Titano.Data;
+using Titano.Data.Archiving;
+using Titano.Protocol;
+
+namespace Titano.Server.Storage;
+
+///
+/// Proxies the server asks for (BRIEF §2.3, §8.5): it decodes with managed decoders only, so the frames whose originals
+/// it cannot decode (HEIF) get their proxies from a Windows client or render node, made as the archive's proxy policy
+/// says. Manifests (sync and render nodes) list every frame with its flags and whether its proxy is wanted.
+///
+public static class ServerProxies
+{
+ private const int Page = 1000;
+
+ /// The server's decoders (BRIEF §4.2: managed only).
+ private static readonly ImageDecoder Decoder = DecoderFactory.CreateServer();
+
+ /// The server takes this format's pixels from proxies made elsewhere.
+ public static bool CannotDecode(ImageFileFormat format) => ArchiveImages.NeedsProxy(Decoder, format);
+
+ /// How proxies of the archive are made; null when it makes none (or its manifest cannot be read now).
+ public static ProxySpec? Spec(Archive archive)
+ {
+ try
+ {
+ var policy = ManifestStore.ReadArchive(new ArchivePaths(archive.RootPath).ManifestPath).ProxyPolicy;
+ return policy.LongEdge == ProxyPolicy.Disabled ? null : new ProxySpec(policy.LongEdge, policy.Quality);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
+ {
+ return null;
+ }
+ }
+
+ ///
+ /// Every frame of in index order, as a manifest lists it: a proxy is there when the server
+ /// built them all or one was sent for the frame; it is wanted for a frame the server cannot decode that has none
+ /// (and is not missing), unless is null.
+ ///
+ public static async Task> FramesAsync(TitanoDatabase db, Archive archive, Sequence sequence, ProxySpec? spec,
+ CancellationToken cancellationToken)
+ {
+ var proxies = sequence.Status.HasFlag(SequenceStatus.ProxiesBuilt);
+ var thumbs = sequence.Status.HasFlag(SequenceStatus.ThumbsBuilt);
+ var folder = new ArchivePaths(archive.RootPath).Sequence(sequence.Folder);
+ var frames = new List(sequence.FrameCount);
+ var after = -1;
+ while (true)
+ {
+ var batch = await db.Frames.ListBySequenceAsync(sequence.Id, after, Page, cancellationToken);
+ foreach (var f in batch)
+ {
+ var sent = !proxies && CannotDecode(f.Format) && File.Exists(folder.Proxy(f.Index));
+ var wanted = spec is not null && !proxies && !sent && CannotDecode(f.Format) && (f.Flags & (FrameFlags.Missing | FrameFlags.Corrupt)) == 0;
+ frames.Add(new ManifestFrame(f.Id, f.Index, f.FileName, f.Size, f.Sha256 ?? string.Empty, proxies || sent, thumbs, (long)f.Flags, wanted));
+ }
+ if (batch.Count < Page) return frames;
+ after = batch[^1].Index;
+ }
+ }
+}
diff --git a/tests/Titano.Data.Tests/Archiving/ProxyTests.cs b/tests/Titano.Data.Tests/Archiving/ProxyTests.cs
new file mode 100644
index 00000000..f7b86b17
--- /dev/null
+++ b/tests/Titano.Data.Tests/Archiving/ProxyTests.cs
@@ -0,0 +1,129 @@
+using Titano.Core.Archiving;
+using Titano.Core.Codecs.Jpeg;
+using Titano.Core.Imaging;
+using Titano.Core.Imaging.Decoders;
+using Titano.Core.Metadata;
+using Titano.Core.Model;
+using Titano.Data.Archiving;
+using Titano.Testing;
+using static Titano.Data.Tests.Archiving.ArchiveFixture;
+
+namespace Titano.Data.Tests.Archiving;
+
+/// Proxies of originals a host cannot decode (BRIEF §2.3, §8.5): sent by a client or render node, checked, kept, thumbnailed.
+[Category("archive")]
+public sealed class ProxyTests(TestContext context)
+{
+ [Test]
+ public void OnlyFormatsAHostCannotDecodeTakeTheirPixelsFromProxies()
+ {
+ var server = DecoderFactory.CreateServer();
+ Assert.True(ArchiveImages.NeedsProxy(server, ImageFileFormat.Heif), "HEIF previews are thumbnails at best");
+ Assert.True(ArchiveImages.NeedsProxy(server, ImageFileFormat.Avif));
+ Assert.True(ArchiveImages.NeedsProxy(server, ImageFileFormat.WebP), "no decoder at all");
+ Assert.False(ArchiveImages.NeedsProxy(server, ImageFileFormat.Cr3), "a RAW's embedded full-size preview");
+ Assert.False(ArchiveImages.NeedsProxy(server, ImageFileFormat.Dng));
+ Assert.False(ArchiveImages.NeedsProxy(new ImageDecoder([]), ImageFileFormat.Jpeg), "proxies are JPEGs");
+ Assert.False(ArchiveImages.NeedsProxy(server, ImageFileFormat.Unknown));
+ // A desktop whose decoders read HEIF makes the proxies a server asks for.
+ Assert.False(ArchiveImages.NeedsProxy(new ImageDecoder([new NativeHeif()]), ImageFileFormat.Heif));
+ }
+
+ [Test]
+ public async Task AProxySentForAFrameThisHostCannotDecodeIsCheckedKeptAndThumbnailed()
+ {
+ await using var fx = await CreateAsync(context);
+ var (sequence, frames) = await HeifSequenceAsync(fx);
+ var folder = fx.Paths.Sequence(sequence.Folder);
+ var images = fx.Service.Images;
+
+ Assert.Equal(ProxyStoreResult.Invalid, images.StoreProxy(fx.Archive, sequence, frames[0], "not a photo"u8.ToArray()));
+ Assert.Equal(ProxyStoreResult.WrongFrame, images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[1].CapturedAt!.Value, 1)));
+ Assert.FileMissing(folder.Proxy(0));
+ var proxy = Proxy(frames[0].CapturedAt!.Value, 2);
+ Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frames[0], proxy));
+ Assert.SequenceEqual(proxy, await File.ReadAllBytesAsync(folder.Proxy(0), fx.Ct));
+
+ // The proxy pass keeps what was sent and makes none from the originals here, even when forced.
+ var proxies = await images.BuildProxiesAsync(fx.Archive, sequence, force: true, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
+ Assert.Equal((0, 1, 1), (proxies.Built, proxies.Reused, proxies.Undecodable));
+ Assert.SequenceEqual(proxy, await File.ReadAllBytesAsync(folder.Proxy(0), fx.Ct));
+ Assert.FileMissing(folder.Proxy(1));
+
+ // The thumbnail comes from the proxy; the frame without one has none yet.
+ var thumbs = await images.BuildThumbnailsAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
+ Assert.Equal((1, 0, 1), (thumbs.Built, thumbs.Reused, thumbs.Undecodable));
+ using (var pack = ThumbPackReader.Open(folder.ThumbsPackPath))
+ {
+ var entry = pack.Entries[0];
+ Assert.Equal((FrameImageRenderer.ThumbnailLongEdge, 240), (entry.Width, entry.Height));
+ }
+ var again = await images.BuildThumbnailsAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
+ Assert.Equal((0, 1, 1), (again.Built, again.Reused, again.Undecodable));
+ }
+
+ [Test]
+ public async Task AProxyLeftByARenumberedFrameIsAskedForAgain()
+ {
+ await using var fx = await CreateAsync(context);
+ var (sequence, frames) = await HeifSequenceAsync(fx);
+ var folder = fx.Paths.Sequence(sequence.Folder);
+ Directory.CreateDirectory(folder.Proxies);
+ await File.WriteAllBytesAsync(folder.Proxy(1), Proxy(frames[0].CapturedAt!.Value, 3), fx.Ct);
+
+ var proxies = await fx.Service.Images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
+
+ Assert.Equal(2, proxies.Undecodable);
+ Assert.FileMissing(folder.Proxy(1));
+ Assert.False((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.ProxiesBuilt));
+ }
+
+ [Test]
+ public async Task AnArchiveWithoutProxiesRefusesThem()
+ {
+ await using var fx = await CreateAsync(context);
+ var (sequence, frames) = await HeifSequenceAsync(fx);
+ var manifest = ManifestStore.ReadArchive(fx.Paths.ManifestPath);
+ ManifestStore.WriteArchive(fx.Paths.ManifestPath, manifest with { ProxyPolicy = new ProxyPolicy { LongEdge = ProxyPolicy.Disabled } });
+
+ Assert.Equal(ProxyStoreResult.Disabled, fx.Service.Images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 4)));
+ Assert.FileMissing(fx.Paths.Sequence(sequence.Folder).Proxy(0));
+ }
+
+ /// Two ingested frames whose originals the archive engine takes for HEIF (its decoders read none).
+ private static async Task<(Sequence Sequence, IReadOnlyList Frames)> HeifSequenceAsync(ArchiveFixture fx)
+ {
+ Guid id = default;
+ for (var i = 0; i < 2; i++)
+ {
+ var staged = fx.Stage(Start.AddSeconds(10 * i), 40 + i);
+ id = (await fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, null, null, "heif", staged.Path, $"IMG_{i:0000}.HEIC",
+ staged.Size, staged.Sha256, null, null), fx.Ct)).SequenceId;
+ }
+ var sequence = (await fx.Db.Sequences.GetAsync(id, fx.Ct))!;
+ var folder = fx.Paths.Sequence(sequence.Folder);
+ var sidecar = ManifestStore.ReadSequence(folder.ManifestPath);
+ ManifestStore.WriteSequence(folder.ManifestPath, sidecar with { Frames = [.. sidecar.Frames.Select(f => f with { Format = ImageFileFormat.Heif })] });
+ return (sequence, await fx.Db.Frames.ListBySequenceAsync(id));
+ }
+
+ /// A 320 × 240 JPEG proxy with in its Exif, as a client makes it.
+ private static byte[] Proxy(DateTime captured, int seed)
+ {
+ using var image = new ImageBuffer(320, 240);
+ var level = 0.2f + seed % 5 * 0.1f;
+ for (var c = 0; c < 3; c++) image.Plane(c).Fill(level + c * 0.05f);
+ var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { CapturedAt = captured, Software = "Titano" });
+ return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] });
+ }
+
+ /// A provider that decodes HEIF natively (WIC with the HEIF extension on a desktop).
+ private sealed class NativeHeif : IImageDecoderProvider
+ {
+ public string Name => "native-heif";
+
+ public DecodeTier? TierFor(ImageFileFormat format) => format == ImageFileFormat.Heif ? DecodeTier.Native : null;
+
+ public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) => null;
+ }
+}
diff --git a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs
index 656032ef..f0a0aa41 100644
--- a/tests/Titano.Data.Tests/Processing/RenderJobTests.cs
+++ b/tests/Titano.Data.Tests/Processing/RenderJobTests.cs
@@ -63,6 +63,33 @@ public sealed class RenderJobTests(TestContext context)
Assert.Equal(3, (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.RenderedCount);
}
+ [Test]
+ public async Task FramesThisHostCannotDecodeRenderFromTheirProxies()
+ {
+ await using var fx = await ProcessingFixture.CreateAsync(context);
+ var sequence = await fx.AddAsync(Scene());
+ var folder = fx.Folder(sequence);
+ Directory.CreateDirectory(folder.Proxies);
+ foreach (var frame in await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))
+ {
+ // The originals are HEIF this host cannot read (BRIEF §2.3): only the proxies a client sent have pixels here.
+ var original = fx.Archive.Paths.FromRelative(frame.RelativePath);
+ File.Copy(original, folder.Proxy(frame.Index));
+ await File.WriteAllBytesAsync(original, [0, 0, 0, 24, .. "ftypheic"u8, 0, 0, 0, 0, .. "mif1heic"u8], fx.Ct);
+ }
+ await using (var session = await fx.Db.Database.OpenAsync(fx.Ct))
+ await session.ExecuteAsync("UPDATE frames SET format = $1 WHERE sequence_id = $2", [(int)ImageFileFormat.Heif, sequence.Id], fx.Ct);
+ await fx.StartEngineAsync();
+
+ // The job does not ask for proxies: the host takes them because it cannot decode the originals.
+ var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
+ await fx.WaitForAsync(job.Id, JobState.Done);
+
+ Assert.FileExists(Path.Combine(folder.Exports, "clip-MJPEG.avi"));
+ var decoded = fx.Decoder.Requests.Where(r => r.Purpose == DecodePurpose.Render).Select(r => Path.GetDirectoryName(r.Path)).Distinct().ToList();
+ Assert.SequenceEqual([folder.Proxies], decoded);
+ }
+
[Test]
public async Task ACancelledRenderLeavesNothingBehind()
{
diff --git a/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs b/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs
index c05213d4..275565b2 100644
--- a/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs
+++ b/tests/Titano.Data.Tests/Sync/FakeSyncRemote.cs
@@ -38,6 +38,9 @@ internal sealed class FakeSyncRemote : ISyncRemote
/// Proxy and thumbnail downloads fail with a server error.
public bool FailAssets { get; set; }
+ /// Proxies clients sent, by frame id (for sequences the server cannot decode).
+ public Dictionary SentProxies { get; } = [];
+
public FakeSequence Add(string? title, IEnumerable originals, string? settingsJson = null,
SequenceStatus status = SequenceStatus.ProxiesBuilt | SequenceStatus.ThumbsBuilt)
{
@@ -96,7 +99,7 @@ internal sealed class FakeSyncRemote : ISyncRemote
{
ManifestCalls++;
if (Refused.Contains(id)) throw new TitanoApiException(HttpStatusCode.Forbidden, new ApiError("forbidden", "refused"));
- return Task.FromResult(Find(id).Manifest());
+ return Task.FromResult(Find(id).Manifest(SentProxies.ContainsKey));
}
}
@@ -171,6 +174,18 @@ internal sealed class FakeSyncRemote : ISyncRemote
await destination.WriteAsync(bytes.AsMemory(offset), cancellationToken);
}
+ /// Like the server: only a frame whose proxy it asks for takes one, and only a JPEG.
+ public Task UploadProxyAsync(Guid frameId, byte[] jpeg, CancellationToken cancellationToken)
+ {
+ lock (_gate)
+ {
+ if (!Sequences.Values.Any(s => s.Undecodable && s.Frames.Any(f => f.Id == frameId))) throw NotFound();
+ if (jpeg is not [0xFF, 0xD8, ..]) throw new TitanoApiException(HttpStatusCode.UnprocessableEntity, new ApiError("invalid_proxy", "not a JPEG"));
+ SentProxies[frameId] = jpeg;
+ }
+ return Task.CompletedTask;
+ }
+
public async Task DownloadRenderAsync(Guid renderId, Stream destination, CancellationToken cancellationToken)
{
FakeRender render;
@@ -225,6 +240,10 @@ internal sealed class FakeSequence
public int SettingsVersion { get; set; } = 1;
public int FramesVersion { get; set; }
public SequenceStatus Status { get; set; }
+
+ /// The server cannot decode these originals (HEIF): its manifest asks for proxies of them.
+ public bool Undecodable { get; set; }
+
public DateTimeOffset UpdatedAt { get; set; } = DateTimeOffset.UtcNow;
public DateTime? FirstCapture { get; set; }
public string? CameraModel { get; set; } = "Canon EOS R5";
@@ -243,9 +262,10 @@ internal sealed class FakeSequence
public SequenceDto Dto() => new(Id, Title, Title ?? "Untitled", "2026/" + Id.ToString("N"), "Canon", CameraModel, null, FirstCapture, null, Frames.Count, 10,
Frames.Sum(f => (long)f.Bytes.Length), (long)Status, Renders.Count, null, Tags, Rating, Notes, SettingsVersion, FramesVersion, 0, null, UpdatedAt);
- public SequenceManifest Manifest() => new(Id, FramesVersion, SettingsVersion, SettingsJson, Tags,
- [.. Frames.Select((f, i) => new ManifestFrame(f.Id, i, f.FileName, f.Bytes.Length, f.Sha256, (Status & SequenceStatus.ProxiesBuilt) != 0,
- (Status & SequenceStatus.ThumbsBuilt) != 0))], [.. Renders.Select(r => r.Dto())]);
+ public SequenceManifest Manifest(Func proxySent) => new(Id, FramesVersion, SettingsVersion, SettingsJson, Tags,
+ [.. Frames.Select((f, i) => new ManifestFrame(f.Id, i, f.FileName, f.Bytes.Length, f.Sha256, (Status & SequenceStatus.ProxiesBuilt) != 0 || proxySent(f.Id),
+ (Status & SequenceStatus.ThumbsBuilt) != 0, WantsProxy: Undecodable && !proxySent(f.Id)))], [.. Renders.Select(r => r.Dto())],
+ Undecodable ? new ProxySpec(1280, 90) : null);
}
internal sealed record FakeRender(Guid Id, string FileName, string PresetName, byte[] Bytes)
diff --git a/tests/Titano.Data.Tests/Sync/SyncTransferTests.cs b/tests/Titano.Data.Tests/Sync/SyncTransferTests.cs
index e4f523c5..129fd092 100644
--- a/tests/Titano.Data.Tests/Sync/SyncTransferTests.cs
+++ b/tests/Titano.Data.Tests/Sync/SyncTransferTests.cs
@@ -1,5 +1,7 @@
+using Titano.Core.Codecs.Jpeg;
using Titano.Core.Imaging;
using Titano.Core.Imaging.Decoders;
+using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Render;
using Titano.Data.Sync;
@@ -32,6 +34,34 @@ public sealed class SyncTransferTests(TestContext context)
Assert.Equal(remote.Id, entry.Link!.RemoteId);
}
+ [Test]
+ public async Task AnUploadSendsTheProxiesTheServerCannotMakeItself()
+ {
+ await using var f = await SyncFixture.CreateAsync(context);
+ var photos = f.NewPhotos(3);
+ var local = await f.LocalAsync("Holy grail", photos);
+ // The server has the originals already (the Uploader sent them) but cannot decode them (HEIF, BRIEF §2.3).
+ var remote = f.Remote.Add("Holy grail", photos);
+ remote.Undecodable = true;
+ await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct);
+ await f.RefreshAsync();
+ var ahead = await f.EntryAsync("Holy grail");
+ Assert.Equal((SyncStatus.LocalAhead, 3), (ahead.Status, ahead.Link!.MissingRemote));
+ var engine = await f.StartEngineAsync();
+
+ var job = await f.Sync.EnqueueUploadAsync(engine, f.Server, local);
+ var done = await f.Archive.WaitForAsync(job.Id, JobState.Done);
+
+ Assert.True(f.Remote.SentProxies.Keys.ToHashSet().SetEquals(remote.Frames.Select(r => r.Id)), "a proxy of every frame");
+ foreach (var proxy in f.Remote.SentProxies.Values)
+ {
+ var info = JpegDecoder.ReadInfo(proxy);
+ Assert.True(info.Width <= 1280 && info.Height <= 1280, "made as the server's policy says");
+ }
+ Assert.Contains(Loc.L("Archive.Log.ProxiesSent", 3, 0), done.LogTail);
+ Assert.Equal(SyncStatus.InSync, (await f.EntryAsync("Holy grail")).Status);
+ }
+
[Test]
public async Task AResumedUploadSendsOnlyWhatTheServerLacks()
{
diff --git a/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs b/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs
index c32fecf2..5b35d8a7 100644
--- a/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs
+++ b/tests/Titano.Server.Tests/Jobs/RenderNodeClientTests.cs
@@ -1,10 +1,14 @@
+using System.Collections.Concurrent;
using System.Text;
using Microsoft.Extensions.DependencyInjection;
+using Titano.Core.Archiving;
using Titano.Core.Codecs.Jpeg;
using Titano.Core.Diagnostics.Synthetic;
using Titano.Core.Export;
+using Titano.Core.Imaging;
using Titano.Core.Imaging.Decoders;
using Titano.Core.Localization;
+using Titano.Core.Metadata;
using Titano.Core.Model;
using Titano.Core.Project;
using Titano.Data.Archiving;
@@ -57,6 +61,40 @@ public sealed class RenderNodeClientTests(TestContext context)
Assert.False(Directory.EnumerateFileSystemEntries(Path.Combine(cache, "jobs")).Any(), "job folder removed");
}
+ [Test]
+ public async Task ANodeSkipsMissingFramesFetchesUnhashedOnesAndSendsTheProxiesAskedFor()
+ {
+ await using var server = await TestServer.StartAsync(context);
+ var (editor, _, token) = await server.UserAsync("alberto", "editor", renderNode: true);
+ var sequenceId = await UploadSequenceAsync(editor, Photos()[..3]);
+ await Uploads.UploadAsync(editor, [0, 0, 0, 24, .. "ftypheic"u8, 0, 0, 0, 0, .. "mif1heic"u8, .. Uploads.Photo(2000, 9)], "IMG_0004.HEIC", sequenceId);
+ var frames = await server.Database.Frames.ListBySequenceAsync(sequenceId);
+ // Frame 1 is gone from the server, frame 2 was adopted and never hashed, frame 4 is a HEIF the server cannot decode.
+ File.Delete(Path.Combine(server.Options.ArchivePath, frames[0].RelativePath));
+ await server.Database.Frames.UpdateFlagsAsync([frames[0].Id], FrameFlags.Missing, FrameFlags.None);
+ await using (var session = await server.Database.Database.OpenAsync(context.Cancellation))
+ {
+ await session.ExecuteAsync("UPDATE frames SET sha256 = NULL WHERE id = $1", [frames[1].Id], context.Cancellation);
+ await session.ExecuteAsync("UPDATE frames SET format = $1 WHERE id = $2", [(int)ImageFileFormat.Heif, frames[3].Id], context.Cancellation);
+ }
+ var job = await CreateRenderAsync(server, editor, sequenceId);
+
+ var requests = new RecordPaths(new SocketsHttpHandler());
+ using var client = new TitanoClient(server.HttpBase, new CertificatePinning([]), "studio-pc", requests) { Token = token };
+ // This PC decodes HEIF (WIC with the HEIF extension on Windows).
+ await using var node = Node(client, context.CreateTempDirectory("node"), decoder: new ImageDecoder([new SolidHeif(), new ManagedDecoderProvider()]));
+ Assert.True(await node.RunOnceAsync(context.Cancellation), "a job was claimed");
+
+ var done = await JobApiTests.GetAsync(editor, job.Id);
+ Assert.Equal("done", done.State, done.Error);
+ Assert.DoesNotContain($"/api/v1/frames/{frames[0].Id}/original", requests.Paths);
+ Assert.Contains($"/api/v1/frames/{frames[1].Id}/original", requests.Paths);
+ var sequence = (await server.Database.Sequences.GetAsync(sequenceId))!;
+ var proxy = new ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder).Proxy(frames[3].Index);
+ Assert.Equal(frames[3].CapturedAt, MetadataReader.Read(proxy).CapturedAt, "the proxy the server asked for, with the frame's capture time");
+ Assert.Equal((96, 64), MetadataReader.Read(proxy).OrientedSize);
+ }
+
[Test]
public async Task ANodeReportsWhyItCouldNotRender()
{
@@ -263,8 +301,8 @@ public sealed class RenderNodeClientTests(TestContext context)
Assert.FileExists(part[..^".part".Length]);
}
- private static RenderNodeClient Node(TitanoClient client, string cache, TimeSpan? poll = null, TimeSpan? heartbeat = null) =>
- new(client, new ProcessingOptions { Archive = new ArchiveServiceOptions { Decoder = DecoderFactory.CreateServer() } },
+ private static RenderNodeClient Node(TitanoClient client, string cache, TimeSpan? poll = null, TimeSpan? heartbeat = null, ImageDecoder? decoder = null) =>
+ new(client, new ProcessingOptions { Archive = new ArchiveServiceOptions { Decoder = decoder ?? DecoderFactory.CreateServer() } },
new RenderNodeOptions
{
ClientName = "studio-pc",
@@ -314,6 +352,35 @@ public sealed class RenderNodeClientTests(TestContext context)
}
}
+ /// Records the path of every request.
+ private sealed class RecordPaths(HttpMessageHandler inner) : DelegatingHandler(inner)
+ {
+ private readonly ConcurrentQueue _paths = new();
+
+ public IReadOnlyCollection Paths => _paths;
+
+ protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+ {
+ _paths.Enqueue(request.RequestUri!.AbsolutePath);
+ return base.SendAsync(request, cancellationToken);
+ }
+ }
+
+ /// Decodes every HEIF as a mid-grey 96 × 64 frame, as a native HEIF decoder would decode a real one.
+ private sealed class SolidHeif : IImageDecoderProvider
+ {
+ public string Name => "heif-test";
+
+ public DecodeTier? TierFor(ImageFileFormat format) => format == ImageFileFormat.Heif ? DecodeTier.Native : null;
+
+ public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default)
+ {
+ var image = new ImageBuffer(96, 64);
+ for (var c = 0; c < 3; c++) image.Plane(c).Fill(0.2f);
+ return new DecodedImage(image, DecodeTier.Native, Name, 96, 64);
+ }
+ }
+
/// Counts the node's claims the server answered.
private sealed class CountClaims(HttpMessageHandler inner) : DelegatingHandler(inner)
{
diff --git a/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs b/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs
new file mode 100644
index 00000000..688343b9
--- /dev/null
+++ b/tests/Titano.Server.Tests/Storage/ProxyUploadTests.cs
@@ -0,0 +1,99 @@
+using System.Net;
+using System.Net.Http.Headers;
+using Titano.Core.Codecs.Jpeg;
+using Titano.Core.Imaging;
+using Titano.Core.Metadata;
+using Titano.Protocol;
+using Titano.Server.Storage;
+using Titano.Testing;
+
+namespace Titano.Server.Tests.Storage;
+
+///
+/// Proxies of originals the server cannot decode (BRIEF §2.3: HEIF) arrive from clients and render nodes through
+/// PUT /api/v1/frames/{id}/proxy and become the frame's proxy and thumbnail.
+///
+[Category("server")]
+public sealed class ProxyUploadTests(TestContext context)
+{
+ [Test]
+ public async Task AProxySentForAFrameTheServerCannotDecodeIsCheckedKeptAndThumbnailed()
+ {
+ await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
+ var (editor, _, _) = await server.UserAsync("alberto", "editor");
+ var (viewer, _, _) = await server.UserAsync("vera", "viewer");
+ var upload = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
+ var frame = Assert.NotNull(await server.Database.Frames.GetAsync(upload.FrameId));
+ Assert.Equal(ImageFileFormat.Heif, frame.Format);
+
+ var manifest = await ManifestAsync(editor, upload.SequenceId);
+ Assert.Equal((true, false), (manifest.Frames.Single().WantsProxy, manifest.Frames.Single().HasProxy));
+ Assert.Equal(new ProxySpec(1920, 92), manifest.Proxies);
+
+ using (var garbage = await PutAsync(editor, frame.Id, "not a photo"u8.ToArray()))
+ await garbage.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "invalid_proxy");
+ using (var other = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value.AddSeconds(1))))
+ await other.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_mismatch");
+ var proxy = Proxy(frame.CapturedAt!.Value);
+ using (var refused = await PutAsync(viewer, frame.Id, proxy))
+ await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
+ using (var missing = await PutAsync(editor, Guid.CreateVersion7(), proxy))
+ await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
+ using (var stored = await PutAsync(editor, frame.Id, proxy))
+ await stored.ExpectAsync(HttpStatusCode.NoContent);
+
+ await Http.BytesEqualAsync(proxy, editor.GetByteArrayAsync($"/api/v1/frames/{frame.Id}/proxy"));
+ var after = (await ManifestAsync(editor, upload.SequenceId)).Frames.Single();
+ Assert.Equal((false, true), (after.WantsProxy, after.HasProxy));
+
+ // The thumbnail job the proxy queued draws the frame from it.
+ var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
+ while (true)
+ {
+ using var thumb = await editor.GetAsync($"/api/v1/frames/{frame.Id}/thumb");
+ if (thumb.StatusCode == HttpStatusCode.OK)
+ {
+ var jpeg = await thumb.Content.ReadAsByteArrayAsync();
+ Assert.Equal((320, 240), (JpegDecoder.ReadInfo(jpeg).Width, JpegDecoder.ReadInfo(jpeg).Height));
+ break;
+ }
+ Assert.True(DateTime.UtcNow < until, $"thumbnail not built: {(int)thumb.StatusCode}");
+ await Task.Delay(100);
+ }
+ }
+
+ [Test]
+ public async Task FramesTheServerDecodesAskForNoProxy()
+ {
+ await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
+ var (editor, _, _) = await server.UserAsync("alberto", "editor");
+ var upload = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 11)), "IMG_0001.JPG", sessionKey: "roof");
+
+ Assert.False((await ManifestAsync(editor, upload.SequenceId)).Frames.Single().WantsProxy);
+ }
+
+ /// A HEIF file as far as signature sniffing goes (an ftyp box naming heic), with no pixels the server can read.
+ private static byte[] Heif(int seed) => [0, 0, 0, 24, .. "ftypheic"u8, 0, 0, 0, 0, .. "mif1heic"u8, .. Uploads.Photo(2000, seed)];
+
+ /// A 320 × 240 JPEG with in its Exif, as a client makes a proxy.
+ private static byte[] Proxy(DateTime captured)
+ {
+ using var image = new ImageBuffer(320, 240);
+ for (var c = 0; c < 3; c++) image.Plane(c).Fill(0.3f + c * 0.1f);
+ var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { CapturedAt = captured, Software = "Titano" });
+ return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] });
+ }
+
+ private static Task PutAsync(HttpClient client, Guid frameId, byte[] body)
+ {
+ var content = new ByteArrayContent(body);
+ content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
+ return client.PutAsync($"/api/v1/frames/{frameId}/proxy", content);
+ }
+
+ private static async Task ManifestAsync(HttpClient client, Guid sequenceId)
+ {
+ using var response = await client.GetAsync($"/api/v1/sequences/{sequenceId}/manifest");
+ return await response.ReadAsync(ProtocolJson.Default.SequenceManifest);
+ }
+}