Routing sizes render jobs from the resolved preset, and the node wait applies the same routing as the claim, so a re-routed job neither keeps a stale size nor waits for a node that will never take it. Settings an older server cannot read stay on this side for the remote editor, archive sync and workspace push, and the reason is shown where it applies. A turn on one side and a framing on the other merge as one conflict. Orientation and framing fixes: an out-of-range crop turns with the content it shows, the aspect text transposes exactly, the Rotation row counts turns as shown on screen, and Reset framing undoes the orientation press by press, so keyframes and aspect stay on their content. The advisor places the horizon in the view as shown. A look at zero strength is cleared and no longer reaches the motion vectors. Preview changes: the middle button pans, a press inside a box with no slack pans while zoomed, the selected box shows a ring, and screen readers hear when the crop value changes. Tooltips in en and it updated; stale translations of changed tooltips removed so they fall back to English. Test changes: the pinned hash is OS-independent, and the tautological encoder and warning assertions became real checks. Added a non-screen test of the Straighten slider binding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
728 lines
46 KiB
C#
728 lines
46 KiB
C#
using System.Text;
|
||
using Chronos.Core.Diagnostics.Synthetic;
|
||
using Chronos.Core.Export;
|
||
using Chronos.Core.Imaging;
|
||
using Chronos.Core.Imaging.Decoders;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Core.Project;
|
||
using Chronos.Core.Video;
|
||
using Chronos.Data.Jobs;
|
||
using Chronos.Data.Processing;
|
||
using Chronos.Data.Tests.Archiving;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.Data.Tests.Processing;
|
||
|
||
[Category("processing")]
|
||
public sealed class RenderJobTests(TestContext context)
|
||
{
|
||
private const int Frames = 24;
|
||
|
||
/// <summary>MJPEG at the source size, named by codec so the tests know the file names.</summary>
|
||
private static readonly ExportSettings Mjpeg = new()
|
||
{
|
||
Preset = new Auto<string>().WithManual("mjpeg-avi"),
|
||
Overrides = new ExportOverrides { Width = 96, Height = 64 },
|
||
NameTemplate = "clip-{codec}",
|
||
};
|
||
|
||
/// <summary>HEVC (a render node's codec) at the size of <see cref="Mjpeg"/>.</summary>
|
||
private static readonly ExportSettings Hevc = Mjpeg with { Preset = new Auto<string>().WithManual("4k-hevc") };
|
||
|
||
private static SyntheticSequence Scene() => SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = Frames, StartEv = 0.5, EndEv = -0.5 });
|
||
|
||
[Test]
|
||
public async Task ABatchWritesPlayableManagedOutputsIntoExportsAndRecordsThem()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["png-sequence", "gif-preview"] }, 96, 64));
|
||
await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
var exports = fx.Folder(sequence).Exports;
|
||
var avi = await File.ReadAllBytesAsync(Path.Combine(exports, "clip-MJPEG.avi"), fx.Ct);
|
||
Assert.Equal(("RIFF", "AVI "), (Encoding.ASCII.GetString(avi, 0, 4), Encoding.ASCII.GetString(avi, 8, 4)));
|
||
Assert.Contains("idx1", Encoding.ASCII.GetString(avi));
|
||
var pngs = Directory.GetFiles(Path.Combine(exports, "clip-PNG")).Order().ToList();
|
||
Assert.Equal(Frames, pngs.Count);
|
||
Assert.Equal("clip-PNG_000001.png", Path.GetFileName(pngs[0]));
|
||
using (var decoded = DecoderFactory.CreateServer().Decode(new DecodeRequest(pngs[^1])))
|
||
Assert.Equal((96, 64), (Assert.NotNull(decoded).Pixels.Width, decoded.Pixels.Height));
|
||
var gif = await File.ReadAllBytesAsync(Path.Combine(exports, "clip-GIF.gif"), fx.Ct);
|
||
Assert.Equal("GIF89a", Encoding.ASCII.GetString(gif, 0, 6));
|
||
Assert.Empty(Directory.EnumerateFileSystemEntries(exports, ".*"));
|
||
|
||
var renders = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).OrderBy(r => r.OutputPath, StringComparer.Ordinal).ToList();
|
||
Assert.SequenceEqual(["Synthetic/exports/clip-GIF.gif", "Synthetic/exports/clip-MJPEG.avi", "Synthetic/exports/clip-PNG"], renders.Select(r => r.OutputPath));
|
||
var mjpeg = renders[1];
|
||
Assert.Equal((Loc.L("Export.Preset.Custom"), "Mjpeg", 96, 64, "test-pc", (long)avi.Length),
|
||
(mjpeg.PresetName, mjpeg.Codec, mjpeg.Width, mjpeg.Height, mjpeg.ProducedBy, mjpeg.Bytes));
|
||
Assert.Equal(Loc.L("Export.Preset.Gif"), renders[0].PresetName);
|
||
Assert.Equal(3, (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.RenderedCount);
|
||
}
|
||
|
||
[Test]
|
||
public async Task AProjectVersionRendersWithItsPositionsPlacedOnTheFramesAndIsRecordedWithIt()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var frames = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct);
|
||
var photos = new FramePhotos(frames.Select(f => (f.Index, new FramePhoto(f.Sha256, f.Size, f.CapturedAt))));
|
||
var projects = fx.Archive.Service.Projects;
|
||
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
|
||
var head = await projects.HeadAsync(vertical.Id, fx.Ct);
|
||
// The version holds its positions parked by photo (the adopted frames are not hashed: size and capture time name them).
|
||
var settings = new ProjectSettings { ExcludedFrames = [3, 5], Timing = new TimingSettings { Mode = new Auto<TimingMode>().WithManual(TimingMode.Constant) } };
|
||
var portable = ProjectContent.ToPortable(settings, photos);
|
||
Assert.Empty(ProjectSettings.FromJson(portable).ExcludedFrames);
|
||
var draft = head with
|
||
{
|
||
Id = Guid.CreateVersion7(),
|
||
ParentId = head.Id,
|
||
Number = 2,
|
||
Kind = ProjectVersionKind.Commit,
|
||
SettingsJson = portable,
|
||
ContentHash = ProjectContent.Hash(portable),
|
||
StoredAt = null,
|
||
};
|
||
var version = (await projects.PushAsync(vertical.Id, draft, fx.Ct)).Version!;
|
||
await fx.StartEngineAsync();
|
||
|
||
var requests = ProcessingJobs.RenderVersion(sequence, version, Mjpeg with { Preset = new Auto<string>().WithManual("png-sequence") }, 96, 64);
|
||
var job = await fx.EnqueueAsync(requests.Single());
|
||
await fx.Archive.WaitForAsync(job.Id, JobState.Done, (int)TestTiming.Budget(60));
|
||
|
||
Assert.Equal(Frames - 2, Directory.GetFiles(Path.Combine(fx.Folder(sequence).Exports, "clip-PNG")).Length);
|
||
var render = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).Single();
|
||
Assert.Equal((vertical.Id, version.Id), (render.ProjectId, render.ProjectVersionId));
|
||
Assert.SequenceEqual([3, 5], ProjectSettings.FromJson(render.SettingsJson!).ExcludedFrames);
|
||
// A render of another project leaves the sequence's own settings alone.
|
||
Assert.Empty(ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.SettingsJson ?? "{}").ExcludedFrames);
|
||
|
||
// A job naming the version without its settings renders them too.
|
||
var named = Chronos.Protocol.ProtocolJson.Default.RenderJobParameters;
|
||
var parameters = System.Text.Json.JsonSerializer.Deserialize(requests[0].ParametersJson!, named)! with { SettingsJson = null };
|
||
var second = await fx.EnqueueAsync(requests[0] with { ParametersJson = System.Text.Json.JsonSerializer.Serialize(parameters, named) });
|
||
await fx.Archive.WaitForAsync(second.Id, JobState.Done, (int)TestTiming.Budget(60));
|
||
Assert.True((await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).All(r => r.ProjectVersionId == version.Id));
|
||
|
||
// A version the index does not hold (saved on a PC, sent later under another id), or one whose settings the job does
|
||
// not embed: the render records the project alone, never a version it did not render.
|
||
var embedded = System.Text.Json.JsonSerializer.Deserialize(requests[0].ParametersJson!, named)!;
|
||
var other = ProjectContent.ToPortable(settings with { ExcludedFrames = [3] }, photos);
|
||
foreach (var wrong in new[] { embedded with { ProjectVersionId = Guid.CreateVersion7() }, embedded with { SettingsJson = other } })
|
||
{
|
||
var refused = await fx.EnqueueAsync(requests[0] with { ParametersJson = System.Text.Json.JsonSerializer.Serialize(wrong, named) });
|
||
await fx.Archive.WaitForAsync(refused.Id, JobState.Done, (int)TestTiming.Budget(60));
|
||
var recorded = (await fx.Db.Renders.GetAsync(Chronos.Data.Processing.Jobs.RenderJobHandler.RenderId(refused.Id, 0), fx.Ct))!;
|
||
Assert.Equal<(Guid?, Guid?)>((vertical.Id, null), (recorded.ProjectId, recorded.ProjectVersionId));
|
||
}
|
||
}
|
||
|
||
[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()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
fx.Decoder.HoldFrame(12, DecodePurpose.Render);
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct);
|
||
await fx.Engine.CancelAsync(job.Id, fx.Ct);
|
||
await fx.WaitForAsync(job.Id, JobState.Cancelled);
|
||
await WaitUntilIdleAsync(fx, job.Id);
|
||
|
||
Assert.Empty(Entries(fx.Folder(sequence).Exports));
|
||
Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
|
||
}
|
||
|
||
[Test]
|
||
public async Task AFailedRenderLeavesNothingBehindAndSaysWhy()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
// 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, "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 ARenderOfAFolderAnotherIndexMovedWaitsForThisIndexsScan()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var left = fx.Folder(sequence).Folder;
|
||
var (server, archive) = await fx.Archive.OtherWriterAsync();
|
||
var plan = await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct);
|
||
await server.ApplyRenameAsync(plan, null, fx.Ct);
|
||
await fx.StartEngineAsync();
|
||
|
||
// A server sharing the archive moved the folder; this index has not scanned since. Nothing renders, nothing is flagged.
|
||
var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
var failed = await fx.WaitForAsync(job.Id, JobState.Failed);
|
||
Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error);
|
||
Assert.False(Directory.Exists(left), "the folder it left is not created again");
|
||
Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
|
||
Assert.True((await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct)).All(f => (f.Flags & (FrameFlags.Missing | FrameFlags.Undecodable)) == 0), "no frame flagged");
|
||
|
||
// Once this index's scan found it there, the render goes into its exports.
|
||
await fx.Archive.ScanAsync();
|
||
var again = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
await fx.WaitForAsync(again.Id, JobState.Done);
|
||
var moved = fx.Archive.Paths.Sequence(plan.Steps.Single().ToFolder);
|
||
Assert.FileExists(Path.Combine(moved.Exports, "clip-MJPEG.avi"));
|
||
Assert.False(Directory.Exists(left));
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARenderNeverWritesIntoAnotherSequenceMovedIntoItsFolder()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var stranger = await fx.AddAsync(Scene(), "Other");
|
||
var (server, archive) = await fx.Archive.OtherWriterAsync();
|
||
await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct), null, fx.Ct);
|
||
await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger.Id], sequence.Folder, null, fx.Ct), null, fx.Ct);
|
||
var folder = fx.Folder(sequence).Folder;
|
||
var before = ArchiveFixture.FilesOf(folder);
|
||
await fx.StartEngineAsync();
|
||
|
||
// A server sharing the archive moved the folder away and the other sequence into it; this index has not scanned since.
|
||
var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
var failed = await fx.WaitForAsync(job.Id, JobState.Failed);
|
||
Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error);
|
||
Assert.SequenceEqual(before, ArchiveFixture.FilesOf(folder), "the other sequence's files are untouched");
|
||
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 = Chronos.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 AFrameThatCannotBeReadIsShownAsItsNeighbourButNeverFlagged()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
// Another program holds the file during the render (antivirus, backup): a read error says nothing about the file.
|
||
fx.Decoder.Unreadable[ProcessingFixture.FileName(10)] = 0;
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
var done = await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
Assert.Contains(Loc.L("Export.Log.StandIns", "11"), done.LogTail);
|
||
var sidecar = Chronos.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath);
|
||
Assert.Equal(FrameFlags.None, sidecar.Frames[10].Flags & FrameFlags.Undecodable);
|
||
Assert.NotEqual(DecodeTier.Unavailable, sidecar.Frames[10].Tier);
|
||
Assert.False(sidecar.Status.HasFlag(SequenceStatus.HasWarnings), "no warning");
|
||
Assert.Equal(FrameFlags.None, (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[10].Flags);
|
||
}
|
||
|
||
[Test]
|
||
public async Task ASmallRenderKeepsTheStoredSizeOfTheLargestPreview()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
// A CR3 on the server: the probe finds its full-size 6000×4000 preview, which caps the output.
|
||
for (var i = 0; i < Frames; i++)
|
||
fx.Decoder.Tiers[ProcessingFixture.FileName(i)] = new FileTier(ImageFileFormat.Jpeg, DecodeTier.EmbeddedPreview, "test-preview", "test", 6000, 4000);
|
||
await fx.StartEngineAsync();
|
||
var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id]));
|
||
await fx.WaitForAsync(light.Id, JobState.Done);
|
||
var probed = Chronos.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames[3];
|
||
Assert.Equal((FrameFlags.PreviewOnly, (int?)6000, (int?)4000), (probed.Flags, probed.PreviewW, probed.PreviewH));
|
||
|
||
// A small render decodes the smallest preview that reaches its size (1620×1080): that is not the largest.
|
||
for (var i = 0; i < Frames; i++) fx.Decoder.PreviewDecodes[ProcessingFixture.FileName(i)] = (1620, 1080);
|
||
var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
var frames = Chronos.Core.Archiving.ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames;
|
||
Assert.True(frames.All(f => f is { Tier: DecodeTier.EmbeddedPreview, PreviewW: 6000, PreviewH: 4000 }), "sidecar preview sizes kept");
|
||
var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct);
|
||
Assert.True(rows.All(f => (f.PreviewWidth, f.PreviewHeight) == (6000, 4000)), "index preview sizes kept");
|
||
Assert.Equal((6000, 4000), (Chronos.Core.Advice.SequenceContext.FromFrames(rows).PreviewWidth, Chronos.Core.Advice.SequenceContext.FromFrames(rows).PreviewHeight));
|
||
}
|
||
|
||
[Test]
|
||
public void FramesARenderNodeReceivesKeepTheirTierFields()
|
||
{
|
||
var dto = new Chronos.Protocol.FrameDto(Guid.CreateVersion7(), Guid.CreateVersion7(), 3, "IMG_0004.CR3", 25_000_000, new string('a', 64),
|
||
new DateTime(2026, 9, 28, 18, 0, 20), 120, 1.0 / 250, 8, 100, 24, 6, 6000, 4000, "cr3",
|
||
(long)(FrameFlags.PreviewOnly | FrameFlags.Intervalometer), 1620, 1080);
|
||
|
||
var frame = RenderNodeClient.ToFrame(dto);
|
||
Assert.Equal((ImageFileFormat.Cr3, FrameFlags.PreviewOnly | FrameFlags.Intervalometer, 1620, 1080),
|
||
(frame.Format, frame.Flags, frame.PreviewWidth, frame.PreviewHeight));
|
||
// The node's advisor caps a portrait sequence at its previews, oriented like the main image.
|
||
var tiers = Chronos.Core.Advice.SequenceContext.FromFrames([frame]);
|
||
Assert.Equal((1, 1080, 1620), (tiers.PreviewOnlyCount, tiers.PreviewWidth, tiers.PreviewHeight));
|
||
}
|
||
|
||
[Test]
|
||
public async Task OnlyFramesTheRenderShowsGetAStandIn()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
foreach (var i in new[] { 1, 3 })
|
||
await File.WriteAllBytesAsync(Path.Combine(fx.Archive.Paths.Root, "Synthetic", ProcessingFixture.FileName(i)), new byte[5000], fx.Ct);
|
||
var decoder = new ImageDecoder([fx.Decoder]);
|
||
var frames = await SequenceFrames.LoadAsync(fx.Db, fx.Archive.Archive, sequence, useProxies: false, decoder, fx.Ct);
|
||
|
||
// A plan that skips the odd frames (a speed-up): the read-ahead meets frames 1 and 3, the pipeline never asks.
|
||
var source = new SequenceFrameSource(frames, frames.LightFrames(), decoder, new FrameWindowOptions { Ahead = 4 })
|
||
{
|
||
Originals = true,
|
||
RenderExcluded = new HashSet<int>(),
|
||
};
|
||
await using (source)
|
||
{
|
||
foreach (var index in new[] { 0, 2, 4, 6 })
|
||
{
|
||
using var frame = await source.GetFrameAsync(index, 64, DecodePurpose.Render, fx.Ct);
|
||
Assert.Equal(64, frame.Width);
|
||
}
|
||
// The read-ahead decodes in the background: wait until it has met frame 4 (index 3).
|
||
for (var waited = 0; !source.Observed.ContainsKey(3) && waited < 200; waited++) await Task.Delay(50, fx.Ct);
|
||
}
|
||
Assert.Equal(DecodeTier.Unavailable, source.Observed[3].Tier);
|
||
Assert.Empty(source.StandIns);
|
||
|
||
// Asked for, a damaged frame shows its neighbour and is listed.
|
||
await using var asked = new SequenceFrameSource(frames, frames.LightFrames(), new ImageDecoder([fx.Decoder]))
|
||
{
|
||
RenderExcluded = new HashSet<int>(),
|
||
};
|
||
using (var standIn = await asked.GetFrameAsync(3, 64, DecodePurpose.Render, fx.Ct))
|
||
Assert.Equal(64, standIn.Width);
|
||
Assert.SequenceEqual([3], asked.StandIns);
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARenderInterruptedByACrashStartsItsOutputAgainCleanly()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var exports = fx.Folder(sequence).Exports;
|
||
var output = Path.Combine(exports, "clip-MJPEG.avi");
|
||
// The crashed attempt left its encoder's temporary file and a finished output it never recorded.
|
||
Directory.CreateDirectory(exports);
|
||
await File.WriteAllBytesAsync(Path.Combine(exports, ".clip-MJPEG.avi.0badf00d.tmp"), new byte[100], fx.Ct);
|
||
await File.WriteAllBytesAsync(output, new byte[100], fx.Ct);
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["gif-preview"] }, 96, 64),
|
||
new RenderCheckpoint([], 0, output).ToJson());
|
||
await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
Assert.SequenceEqual(["clip-GIF.gif", "clip-MJPEG.avi"], Entries(exports));
|
||
Assert.Equal("RIFF", Encoding.ASCII.GetString((await File.ReadAllBytesAsync(output, fx.Ct))[..4]));
|
||
Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARenderInterruptedAfterRecordingAnOutputResumesWithTheNextOne()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var exports = fx.Folder(sequence).Exports;
|
||
var output = Path.Combine(exports, "clip-MJPEG.avi");
|
||
Directory.CreateDirectory(exports);
|
||
var recorded = Encoding.ASCII.GetBytes("RIFF recorded before the crash");
|
||
await File.WriteAllBytesAsync(output, recorded, fx.Ct);
|
||
// The crash came after the job recorded its first entry and before its checkpoint said so.
|
||
var jobId = Guid.CreateVersion7();
|
||
await fx.Db.Renders.InsertAsync(RecordedRender(sequence, Chronos.Data.Processing.Jobs.RenderJobHandler.RenderId(jobId, 0)), fx.Ct);
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["gif-preview"] }, 96, 64),
|
||
new RenderCheckpoint([], 0, output).ToJson(), jobId);
|
||
await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
var kept = await File.ReadAllBytesAsync(output, fx.Ct);
|
||
Assert.BytesEqual(recorded, kept);
|
||
Assert.SequenceEqual(["clip-GIF.gif", "clip-MJPEG.avi"], Entries(exports));
|
||
Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARenderResumedAfterAnotherRecordedItsNameKeepsThatOutput()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var exports = fx.Folder(sequence).Exports;
|
||
var output = Path.Combine(exports, "clip-MJPEG.avi");
|
||
Directory.CreateDirectory(exports);
|
||
// While this job waited to resume, another render of the same preset finished under the name it had chosen.
|
||
var other = Encoding.ASCII.GetBytes("RIFF another render's output");
|
||
await File.WriteAllBytesAsync(output, other, fx.Ct);
|
||
await fx.Db.Renders.InsertAsync(RecordedRender(sequence, Guid.CreateVersion7()), fx.Ct);
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg, 96, 64), new RenderCheckpoint([], 0, output).ToJson());
|
||
await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
var kept = await File.ReadAllBytesAsync(output, fx.Ct);
|
||
Assert.BytesEqual(other, kept);
|
||
Assert.SequenceEqual(["clip-MJPEG (2).avi", "clip-MJPEG.avi"], Entries(exports));
|
||
Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
|
||
}
|
||
|
||
[Test]
|
||
public async Task ARenderResumedAfterItsFolderMovedNeverDeletesWhatAnotherSequenceBroughtIntoIt()
|
||
{
|
||
// The crashed attempt's checkpoint names the folder it chose the output in, or (written by an older version) does not.
|
||
foreach (var named in new[] { true, false })
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
var stranger = await fx.AddAsync(Scene(), "Other");
|
||
var output = Path.Combine(fx.Folder(sequence).Exports, "clip-MJPEG.avi");
|
||
// The crashed attempt left its encoder's temporary file and a finished output it never recorded; the other
|
||
// sequence has an export of that name, and a hidden file that looks like such a leftover.
|
||
Directory.CreateDirectory(fx.Folder(sequence).Exports);
|
||
await File.WriteAllBytesAsync(Path.Combine(fx.Folder(sequence).Exports, ".clip-MJPEG.avi.0badf00d.tmp"), new byte[100], fx.Ct);
|
||
await File.WriteAllBytesAsync(output, new byte[100], fx.Ct);
|
||
Directory.CreateDirectory(fx.Folder(stranger).Exports);
|
||
await File.WriteAllBytesAsync(Path.Combine(fx.Folder(stranger).Exports, ".clip-MJPEG.avi.0ddba11.tmp"), new byte[50], fx.Ct);
|
||
await File.WriteAllBytesAsync(Path.Combine(fx.Folder(stranger).Exports, "clip-MJPEG.avi"), Encoding.ASCII.GetBytes("RIFF theirs"), fx.Ct);
|
||
|
||
// Another index moves the folder away, the leftovers along, then the other sequence into the folder it left; this
|
||
// index's scan finds both before the job resumes.
|
||
var (server, archive) = await fx.Archive.OtherWriterAsync();
|
||
var plan = await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct);
|
||
await server.ApplyRenameAsync(plan, null, fx.Ct);
|
||
await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger.Id], sequence.Folder, null, fx.Ct), null, fx.Ct);
|
||
await fx.Archive.ScanAsync();
|
||
var before = ArchiveFixture.FilesOf(fx.Folder(sequence).Folder);
|
||
await fx.StartEngineAsync();
|
||
|
||
var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg, 96, 64),
|
||
new RenderCheckpoint([], 0, output, named ? sequence.Folder : null).ToJson());
|
||
await fx.WaitForAsync(job.Id, JobState.Done);
|
||
|
||
Assert.SequenceEqual(before, ArchiveFixture.FilesOf(fx.Folder(sequence).Folder), $"{named}: the other sequence's files are untouched");
|
||
// Its leftovers are removed where the folder took them when the checkpoint says where it chose the output, and
|
||
// stay otherwise: the render then takes another name.
|
||
var moved = fx.Archive.Paths.Sequence(plan.Steps.Single().ToFolder).Exports;
|
||
Assert.SequenceEqual(named ? ["clip-MJPEG.avi"] : [".clip-MJPEG.avi.0badf00d.tmp", "clip-MJPEG (2).avi", "clip-MJPEG.avi"], Entries(moved), named.ToString());
|
||
var rendered = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).Single().OutputPath;
|
||
Assert.Equal(plan.Steps.Single().ToFolder + (named ? "/exports/clip-MJPEG.avi" : "/exports/clip-MJPEG (2).avi"), rendered);
|
||
Assert.Equal("RIFF", Encoding.ASCII.GetString((await File.ReadAllBytesAsync(fx.Archive.Paths.FromRelative(rendered), fx.Ct))[..4]));
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public async Task ConcurrentRendersOfOnePresetKeepBothOutputs()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
await fx.StartEngineAsync(workers: 2);
|
||
|
||
var first = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
var second = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64));
|
||
await fx.WaitForAsync(first.Id, JobState.Done);
|
||
await fx.WaitForAsync(second.Id, JobState.Done);
|
||
|
||
Assert.SequenceEqual(["clip-MJPEG (2).avi", "clip-MJPEG.avi"], Entries(fx.Folder(sequence).Exports));
|
||
var renders = await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct);
|
||
Assert.Equal(2, renders.Select(r => r.OutputPath).Distinct().Count());
|
||
}
|
||
|
||
[Test]
|
||
public void ANameBeingWrittenIsNotPickedAgain()
|
||
{
|
||
var folder = context.CreateTempDirectory("exports");
|
||
var name = new ExportNameContext { Date = new DateTime(2026, 6, 1), Title = "Roof", PresetName = "MJPEG", Codec = VideoCodec.Mjpeg };
|
||
using var a = new OutputNames();
|
||
using var b = new OutputNames();
|
||
var first = a.Reserve(taken => ExportNaming.OutputPath(folder, "{title}", name, taken));
|
||
var second = b.Reserve(taken => ExportNaming.OutputPath(folder, "{title}", name, taken));
|
||
Assert.Equal((Path.Combine(folder, "Roof.avi"), Path.Combine(folder, "Roof (2).avi")), (first, second));
|
||
Assert.False(b.TryReserve(first), "held by the first render");
|
||
|
||
a.Dispose();
|
||
using var c = new OutputNames();
|
||
Assert.Equal(first, c.Reserve(taken => ExportNaming.OutputPath(folder, "{title}", name, taken)));
|
||
}
|
||
|
||
[Test]
|
||
public void RenderRowIdsAreStablePerJobAndEntry()
|
||
{
|
||
var job = Guid.CreateVersion7();
|
||
var id = Chronos.Data.Processing.Jobs.RenderJobHandler.RenderId(job, 0);
|
||
Assert.Equal(id, Chronos.Data.Processing.Jobs.RenderJobHandler.RenderId(job, 0));
|
||
Assert.NotEqual(id, Chronos.Data.Processing.Jobs.RenderJobHandler.RenderId(job, 1));
|
||
Assert.NotEqual(id, Chronos.Data.Processing.Jobs.RenderJobHandler.RenderId(Guid.CreateVersion7(), 0));
|
||
Assert.Equal(8, id.Version);
|
||
}
|
||
|
||
[Test]
|
||
public async Task AServerTakesOnlyTheRendersItsManagedEncodersProduce()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var server = new ProcessingService(fx.Db, new ProcessingOptions { Host = EncoderHost.Server, AwaitsRenderNode = (_, _, _) => Task.FromResult(true) });
|
||
var handler = Assert.NotNull(server.CreateJobHandlers().Single(h => h.Kind == JobKind.Render) as ISelectiveJobHandler);
|
||
var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic" };
|
||
Job Job(ExportSettings export) => new() { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = ProcessingJobs.Render(sequence, export, 96, 64).ParametersJson };
|
||
async Task<bool> AcceptsAsync(string? parametersJson) =>
|
||
await handler.AcceptsAsync(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = parametersJson }, fx.Ct);
|
||
|
||
Assert.True(await handler.AcceptsAsync(Job(Mjpeg with { Batch = ["png-sequence", "gif-preview"] }), fx.Ct), "managed outputs only");
|
||
Assert.False(await handler.AcceptsAsync(Job(Hevc), fx.Ct), "HEVC waits for a render node");
|
||
Assert.False(await handler.AcceptsAsync(Job(Mjpeg with { Batch = ["1080p-h264"] }), fx.Ct), "one MP4 in the batch");
|
||
Assert.True(await handler.AcceptsAsync(Job(Hevc) with { Checkpoint = """{"done":[],"pending":0}""" }, fx.Ct), "started here: resumes here");
|
||
Assert.True(await AcceptsAsync("{}"), "unreadable: fails with its reason");
|
||
Assert.True(await AcceptsAsync(WithPreset("""{"preset":{},"Preset":{}}""")), "a member given twice: fails with its reason");
|
||
Assert.True(await AcceptsAsync(WithPreset("""{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"batch":null}""")), "a null batch is no batch");
|
||
|
||
var client = new ProcessingService(fx.Db).CreateJobHandlers().Single(h => h.Kind == JobKind.Render);
|
||
Assert.False(client is ISelectiveJobHandler, "a client renders whatever it is given");
|
||
}
|
||
|
||
[Test]
|
||
public async Task AServerTakesMp4JobsOnceNoRenderNodeCanAndOnlyThen()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic" };
|
||
var job = new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = ProcessingJobs.Render(sequence, Hevc, 96, 64).ParametersJson };
|
||
async Task<bool> AcceptsAsync(Func<Job, Chronos.Protocol.RenderJobParameters, CancellationToken, Task<bool>>? awaits)
|
||
{
|
||
var server = new ProcessingService(fx.Db, new ProcessingOptions { Host = EncoderHost.Server, AwaitsRenderNode = awaits });
|
||
return await ((ISelectiveJobHandler)server.CreateJobHandlers().Single(h => h.Kind == JobKind.Render)).AcceptsAsync(job, fx.Ct);
|
||
}
|
||
|
||
Chronos.Protocol.RenderJobParameters? asked = null;
|
||
Assert.True(await AcceptsAsync((_, p, _) => { asked = p; return Task.FromResult(false); }), "no node can take it");
|
||
Assert.Equal(("hevc", 96, 64), (asked!.Codec, asked.Width, asked.Height));
|
||
Assert.False(await AcceptsAsync(null), "without a node check, MP4 jobs always wait");
|
||
Assert.False(await AcceptsAsync((_, _, _) => throw new InvalidOperationException("database unreachable")), "unknown: keeps waiting");
|
||
}
|
||
|
||
[Test]
|
||
public async Task AServerRendersAsMjpegWhatNoRenderNodeTookAndSaysSo()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context, o => o with { Host = EncoderHost.Server, AwaitsRenderNode = (_, _, _) => Task.FromResult(false) });
|
||
var sequence = await fx.AddAsync(Scene());
|
||
await fx.StartEngineAsync();
|
||
|
||
var request = ProcessingJobs.Render(sequence, Hevc, 96, 64);
|
||
var job = await fx.WaitForAsync((await fx.EnqueueAsync(request)).Id, JobState.Done);
|
||
|
||
var avi = await File.ReadAllBytesAsync(Path.Combine(fx.Folder(sequence).Exports, "clip-MJPEG.avi"), fx.Ct);
|
||
Assert.Equal(("RIFF", "AVI "), (Encoding.ASCII.GetString(avi, 0, 4), Encoding.ASCII.GetString(avi, 8, 4)));
|
||
var render = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).Single();
|
||
var preset = Loc.L("Export.Preset.Custom");
|
||
Assert.Equal((preset, "Mjpeg", 96, 64), (render.PresetName, render.Codec, render.Width, render.Height));
|
||
Assert.Contains(Loc.L("Export.Log.NoRenderNode", preset, "HEVC", "MJPEG"), job.LogTail);
|
||
}
|
||
|
||
[Test]
|
||
public void ABatchForAServerBecomesOneJobPerPreset()
|
||
{
|
||
var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic", Title = "Roof" };
|
||
var jobs = ProcessingJobs.RenderEach(sequence, Mjpeg with { Batch = ["mjpeg-avi", "gif-preview", "GIF-preview", "4k-hevc"] }, 96, 64);
|
||
var parameters = jobs.Select(j => System.Text.Json.JsonSerializer.Deserialize(j.ParametersJson!, Chronos.Protocol.ProtocolJson.Default.RenderJobParameters)!).ToList();
|
||
Assert.SequenceEqual(["mjpeg", "gif", "hevc"], parameters.Select(p => p.Codec));
|
||
Assert.True(jobs.All(j => j.Kind == JobKind.Render && j.Targets.SequenceEqual([sequence.Id])), "render jobs of the sequence");
|
||
Assert.True(parameters.All(p => ProcessingJobs.ReadExport(p.PresetJson).Batch.Count == 0), "no job carries a batch");
|
||
Assert.Equal((3840, 2160), (parameters[2].Width, parameters[2].Height));
|
||
|
||
// A posted batch written by hand may hold blank entries: they name no preset.
|
||
var posted = System.Text.Json.JsonSerializer.Deserialize(WithPreset("""{"preset":{"isAuto":false,"manual":"mjpeg-avi"},"batch":[null," ","gif-preview"]}"""),
|
||
Chronos.Protocol.ProtocolJson.Default.RenderJobParameters)!;
|
||
Assert.SequenceEqual(["mjpeg", "gif"], ProcessingJobs.Split(posted, 96, 64).Select(p => p.Codec));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Owner review 1, phase 4: a render job carries the output size its settings give it (the chosen proportions win over a
|
||
/// fixed-size preset, a quarter turn swaps a source-sized output) and the settings format its render needs, so a render
|
||
/// node is matched to what it will write; a job posted by an older client gets both from the server (<see cref="ProcessingJobs.Split"/>).
|
||
/// </summary>
|
||
[Test]
|
||
public void RenderJobsCarryTheSizeAndFormatOfTheirSettings()
|
||
{
|
||
var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic", Title = "Roof" };
|
||
var uhd = new ExportSettings { Preset = new Auto<string>().WithManual("4k-h264") };
|
||
var portrait = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto<string>().WithManual("9:16") } };
|
||
static Chronos.Protocol.RenderJobParameters Read(Chronos.Data.Archiving.Jobs.ArchiveJobRequest request) => ProcessingJobs.ReadRender(request.ParametersJson).Parameters;
|
||
|
||
var adapted = Read(ProcessingJobs.Render(sequence, uhd, 6000, 4000, portrait));
|
||
Assert.Equal((2160, 3840, 2), (adapted.Width, adapted.Height, adapted.RequiredSettingsFormat));
|
||
var source = Read(ProcessingJobs.Render(sequence, uhd, 6000, 4000, new ProjectSettings()));
|
||
Assert.Equal((3840, 2160, 1), (source.Width, source.Height, source.RequiredSettingsFormat));
|
||
// A source-sized output turns with the picture; the turn needs format 2.
|
||
var png = new ExportSettings { Preset = new Auto<string>().WithManual("png-sequence") };
|
||
var turned = Read(ProcessingJobs.Render(sequence, png, 6000, 4000, new ProjectSettings { Camera = new CameraSettings { Rotate = 90 } }));
|
||
Assert.Equal((4000, 6000, 2), (turned.Width, turned.Height, turned.RequiredSettingsFormat));
|
||
// The sequence's own settings when the job embeds none.
|
||
var own = Read(ProcessingJobs.Render(sequence with { SettingsJson = portrait.ToJson() }, uhd, 6000, 4000));
|
||
Assert.Equal((2160, 3840, 2), (own.Width, own.Height, own.RequiredSettingsFormat));
|
||
|
||
// Posted by an older client (the preset's size, no format) with a batch: the server sizes each job for the settings.
|
||
var posted = Read(ProcessingJobs.Render(sequence, uhd with { Batch = ["1080p-h264"] }, 6000, 4000)) with { SettingsJson = portrait.ToJson() };
|
||
Assert.Equal((3840, 2160, 1), (posted.Width, posted.Height, posted.RequiredSettingsFormat));
|
||
var split = ProcessingJobs.Split(posted, 6000, 4000, portrait);
|
||
Assert.SequenceEqual([(2160, 3840, 2), (1080, 1920, 2)], split.Select(p => (p.Width, p.Height, p.RequiredSettingsFormat)));
|
||
Assert.Equal(split[0], ProcessingJobs.Routed(split[0], portrait, 6000, 4000), "a size already adapted stays");
|
||
// The sequence's settings change between posting and routing: the size comes from the preset again, never from the
|
||
// size a newer client already adapted (2160×2160 for 1:1 would adapt to 2160×1215 for 16:9).
|
||
var square = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto<string>().WithManual("1:1") } };
|
||
var wide = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto<string>().WithManual("16:9") } };
|
||
var squared = Read(ProcessingJobs.Render(sequence, uhd, 6000, 4000, square));
|
||
Assert.Equal((2160, 2160), (squared.Width, squared.Height));
|
||
var rerouted = ProcessingJobs.Routed(squared, wide, 6000, 4000);
|
||
Assert.Equal((3840, 2160), (rerouted.Width, rerouted.Height), "the preset's box adapted to the new aspect");
|
||
var tall = Read(ProcessingJobs.Render(sequence, uhd, 6000, 4000, new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto<string>().WithManual("4:5") } }));
|
||
Assert.Equal((2160, 2700), (tall.Width, tall.Height));
|
||
Assert.Equal((3840, 2160), (ProcessingJobs.Routed(tall, wide, 6000, 4000).Width, ProcessingJobs.Routed(tall, wide, 6000, 4000).Height));
|
||
Assert.Equal((3840, 2160, 1), ProcessingJobs.Split(posted, 6000, 4000).Select(p => (p.Width, p.Height, p.RequiredSettingsFormat)).First(),
|
||
"settings that cannot be read keep the size the job was posted with");
|
||
// What the desktop asks of a server before a render: the highest format of the export and its batch.
|
||
Assert.Equal(1, ProcessingJobs.RequiredFormat(portrait, png, 6000, 4000), "a source-sized output keeps the proportions");
|
||
Assert.Equal(2, ProcessingJobs.RequiredFormat(portrait, png with { Batch = ["4k-h264"] }, 6000, 4000));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Owner review 1, phase 4, end to end: a turned, portrait project with a look renders each output at the size its job
|
||
/// was routed with (the fixed box adapted to 9:16, the source-sized output on the turned view) and records it so.
|
||
/// </summary>
|
||
[Test]
|
||
public async Task ATurnedPortraitProjectRendersAtTheSizeItsJobWasRoutedWith()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
await fx.StartEngineAsync();
|
||
|
||
var settings = new ProjectSettings
|
||
{
|
||
Camera = new CameraSettings { Aspect = new Auto<string>().WithManual("9:16"), Rotate = 90, Straighten = 2 },
|
||
Look = new LookSettings { Filter = "sepia", Strength = 0.6 },
|
||
};
|
||
var request = ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["png-sequence"] }, 96, 64, settings);
|
||
var routed = ProcessingJobs.ReadRender(request.ParametersJson).Parameters;
|
||
Assert.Equal((54, 96, 2), (routed.Width, routed.Height, routed.RequiredSettingsFormat));
|
||
await fx.WaitForAsync((await fx.EnqueueAsync(request)).Id, JobState.Done);
|
||
|
||
var renders = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).OrderBy(r => r.OutputPath, StringComparer.Ordinal).ToList();
|
||
Assert.SequenceEqual([(54, 96), (54, 96)], renders.Select(r => (r.Width, r.Height)));
|
||
var pngs = Directory.GetFiles(Path.Combine(fx.Folder(sequence).Exports, "clip-PNG")).Order().ToList();
|
||
Assert.Equal(Frames, pngs.Count);
|
||
using var decoded = DecoderFactory.CreateServer().Decode(new DecodeRequest(pngs[^1]));
|
||
Assert.Equal((54, 96), (Assert.NotNull(decoded).Pixels.Width, decoded.Pixels.Height));
|
||
}
|
||
|
||
/// <summary>Settings of a newer Chronos fail the render with the reason in the user's language, never as an English message.</summary>
|
||
[Test]
|
||
public async Task AnOverFormatRenderFailsSayingANewerChronosIsNeeded()
|
||
{
|
||
await using var fx = await ProcessingFixture.CreateAsync(context);
|
||
var sequence = await fx.AddAsync(Scene());
|
||
await fx.StartEngineAsync();
|
||
|
||
var parameters = ProcessingJobs.ReadRender(ProcessingJobs.Render(sequence, Mjpeg, 96, 64).ParametersJson).Parameters with
|
||
{
|
||
SettingsJson = """{"version":3,"camera":{"rotate":90},"grade":{"lut":"teal"}}""",
|
||
};
|
||
var request = new Chronos.Data.Archiving.Jobs.ArchiveJobRequest(JobKind.Render, [sequence.Id], "newer",
|
||
System.Text.Json.JsonSerializer.Serialize(parameters, Chronos.Protocol.ProtocolJson.Default.RenderJobParameters), JobPriority.User);
|
||
Assert.Equal(3, ProcessingJobs.ReadRender(ProcessingJobs.Render(sequence, Mjpeg, 96, 64,
|
||
ProjectSettings.FromJson(parameters.SettingsJson, allowNewer: true)).ParametersJson).Parameters.RequiredSettingsFormat, "routed to none older");
|
||
var failed = await fx.WaitForAsync((await fx.EnqueueAsync(request)).Id, JobState.Failed);
|
||
Assert.Equal(Loc.L("Errors.Render.NewerSettings"), failed.Error);
|
||
Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct));
|
||
}
|
||
|
||
/// <summary>MJPEG job parameters whose preset JSON is <paramref name="presetJson"/>.</summary>
|
||
private static string WithPreset(string presetJson) => System.Text.Json.JsonSerializer.Serialize(
|
||
new Chronos.Protocol.RenderJobParameters("MJPEG", presetJson, "mjpeg", 96, 64, false, null), Chronos.Protocol.ProtocolJson.Default.RenderJobParameters);
|
||
|
||
private static Render RecordedRender(Sequence sequence, Guid id) => new()
|
||
{
|
||
Id = id,
|
||
SequenceId = sequence.Id,
|
||
PresetName = "MJPEG",
|
||
OutputPath = "Synthetic/exports/clip-MJPEG.avi",
|
||
Created = DateTimeOffset.UtcNow,
|
||
};
|
||
|
||
private static List<string> Entries(string folder) =>
|
||
Directory.Exists(folder) ? [.. Directory.EnumerateFileSystemEntries(folder).Select(e => Path.GetFileName(e)).Order(StringComparer.Ordinal)] : [];
|
||
|
||
/// <summary>The engine marks a job cancelled before its handler has unwound; wait until the worker let it go.</summary>
|
||
private static async Task WaitUntilIdleAsync(ProcessingFixture fx, Guid jobId)
|
||
{
|
||
var until = DateTime.UtcNow.AddSeconds(30);
|
||
while (fx.Engine.RunningJobIds.Contains(jobId))
|
||
{
|
||
Assert.True(DateTime.UtcNow < until, "the render did not stop");
|
||
await Task.Delay(20, fx.Ct);
|
||
}
|
||
}
|
||
}
|