Files
Alby96andClaude Opus 5.5 728ffa35cb
CI / Build and test (push) Successful in 9m41s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 9s
Release / Build, test and publish (push) Successful in 14m49s
CI / PostgreSQL 16 integration (push) Successful in 8m51s
CI / PostgreSQL 17 integration (push) Successful in 9m48s
CI / Docker image (push) Successful in 54s
Release / Server image (push) Successful in 1m39s
feat: export panel and Render menu, playback options, videos library (owner review 1 phase 5) (#27)
Owner review 1 R3, R8, R9. A grouped Export step and Render menu; encoding, playback (reverse, boomerang, loops, fades, hold) and still frames; one videos library on the desktop and the server with a verified trash and copies to a videos folder.

Closes #21

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-11-05 09:18:40 +01:00

782 lines
42 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using Chronos.Core.Export;
using Chronos.Core.Project;
using Chronos.Core.Video;
using Chronos.Testing;
namespace Chronos.Core.Tests.Project;
public sealed class ProjectSettingsTests
{
[Test]
public void JsonRoundTripKeepsAutoAndManualValues()
{
var settings = new ProjectSettings
{
Exposure = new ExposureSettings
{
DeflickerWindow = new Auto<int>().WithAdvice(41, "Advisor.Reason.FlickerPeriod", "10.2"),
DeflickerStrength = new Auto<double>().WithManual(0.8),
},
Timing = new TimingSettings { FrameRate = new Auto<string>().WithAdvice("24", null) },
ExcludedFrames = [3, 7],
};
var back = ProjectSettings.FromJson(settings.ToJson());
Assert.Equal(41, back.Exposure.DeflickerWindow.Resolve(0));
Assert.True(back.Exposure.DeflickerWindow.IsAuto);
Assert.Equal("Advisor.Reason.FlickerPeriod", back.Exposure.DeflickerWindow.ReasonKey);
Assert.Equal(0.8, back.Exposure.DeflickerStrength.Resolve(1.0));
Assert.False(back.Exposure.DeflickerStrength.IsAuto);
Assert.SequenceEqual(new[] { 3, 7 }, back.ExcludedFrames);
Assert.Contains("\"deflickerWindow\"", settings.ToJson());
}
[Test]
public void ValueTypesFallBackOnlyWithoutAdvice()
{
Assert.Equal(21, new Auto<int>().Resolve(21));
Assert.Equal(FlowQualitySetting.Balanced, new Auto<FlowQualitySetting>().Resolve(FlowQualitySetting.Balanced));
Assert.Equal(0, new Auto<int>().WithAdvice(0, null).Resolve(21));
Assert.False(new Auto<bool>().WithAdvice(false, null).Resolve(true));
Assert.Equal(0.5, new Auto<double>().WithAdvice(0.8, null).WithManual(0.5).Resolve(1.0));
Assert.False(new Auto<bool>().WithManual(false).Resolve(true));
var back = ProjectSettings.FromJson(new ProjectSettings
{
Exposure = new ExposureSettings { Deflicker = new Auto<bool>().WithAdvice(false, null) },
}.ToJson());
Assert.False(back.Exposure.Deflicker.Resolve(true));
Assert.True(ProjectSettings.FromJson(new ProjectSettings().ToJson()).Exposure.Deflicker.Resolve(true));
}
[Test]
public void ResetReturnsToAdvice()
{
var a = new Auto<int>().WithAdvice(41, null).WithManual(15);
Assert.Equal(15, a.Resolve(0));
Assert.Equal(41, a.Reset().Resolve(0));
}
[Test]
public void NewerVersionIsRefused() =>
Assert.Throws<InvalidDataException>(() => ProjectSettings.FromJson("{\"version\": 99}"));
[Test]
public void MissingMembersKeepTheirDefaults()
{
var defaults = new ProjectSettings().ToJson();
Assert.Equal(defaults, ProjectSettings.FromJson("{}").ToJson());
Assert.Equal(defaults, ProjectSettings.FromJson("null").ToJson());
// An API client's partial edit: one manual value, a section given as null, keys in another casing.
var partial = ProjectSettings.FromJson(
"""{ "Exposure": { "deflicker": { "isAuto": false, "manual": false } }, "motion": null, "export": { "preset": { "isAuto": false, "manual": "4k-hevc" } } }""");
Assert.False(partial.Exposure.Deflicker.Resolve(true));
Assert.True(partial.Exposure.HolyGrail.IsAuto);
Assert.Equal(0.9, partial.Exposure.HighlightKnee);
Assert.True(partial.Motion.Stabilize.IsAuto);
Assert.Equal("4k-hevc", partial.Export.Preset.Resolve("1080p-h264"));
Assert.Equal("{date} {title} - {preset}", partial.Export.NameTemplate);
Assert.SequenceEqual(new[] { 0.0, 1.0 }, partial.Timing.RemapCurve.Select(p => p.X));
Assert.Equal(9, partial.Stack.Length);
Assert.Equal(ProjectSettings.BaseVersion, partial.Version);
// An explicit null clears a nullable value; arrays are replaced, not merged.
var cleared = ProjectSettings.FromJson("""{ "exposure": { "highlightKnee": null }, "timing": { "remapCurve": [ { "x": 0, "y": 0.5 } ] } }""");
Assert.Null(cleared.Exposure.HighlightKnee);
Assert.Equal(1, cleared.Timing.RemapCurve.Count);
}
[Test]
public void NullHighlightKneeSurvivesTheRoundTrip()
{
// "No knee, hard clip" must not come back as the default knee when the project is rewritten.
var off = new ProjectSettings { Exposure = new ExposureSettings { HighlightKnee = null } };
Assert.Contains("\"highlightKnee\": null", off.ToJson());
Assert.Null(ProjectSettings.FromJson(off.ToJson()).Exposure.HighlightKnee);
Assert.Equal(0.9, ProjectSettings.FromJson(new ProjectSettings().ToJson()).Exposure.HighlightKnee);
}
[Test]
public void NullListsAndTextsKeepTheirDefaults()
{
var project = ProjectSettings.FromJson(
"""{ "excludedFrames": null, "export": { "batch": null, "nameTemplate": null }, "timing": { "remapCurve": null }, "camera": { "keyframes": null } }""");
Assert.Count(0, project.ExcludedFrames);
Assert.Count(0, project.Export.Batch);
Assert.Equal("{date} {title} - {preset}", project.Export.NameTemplate);
Assert.Count(2, project.Timing.RemapCurve);
Assert.Count(0, project.Camera.Keyframes);
// Nullable members without a default still clear.
Assert.Null(ProjectSettings.FromJson("""{ "export": { "folder": null }, "heroFrame": null }""").HeroFrame);
}
[Test]
public void DuplicateKeysAreAJsonError()
{
Assert.Throws<System.Text.Json.JsonException>(() => ProjectSettings.FromJson("""{ "version": 1, "version": 1 }"""));
Assert.Throws<System.Text.Json.JsonException>(() => ProjectSettings.FromJson("""{ "Export": {}, "export": {} }"""));
Assert.Throws<System.Text.Json.JsonException>(() => ProjectSettings.FromJson("""{ "export": { "batch": [], "Batch": [] } }"""));
}
[Test]
public void ProjectMustBeAnObject() =>
Assert.Throws<System.Text.Json.JsonException>(() => ProjectSettings.FromJson("[1, 2]"));
[Test]
public void FramePositionsFollowInsertedFramesAndOtherMembersStay()
{
var project = new ProjectSettings
{
ExcludedFrames = [3, 7, 40],
HeroFrame = 2,
Camera = new CameraSettings { Keyframes = [new CameraKey(0, 0.5, 0.5, 1, 0), new CameraKey(7, 0.4, 0.5, 1.5, 0)] },
Exposure = new ExposureSettings { DeflickerWindow = new Auto<int>().WithManual(41) },
};
// Two frames inserted before position 3 and one before position 7; 40 is no frame of the old list and stays.
var moves = new Dictionary<int, int> { [0] = 0, [1] = 1, [2] = 4, [3] = 5, [4] = 6, [5] = 7, [6] = 8, [7] = 10 };
var moved = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.MoveFramePositions(project.ToJson(), moves)));
Assert.SequenceEqual([5, 10, 40], moved.ExcludedFrames);
Assert.Equal(4, moved.HeroFrame);
Assert.SequenceEqual([0, 10], moved.Camera.Keyframes.Select(k => k.Frame));
Assert.Equal((0.4, 1.5), (moved.Camera.Keyframes[1].CenterX, moved.Camera.Keyframes[1].Zoom));
Assert.Equal(41, moved.Exposure.DeflickerWindow.Manual);
}
[Test]
public void MovingPositionsEditsTheJsonInPlace()
{
const string project = """{ "ExcludedFrames": [1, 2], "heroFrame": null, "futureOption": { "keep": [1, 2] }, "camera": { "keyframes": [ { "frame": 1.5 } ] } }""";
var moved = Assert.NotNull(ProjectSettings.MoveFramePositions(project, new Dictionary<int, int> { [1] = 3 }));
var json = System.Text.Json.Nodes.JsonNode.Parse(moved)!;
Assert.SequenceEqual([3, 2], json["ExcludedFrames"]!.AsArray().Select(n => n!.GetValue<int>()));
Assert.Equal("""{"keep":[1,2]}""", json["futureOption"]!.ToJsonString());
Assert.Null(json["heroFrame"]);
Assert.Equal(1.5, json["camera"]!["keyframes"]![0]!["frame"]!.GetValue<double>());
}
[Test]
public void NothingToMoveGivesNoNewProject()
{
Assert.Null(ProjectSettings.MoveFramePositions(new ProjectSettings { ExcludedFrames = [1] }.ToJson(), new Dictionary<int, int>()));
Assert.Null(ProjectSettings.MoveFramePositions(new ProjectSettings { ExcludedFrames = [1] }.ToJson(), new Dictionary<int, int> { [2] = 3, [1] = 1 }));
Assert.Null(ProjectSettings.MoveFramePositions("not json", new Dictionary<int, int> { [1] = 2 }));
Assert.Null(ProjectSettings.MoveFramePositions("[1, 2]", new Dictionary<int, int> { [1] = 2 }));
Assert.Null(ProjectSettings.MoveFramePositions("""{ "heroFrame": 1, "HeroFrame": 1 }""", new Dictionary<int, int> { [1] = 2 }));
}
[Test]
public void AnEditorsPositionsFollowFramesInsertedUnderItAsTheIndexMovedTheStoredOnes()
{
// An editor read four frames; a download then inserted two earlier photos, one of which an exclusion waited for.
var photos = Enumerable.Range(0, 6).Select(Photo).ToList();
var ids = Enumerable.Range(0, 6).Select(_ => Guid.CreateVersion7()).ToList();
IReadOnlyList<Guid> before = ids[2..];
var after = ids.Select((id, i) => new Chronos.Core.Model.Frame
{
Id = id,
SequenceId = Guid.Empty,
Index = i,
RelativePath = $"s/IMG_{i}.JPG",
FileName = $"IMG_{i}.JPG",
Sha256 = photos[i].Sha256,
Size = photos[i].Size,
CapturedAt = photos[i].CapturedAt,
}).ToList();
var project = new ProjectSettings
{
ExcludedFrames = [1, 3],
HeroFrame = 0,
Camera = new CameraSettings { Keyframes = [new CameraKey(2, 0.5, 0.5, 1, 0)] },
Exposure = new ExposureSettings { DeflickerWindow = new Auto<int>().WithManual(41) },
PendingFrames = [new PendingFrame { Sha256 = photos[1].Sha256, Size = photos[1].Size, Excluded = true }],
};
var followed = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.FollowFrames(project.ToJson(), before, after)));
Assert.SequenceEqual([1, 3, 5], followed.ExcludedFrames);
Assert.Equal(2, followed.HeroFrame);
Assert.SequenceEqual([4], followed.Camera.Keyframes.Select(k => k.Frame));
Assert.Equal(41, followed.Exposure.DeflickerWindow.Manual);
Assert.Null(followed.PendingFrames);
// The same frames: nothing moves. A frame the editor read that is gone: positions stay, as the index leaves them.
Assert.Null(ProjectSettings.FollowFrames(new ProjectSettings { ExcludedFrames = [1] }.ToJson(), ids, after));
var removed = after.Where(f => f.Id != ids[3]).Select((f, i) => f with { Index = i }).ToList();
Assert.Null(ProjectSettings.FollowFrames(new ProjectSettings { ExcludedFrames = [1, 3] }.ToJson(), before, removed));
}
[Test]
public void PositionsCrossToAnotherCopyByPhotoAndWaitForPhotosItLacks()
{
// The server holds six photos; this copy only the last four, and one of its own the server lacks.
var photos = Enumerable.Range(0, 7).Select(Photo).ToList();
var server = Frames(photos[..6]);
var here = Frames([.. photos[2..6], photos[6]]);
var project = new ProjectSettings
{
ExcludedFrames = [0, 3],
HeroFrame = 1,
Camera = new CameraSettings { Keyframes = [new CameraKey(0, 0.5, 0.5, 1, 0), new CameraKey(4, 0.4, 0.5, 1.5, 0)] },
Exposure = new ExposureSettings { DeflickerWindow = new Auto<int>().WithManual(41) },
};
var taken = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(project.ToJson(), server, here)));
Assert.SequenceEqual([1], taken.ExcludedFrames);
Assert.Null(taken.HeroFrame);
Assert.SequenceEqual([2], taken.Camera.Keyframes.Select(k => k.Frame));
Assert.Equal(1.5, taken.Camera.Keyframes[0].Zoom);
Assert.Equal(41, taken.Exposure.DeflickerWindow.Manual);
var pending = Assert.NotNull(taken.PendingFrames);
Assert.Equal(2, pending.Count);
var first = Assert.Contains(pending, p => p.Sha256 == photos[0].Sha256);
Assert.True(first.Excluded && !first.Hero);
Assert.Count(1, first.Keyframes);
Assert.Equal(0.5, first.Keyframes[0].CenterX);
Assert.True(Assert.Contains(pending, p => p.Sha256 == photos[1].Sha256).Hero);
Assert.True(taken.HeroPending);
// The two photos arrive (inserted before the others): what waited takes its place, and the rest moved with its frames.
var arrived = Frames(photos);
var moved = ProjectSettings.MoveFramePositions(taken.ToJson(), new Dictionary<int, int> { [0] = 2, [1] = 3, [2] = 4, [3] = 5, [4] = 6 })!;
var placed = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(moved, null, arrived)));
Assert.SequenceEqual([0, 3], placed.ExcludedFrames);
Assert.Equal(1, placed.HeroFrame);
Assert.SequenceEqual([0, 4], placed.Camera.Keyframes.Select(k => k.Frame));
Assert.Null(placed.PendingFrames);
Assert.Null(ProjectSettings.TranslateFramePositions(placed.ToJson(), null, arrived));
}
[Test]
public void SettingsSentBackLandOnTheSamePhotos()
{
var photos = Enumerable.Range(0, 5).Select(Photo).ToList();
var server = Frames(photos[1..]);
var here = Frames(photos);
// Photo 0 is only here: its exclusion waits on the server, and comes back as a position.
var project = new ProjectSettings { ExcludedFrames = [0, 2], HeroFrame = 4 };
var sent = Assert.NotNull(ProjectSettings.TranslateFramePositions(project.ToJson(), here, server));
var back = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(sent, server, here)));
Assert.SequenceEqual([1], ProjectSettings.FromJson(sent).ExcludedFrames);
Assert.Equal(3, ProjectSettings.FromJson(sent).HeroFrame);
Assert.Equal(project.ToJson(), back.ToJson());
}
[Test]
public void AHeroOrKeyframeChosenSinceIsNewerThanTheOneThatWaited()
{
var photos = Enumerable.Range(0, 3).Select(Photo).ToList();
var waiting = new ProjectSettings
{
HeroFrame = 2,
Camera = new CameraSettings { Keyframes = [new CameraKey(0, 0.2, 0.2, 2, 0)] },
PendingFrames = [new PendingFrame { Sha256 = photos[0].Sha256, Size = photos[0].Size, Hero = true, Keyframes = [new CameraKey(9, 0.7, 0.7, 1, 0)] }],
};
var placed = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(waiting.ToJson(), null, Frames(photos))));
Assert.Equal(2, placed.HeroFrame);
Assert.Count(1, placed.Camera.Keyframes);
Assert.Equal(0.2, placed.Camera.Keyframes[0].CenterX);
Assert.Null(placed.PendingFrames);
}
[Test]
public void AHeroChosenSinceAnotherWaitedStaysTheHeroWhenItMustWaitToo()
{
// This PC chose photo 3 as the hero before the server had it, so it waits there; an editor on the server then
// chose photo 2, which this PC lacks.
var photos = Enumerable.Range(0, 4).Select(Photo).ToList();
var server = Frames(photos[..3]);
var here = Frames([photos[0], photos[1], photos[3]]);
var edited = new ProjectSettings
{
ExcludedFrames = [0],
HeroFrame = 2,
PendingFrames = [new PendingFrame { Sha256 = photos[3].Sha256, Size = photos[3].Size, CapturedAt = photos[3].CapturedAt, Hero = true }],
};
var taken = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(edited.ToJson(), server, here)));
Assert.Null(taken.HeroFrame);
Assert.SequenceEqual([0], taken.ExcludedFrames);
var waiting = Assert.NotNull(taken.PendingFrames);
Assert.Count(1, waiting);
Assert.True(waiting[0].Hero && waiting[0].Sha256 == photos[2].Sha256, "the newer hero waits for its photo");
Assert.True(taken.HeroPending);
// Its photo arrives: it is the hero again.
var arrived = Frames([photos[0], photos[1], photos[2], photos[3]]);
var moved = ProjectSettings.MoveFramePositions(taken.ToJson(), new Dictionary<int, int> { [2] = 3 }) ?? taken.ToJson();
var placed = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(moved, null, arrived)));
Assert.Equal(2, placed.HeroFrame);
Assert.Null(placed.PendingFrames);
// A hero chosen here while one waits clears the waiting one, even before its photo arrives.
var chosen = (taken with { HeroFrame = 1 }).ToJson();
var cleared = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(chosen, null, here)));
Assert.Equal(1, cleared.HeroFrame);
Assert.Null(cleared.PendingFrames);
}
[Test]
public void APhotoHeldTwiceKeepsEachCopysPositions()
{
// The server adopted a folder holding photo 1 twice ('IMG_0001.JPG', 'IMG_0001 (1).JPG'); this PC keeps it once.
var photos = Enumerable.Range(0, 3).Select(Photo).ToList();
var server = Frames([photos[0], photos[1], photos[1], photos[2]]);
var here = Frames(photos);
var project = new ProjectSettings
{
ExcludedFrames = [2],
HeroFrame = 2,
Camera = new CameraSettings { Keyframes = [new CameraKey(1, 0.1, 0.5, 1, 0), new CameraKey(2, 0.2, 0.5, 1, 0)] },
};
// The second copy, which the deep analysis flags as a duplicate, is excluded there: this PC still renders its only copy.
var taken = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(project.ToJson(), server, here)));
Assert.Empty(taken.ExcludedFrames);
Assert.Null(taken.HeroFrame);
Assert.SequenceEqual([1], taken.Camera.Keyframes.Select(k => k.Frame));
Assert.Equal(0.1, taken.Camera.Keyframes[0].CenterX);
var waiting = Assert.NotNull(taken.PendingFrames);
Assert.Count(1, waiting);
Assert.True(waiting[0] is { Excluded: true, Hero: true, Occurrence: 1 } && waiting[0].Sha256 == photos[1].Sha256);
Assert.Count(1, waiting[0].Keyframes);
Assert.Equal(0.2, waiting[0].Keyframes[0].CenterX);
Assert.Contains("\"occurrence\": 1", taken.ToJson());
// Sent back after an edit of something else, every position lands on the copy it named.
var edited = taken with { Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 } };
var back = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(edited.ToJson(), here, server)));
Assert.SequenceEqual([2], back.ExcludedFrames);
Assert.Equal(2, back.HeroFrame);
Assert.SequenceEqual([1, 2], back.Camera.Keyframes.Select(k => k.Frame));
Assert.SequenceEqual([0.1, 0.2], back.Camera.Keyframes.Select(k => k.CenterX));
Assert.Null(back.PendingFrames);
// Both copies excluded there: this PC excludes its copy, and the server gets both back.
var both = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(new ProjectSettings { ExcludedFrames = [1, 2] }.ToJson(), server, here)));
Assert.SequenceEqual([1], both.ExcludedFrames);
var excluded = Assert.NotNull(both.PendingFrames);
Assert.Count(1, excluded);
Assert.True(excluded[0] is { Excluded: true, Hero: false, Occurrence: 1 });
var returned = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(both.ToJson(), here, server)));
Assert.SequenceEqual([1, 2], returned.ExcludedFrames);
Assert.Null(returned.PendingFrames);
}
[Test]
public void TheCopiesOfAPhotoAreToldApartByTheirOrder()
{
var time = new DateTime(2026, 9, 28, 18, 0, 0);
var hashed = new FramePhoto(new string('a', 64), 100, time);
var other = new FramePhoto(new string('b', 64), 200, time);
var unhashed = new FramePhoto(null, 100, time);
// The frame at 3 has not been hashed yet: it may be a copy of the photo, or another photo of the same size taken in
// the same second. The frames with the photo's hash are its copies; size and capture time match the unhashed one.
var frames = Frames([other, hashed, other, unhashed, hashed]);
Assert.SequenceEqual([1, 4], new[] { 0, 1, 2 }.Select(n => frames.IndexOf(hashed, n)).OfType<int>());
Assert.Null(frames.IndexOf(hashed, 2));
Assert.SequenceEqual([1, 3, 4], new[] { 0, 1, 2 }.Select(n => frames.IndexOf(unhashed, n)).OfType<int>());
Assert.SequenceEqual([0, 0, 1, 1, 1], Enumerable.Range(0, 5).Select(frames.Occurrence));
Assert.Equal(0, frames.Occurrence(9));
Assert.Equal(2, frames.IndexOf(new FramePhoto(new string('B', 64), 0, null), 1));
// Without a frame holding its hash, a hashed photo is the frames not hashed yet with its size and capture time.
Assert.Equal(3, frames.IndexOf(new FramePhoto(new string('c', 64), 100, time)));
}
[Test]
public void APhotoNotHashedYetDoesNotTakeThePositionsOfAnotherWithItsSizeAndTime()
{
// Two photos of a burst share size and capture time (a RAW of constant size, no sub-second times). The server has
// not hashed the first yet; this PC has hashed both and does not have the third photo yet.
var time = new DateTime(2026, 9, 28, 18, 0, 0);
var (first, second) = (new FramePhoto(new string('a', 64), 100, time), new FramePhoto(new string('b', 64), 100, time));
var server = Frames([first with { Sha256 = null }, second, Photo(3)]);
var here = Frames([first, second]);
// The second photo excluded on the server is the second here, and back; the first stays the hero on both.
var project = new ProjectSettings { ExcludedFrames = [1, 2], HeroFrame = 0 };
var taken = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(project.ToJson(), server, here)));
Assert.SequenceEqual([1], taken.ExcludedFrames);
Assert.Equal(0, taken.HeroFrame);
var waiting = Assert.NotNull(taken.PendingFrames);
Assert.True(waiting is [{ Excluded: true, Occurrence: 0 }] && waiting[0].Sha256 == Photo(3).Sha256, "only the third photo waits");
var back = ProjectSettings.FromJson(Assert.NotNull(ProjectSettings.TranslateFramePositions(taken.ToJson(), here, server)));
Assert.SequenceEqual([1, 2], back.ExcludedFrames);
Assert.Equal(0, back.HeroFrame);
Assert.Null(back.PendingFrames);
// A copy that has not hashed its first frame still finds the second photo by its hash, not on that frame.
Assert.Equal(1, server.IndexOf(second));
Assert.Equal(0, server.Occurrence(1));
Assert.Equal(0, server.IndexOf(first));
}
[Test]
public void AProjectNamingNoFrameCrossesAsItIs()
{
var json = new ProjectSettings { Exposure = new ExposureSettings { DeflickerWindow = new Auto<int>().WithManual(41) } }.ToJson();
Assert.False(ProjectSettings.NamesFrames(json));
Assert.False(json.Contains("pendingFrames", StringComparison.OrdinalIgnoreCase), "an old project reads and writes as it did");
Assert.False(ProjectSettings.NamesFrames("not json"));
Assert.True(ProjectSettings.NamesFrames("""{ "HeroFrame": 0 }"""));
Assert.Null(ProjectSettings.TranslateFramePositions(json, Frames([Photo(1)]), Frames([Photo(2)])));
Assert.Null(ProjectSettings.TranslateFramePositions("[1]", null, Frames([])));
}
[Test]
public void PhotosMatchByHashElseBySizeAndCaptureTime()
{
var time = new DateTime(2026, 9, 28, 18, 0, 0, 123);
var hashed = new FramePhoto(new string('a', 64), 100, time);
Assert.True(hashed.Matches(new FramePhoto(new string('A', 64), 1, null)));
Assert.False(hashed.Matches(new FramePhoto(new string('b', 64), 100, time)));
Assert.True(hashed.Matches(new FramePhoto("", 100, time.AddTicks(9_999))));
Assert.False(hashed.Matches(new FramePhoto(null, 100, time.AddMilliseconds(1))));
Assert.False(new FramePhoto(null, 100, null).Matches(new FramePhoto(null, 100, null)));
var frames = Frames([new FramePhoto(null, 100, time), hashed]);
Assert.Equal(1, frames.IndexOf(new FramePhoto(new string('a', 64), 100, null)));
Assert.Equal(0, frames.IndexOf(new FramePhoto(null, 100, time)));
Assert.Null(frames.IndexOf(new FramePhoto(null, 101, time)));
}
private static FramePhoto Photo(int seed) =>
new(Convert.ToHexStringLower(System.Security.Cryptography.SHA256.HashData([(byte)seed])), 1000 + seed, new DateTime(2026, 9, 28, 18, 0, 0).AddSeconds(10 * seed));
private static FramePhotos Frames(IEnumerable<FramePhoto> photos) => new(photos.Select((p, i) => (i, p)));
[Test]
public void BuiltInPresetIdsAreUnique() =>
Assert.Equal(ExportPresets.BuiltIn.Count, ExportPresets.BuiltIn.Select(p => p.Id).Distinct().Count());
[Test]
public void BitRateFollowsBitsPerPixel()
{
var p = Assert.NotNull(ExportPresets.Find("4k-hevc10-archive"));
// 0.30 × 3840 × 2160 × 24 ≈ 59.7 Mb/s (archive budget); share presets use the codec default.
Assert.Equal(59_719_680L, p.EffectiveBitRate(3840, 2160, new Rational(24, 1)));
Assert.Equal(19_906_560L, ExportPresets.Find("4k-h264")!.EffectiveBitRate(3840, 2160, new Rational(24, 1)));
var s = p.ToEncodeSettings("out.mp4", 3840, 2160);
Assert.Equal(24, s.GopLength);
Assert.Equal(10, s.BitDepth);
}
/// <summary>
/// SHA-256 of the default project's canonical text, as format-1 builds write it: none of phase 4's members, version 1.
/// Builds before wrote it indented with the OS's line ends (CRLF on Windows, LF on Linux); this pin is of the CRLF text,
/// the hash such a Windows build stored.
/// </summary>
private const string DefaultProjectHash = "df0b0f50b113475ece3753a80df0be05cc281cdaa1fa08a73a438ea9161358e0";
/// <summary>SHA-256 of the same text with LF, as every build writes it now on every OS.</summary>
private const string DefaultProjectLfHash = "24e4c2d0379bfda6e42533d4687d69cca95bab72f2a49bd70e2fba267b66a3d1";
[Test]
public void ProjectsWithoutTheNewMembersKeepTheirTextAndHash()
{
var defaults = new ProjectSettings().ToJson();
Assert.False(defaults.Contains('\r', StringComparison.Ordinal), "line ends");
Assert.Equal(DefaultProjectLfHash, ProjectContent.Hash(ProjectContent.Canonical(defaults)));
// A version a Windows build stored before still names this text.
Assert.True(ProjectContent.MatchesHash(ProjectContent.Canonical(defaults), DefaultProjectHash));
Assert.Equal(DefaultProjectHash, ProjectContent.Hash(ProjectContent.Canonical(defaults).Replace("\n", "\r\n", StringComparison.Ordinal)));
// The old build wrote the OS's line ends (OldJson leaves NewLine unset): the same text but for those.
Assert.Equal(OldBuild.Write(new OldProject()).ReplaceLineEndings("\n"), defaults);
Assert.Contains("\"version\": 1", defaults);
foreach (var member in new[] { "rotate", "mirror", "flip", "straighten", "\"look\"" })
Assert.False(defaults.Contains(member, StringComparison.Ordinal), member);
// A project written by a format-1 build reads and writes back the same, byte for byte but for line ends.
var older = new ProjectSettings
{
Camera = new CameraSettings { Crop = [0.1, 0.2, 0.5, 0.6], Aspect = new Auto<string>().WithManual("9:16"), Keyframes = [new CameraKey(3, 0.4, 0.5, 1.5, 2)] },
Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 },
}.ToJson();
Assert.Equal(older, ProjectContent.Canonical(older));
Assert.Equal(older, OldBuild.Write(OldBuild.Read(older)).ReplaceLineEndings("\n"));
Assert.Equal(older, ProjectContent.Canonical(older.Replace("\n", "\r\n", StringComparison.Ordinal)));
Assert.Equal(ProjectSettings.BaseVersion, ProjectContent.FormatOf(older));
}
[Test]
public void TheNewMembersRoundTripAndRaiseTheFormatOnlyWhileUsed()
{
var plain = new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.5 } };
Assert.Equal(ProjectSettings.BaseVersion, plain.RequiredFormat);
var turned = plain with { Camera = plain.Camera with { Rotate = 90, Mirror = true, Flip = true, Straighten = -3.5 } };
var looked = plain with { Look = new LookSettings { Filter = "sepia", Strength = 0.6 } };
foreach (var settings in new[] { turned, looked, plain with { Camera = new CameraSettings { Straighten = 1 } }, plain with { Camera = new CameraSettings { Flip = true } } })
{
Assert.Equal(2, settings.RequiredFormat);
var json = settings.ToJson();
Assert.Contains("\"version\": 2", json);
var back = ProjectSettings.FromJson(json);
Assert.Equal(2, back.Version);
Assert.False(back.IsNewerFormat);
Assert.Equal(json, back.ToJson());
}
var read = ProjectSettings.FromJson(turned.ToJson());
Assert.Equal((90, true, true, -3.5), (read.Camera.Rotate, read.Camera.Mirror, read.Camera.Flip, read.Camera.Straighten));
Assert.Equal((1, true), (read.Camera.Turns, read.Camera.IsOriented));
var look = Assert.NotNull(ProjectSettings.FromJson(looked.ToJson()).Look);
Assert.Equal(("sepia", (double?)0.6), (look.Filter, look.Strength));
// Taken away again, the project is format 1 with the text it had before.
var undone = ProjectSettings.FromJson(turned.ToJson()) with { Camera = plain.Camera };
Assert.Equal(ProjectSettings.BaseVersion, undone.RequiredFormat);
Assert.Equal(plain.ToJson(), undone.ToJson());
Assert.Equal(plain.ToJson(), (ProjectSettings.FromJson(looked.ToJson()) with { Look = null }).ToJson());
// An identity look and a whole turn need nothing newer; an unknown look does (it is a newer Chronos's).
Assert.Equal(1, (plain with { Look = new LookSettings { Filter = "none" } }).RequiredFormat);
Assert.Equal(1, (plain with { Look = new LookSettings { Filter = "mono", Strength = 0 } }).RequiredFormat);
Assert.Equal(1, (plain with { Camera = new CameraSettings { Rotate = 360 } }).RequiredFormat);
Assert.Equal(2, (plain with { Look = new LookSettings { Filter = "film" } }).RequiredFormat);
Assert.Equal(3, new CameraSettings { Rotate = -90 }.Turns);
}
[Test]
public void TheNewMembersComeAfterTheOldOnesSoAnOlderBuildWritesThemBackInPlace()
{
var settings = new ProjectSettings
{
Camera = new CameraSettings { Crop = [0.2, 0, 0.6, 1], Keyframes = [new CameraKey(1, 0.5, 0.5, 2, 0)], Rotate = 270, Straighten = 2.25 },
HeroFrame = 4,
Look = new LookSettings { Filter = "warm" },
};
var canonical = ProjectContent.Canonical(settings.ToJson());
// A format-1 build keeps them as members it does not know, and writes them where they were.
var old = OldBuild.Read(canonical);
Assert.True(old.Camera.Extra!.ContainsKey("rotate") && old.Extra!.ContainsKey("look"));
// In the OS's line ends (CRLF on Windows): the same text and content hash but for those.
Assert.Equal(canonical, OldBuild.Write(old).ReplaceLineEndings("\n"));
Assert.True(ProjectContent.MatchesHash(OldBuild.Write(old), ProjectContent.Hash(canonical)));
Assert.True(ProjectContent.SameChoices(OldBuild.Write(old), canonical, new FramePhotos([])));
var camera = System.Text.Json.Nodes.JsonNode.Parse(canonical)!["camera"]!.AsObject().Select(p => p.Key).ToList();
Assert.SequenceEqual(["crop", "aspect", "offsetX", "offsetY", "keyframes", "rotate", "straighten"], camera);
}
[Test]
public void ANewerFormatStaysReadOnlyAndKeepsItsNumber()
{
const string newer = """{ "version": 4, "camera": { "rotate": 90 }, "look": { "filter": "film", "grain": 0.2 } }""";
Assert.Throws<InvalidDataException>(() => ProjectSettings.FromJson(newer));
var read = ProjectSettings.FromJson(newer, allowNewer: true);
Assert.True(read.IsNewerFormat);
Assert.Equal(4, read.WrittenFormat);
var canonical = ProjectContent.Canonical(newer);
Assert.Equal(4, ProjectContent.FormatOf(canonical));
Assert.Contains("\"grain\": 0.2", canonical);
Assert.Equal(canonical, ProjectContent.Canonical(canonical));
// Format-2 and format-3 projects are this Chronos's own (written as the format they need); text without a version
// is format 1.
Assert.False(ProjectSettings.FromJson("""{ "version": 2 }""").IsNewerFormat);
Assert.Equal(1, ProjectSettings.FromJson("""{ "version": 2 }""").WrittenFormat);
Assert.False(ProjectSettings.FromJson("""{ "version": 3 }""").IsNewerFormat);
Assert.Equal(1, ProjectSettings.FromJson("""{ "version": 3 }""").WrittenFormat);
Assert.Equal(1, ProjectContent.FormatOf("""{ "camera": {} }"""));
Assert.Equal(1, ProjectContent.FormatOf(null));
}
[Test]
public void APlaybackAtItsDefaultIsWrittenAsNone()
{
var plain = new ProjectSettings().ToJson();
foreach (var playback in new[]
{
new PlaybackSettings(),
new PlaybackSettings { Direction = "Forward", Loops = 1, FadeIn = 0, FadeOut = 0, HoldEnd = 0 },
new PlaybackSettings { Loops = 0, FadeIn = double.NaN, HoldEnd = -2 },
})
{
Assert.True(playback.IsDefault);
var settings = new ProjectSettings { Export = new ExportSettings { Playback = playback } };
Assert.Equal(ProjectSettings.BaseVersion, settings.RequiredFormat);
Assert.Equal(plain, settings.ToJson());
}
Assert.False(plain.Contains("playback", StringComparison.Ordinal));
Assert.Null(ProjectSettings.FromJson(plain).Export.Playback);
}
[Test]
public void ThePlaybackRaisesTheFormatToThreeAndLeavesOutItsDefaults()
{
var plain = new ProjectSettings();
var turned = plain with { Camera = new CameraSettings { Rotate = 90 } };
var reversed = new PlaybackSettings { Direction = PlaybackDirection.Reverse, Loops = 1, FadeIn = 0 };
Assert.Equal((1, 2), (plain.RequiredFormat, turned.RequiredFormat));
foreach (var settings in new[]
{
plain with { Export = plain.Export with { Playback = reversed } },
turned with { Export = plain.Export with { Playback = new PlaybackSettings { FadeOut = 2.5 } } },
plain with { Export = plain.Export with { Playback = new PlaybackSettings { Loops = 3, HoldEnd = 1 } } },
})
{
Assert.Equal(ProjectSettings.PlaybackVersion, settings.RequiredFormat);
Assert.Equal(3, ProjectSettings.CurrentVersion);
var json = settings.ToJson();
Assert.Contains("\"version\": 3", json);
var back = ProjectSettings.FromJson(json);
Assert.Equal(3, back.Version);
Assert.False(back.IsNewerFormat);
Assert.Equal(json, back.ToJson());
Assert.Equal(json, ProjectContent.Canonical(json));
}
// Each member at its default is left out of the text.
var text = (plain with { Export = plain.Export with { Playback = reversed } }).ToJson();
var written = System.Text.Json.Nodes.JsonNode.Parse(text)!["export"]!["playback"]!.AsObject().Select(p => p.Key).ToList();
Assert.SequenceEqual(["direction"], written);
// Every member reads back; the effective values clamp what is out of range.
var full = ProjectSettings.FromJson("""{ "export": { "playback": { "direction": "boomerang", "loops": 40, "fadeIn": 1.5, "fadeOut": 99, "holdEnd": 3 } } }""");
var playback = Assert.NotNull(full.Export.Playback);
Assert.Equal(("boomerang", (int?)40, (double?)1.5, (double?)99.0, (double?)3.0), (playback.Direction, playback.Loops, playback.FadeIn, playback.FadeOut, playback.HoldEnd));
Assert.Equal((PlaybackSettings.MaxLoops, PlaybackSettings.MaxFadeSeconds), (playback.EffectiveLoops, playback.EffectiveFadeOut));
Assert.Equal(3, full.RequiredFormat);
// A direction this Chronos does not know renders forward but is kept, and keeps the format.
var unknown = ProjectSettings.FromJson("""{ "export": { "playback": { "direction": "pingpong", "speed": 2 } } }""");
var kept = Assert.NotNull(unknown.Export.Playback);
Assert.Equal(PlaybackDirection.Forward, kept.EffectiveDirection);
Assert.False(kept.IsDefault);
Assert.Equal(3, unknown.RequiredFormat);
Assert.Contains("\"speed\": 2", unknown.ToJson());
// Taken away again, the project is format 1 with the text it had before.
var undone = ProjectSettings.FromJson(text) with { Export = plain.Export };
Assert.Equal(plain.ToJson(), undone.ToJson());
}
[Test]
public void AFormatThreeFileReadByAFormatTwoBuildKeepsItsPlayback()
{
var path = Path.Combine(TestContext.FixturesDirectory, "settings", "format3-playback.json");
var fixture = File.ReadAllText(path);
var settings = ProjectSettings.FromJson(fixture);
Assert.Equal(3, settings.Version);
var playback = Assert.NotNull(settings.Export.Playback);
Assert.Equal((PlaybackDirection.Boomerang, 2, 1.5, 2.0, 3.0), (playback.EffectiveDirection, playback.EffectiveLoops, playback.EffectiveFadeIn, playback.EffectiveFadeOut, playback.EffectiveHoldEnd));
Assert.Equal((3, 90), (settings.RequiredFormat, settings.Camera.Rotate));
var canonical = ProjectContent.Canonical(settings.ToJson());
Assert.Equal(3, ProjectContent.FormatOf(canonical));
// A format-2 build knows no playback: it lands in the export's Extra and is written back where it was.
var old = Format2Build.Read(canonical);
Assert.True(old.Export.Extra!.ContainsKey("playback"));
Assert.Equal(3, old.Version);
Assert.Equal(canonical, Format2Build.Write(old).ReplaceLineEndings("\n"));
Assert.True(ProjectContent.MatchesHash(Format2Build.Write(old), ProjectContent.Hash(canonical)));
var export = System.Text.Json.Nodes.JsonNode.Parse(canonical)!["export"]!.AsObject().Select(p => p.Key).ToList();
Assert.Equal("playback", export[^1]);
}
/// <summary>
/// The settings as a format-2 build reads and writes them: its export without the playback (owner review 1, phase 5),
/// with the same serialiser options. What it does not know lands in <c>Extra</c>.
/// </summary>
private static class Format2Build
{
public static Format2Project Read(string json) => System.Text.Json.JsonSerializer.Deserialize(json, OldJson.Default.Format2Project)!;
public static string Write(Format2Project project) => System.Text.Json.JsonSerializer.Serialize(project, OldJson.Default.Format2Project);
}
/// <summary>
/// The settings as a format-1 build reads and writes them: its camera without phase 4's members and its project without
/// the look, with the same serialiser options. What it does not know lands in <c>Extra</c>.
/// </summary>
private static class OldBuild
{
public static OldProject Read(string json) => System.Text.Json.JsonSerializer.Deserialize(json, OldJson.Default.OldProject)!;
public static string Write(OldProject project) => System.Text.Json.JsonSerializer.Serialize(project, OldJson.Default.OldProject);
}
}
/// <summary>A format-1 build's camera (before owner review 1, phase 4).</summary>
internal sealed record OldCamera
{
public double[]? Crop { get; init; }
public Auto<string> Aspect { get; init; } = new();
public double OffsetX { get; init; }
public double OffsetY { get; init; }
public IReadOnlyList<CameraKey> Keyframes { get; init; } = [];
[System.Text.Json.Serialization.JsonExtensionData]
public Dictionary<string, System.Text.Json.JsonElement>? Extra { get; set; }
}
/// <summary>A format-1 build's project (before owner review 1, phase 4).</summary>
internal sealed record OldProject
{
public int Version { get; init; } = 1;
public TimingSettings Timing { get; init; } = new();
public ExposureSettings Exposure { get; init; } = new();
public MotionSettings Motion { get; init; } = new();
public OldCamera Camera { get; init; } = new();
public StackSettings Stack { get; init; } = new();
public ExportSettings Export { get; init; } = new();
public IReadOnlyList<int> ExcludedFrames { get; init; } = [];
public int? HeroFrame { get; init; }
public IReadOnlyList<PendingFrame>? PendingFrames { get; init; }
[System.Text.Json.Serialization.JsonExtensionData]
public Dictionary<string, System.Text.Json.JsonElement>? Extra { get; set; }
}
/// <summary>A format-2 build's export (before owner review 1, phase 5): no playback.</summary>
internal sealed record Format2Export
{
public Auto<string> Preset { get; init; } = new();
public ExportOverrides Overrides { get; init; } = new();
public string NameTemplate { get; init; } = "{date} {title} - {preset}";
public string? Folder { get; init; }
public IReadOnlyList<string> Batch { get; init; } = [];
public bool SyncToServer { get; init; }
[System.Text.Json.Serialization.JsonExtensionData]
public Dictionary<string, System.Text.Json.JsonElement>? Extra { get; set; }
}
/// <summary>A format-2 build's project (owner review 1, phase 4): phase 4's camera and look, the export without playback.</summary>
internal sealed record Format2Project
{
public int Version { get; init; } = 1;
public TimingSettings Timing { get; init; } = new();
public ExposureSettings Exposure { get; init; } = new();
public MotionSettings Motion { get; init; } = new();
public CameraSettings Camera { get; init; } = new();
public StackSettings Stack { get; init; } = new();
public Format2Export Export { get; init; } = new();
public IReadOnlyList<int> ExcludedFrames { get; init; } = [];
public int? HeroFrame { get; init; }
public IReadOnlyList<PendingFrame>? PendingFrames { get; init; }
public LookSettings? Look { get; init; }
[System.Text.Json.Serialization.JsonExtensionData]
public Dictionary<string, System.Text.Json.JsonElement>? Extra { get; set; }
}
[System.Text.Json.Serialization.JsonSourceGenerationOptions(
WriteIndented = true,
PropertyNamingPolicy = System.Text.Json.Serialization.JsonKnownNamingPolicy.CamelCase,
DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,
UseStringEnumConverter = true,
PropertyNameCaseInsensitive = true)]
[System.Text.Json.Serialization.JsonSerializable(typeof(OldProject))]
[System.Text.Json.Serialization.JsonSerializable(typeof(Format2Project))]
internal sealed partial class OldJson : System.Text.Json.Serialization.JsonSerializerContext;