Wire the phase 5 parcels into one working whole. - Save frame works in a workspace project. WorkspaceSequenceSource now makes still jobs (IProjectStills) routed like its renders: with the originals on this PC, a WorkspaceRender still into exports/; with proxies only, the home's still job with the portable settings and the project id. The tooltip for a source that saves no frames is now a real string. - The Export footer has Save project file again for library sequences; workspace projects keep it in their project menu only. - Sync render downloads are hashed and compared with the server's sha256 (one retry, then the job fails without filing the file), and uploads and downloads carry the render kind, so a saved frame no longer counts as a recent preset. - Add the missing en/it strings: still frame out of the sequence (Core and both job handlers), keyframes not applicable, workspace stills, Videos refresh / clear sequence / play-from-server tips, the videos-folder creation error, and the admin panel kind labels, play and trash tips. - Delete the export history, batch and card strings no longer used from English and prune them from every culture. - Videos: the sequence chip clears only the sequence filter (desktop and admin panel), the desktop remembers cards or list, and a Refresh button. Refs #21 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
302 lines
17 KiB
C#
302 lines
17 KiB
C#
using System.Text.Json;
|
||
using Chronos.App.Editor;
|
||
using Chronos.Core.Export;
|
||
using Chronos.Core.Localization;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Core.Project;
|
||
using Chronos.Core.Render;
|
||
using Chronos.Core.Video;
|
||
using Chronos.Data.Archiving.Jobs;
|
||
using Chronos.Protocol;
|
||
using Chronos.Testing;
|
||
using Chronos.Ui.Mvvm;
|
||
using Chronos.Ui.Visuals;
|
||
|
||
namespace Chronos.App.Tests.Editor;
|
||
|
||
/// <summary>
|
||
/// The editor's Render ▾ menu (owner review 1, R3, decisions 1, 2 and 12): grouped presets with the current one checked,
|
||
/// recent presets from the render history, Save frame and why it waits, still jobs, the Render tooltip.
|
||
/// </summary>
|
||
public sealed class RenderMenuTests
|
||
{
|
||
private static readonly RelayCommand Select = new(_ => { });
|
||
|
||
[Test]
|
||
public void TheMenuPutsTheCurrentTheRecommendedTheBatchAndTheRecentPresetsFirstAndGroupsTheRest()
|
||
{
|
||
var menu = RenderMenu.Build(new RenderMenuState
|
||
{
|
||
CurrentPresetId = "4k-hevc",
|
||
BasePresetId = "4k-hevc",
|
||
RecommendedPresetId = "4k-hevc10-archive",
|
||
Batch = ["1080p-h264", "4k-hevc10-archive"],
|
||
Recent = ["vertical-1080x1920", "1080p-h264", "gif-preview", "apng", "png-sequence"],
|
||
Details = p => p.Id + " details",
|
||
SelectPreset = Select,
|
||
});
|
||
|
||
// The current preset, listed by no section, comes first and is the one checked.
|
||
Assert.Equal("preset:4k-hevc", menu[0].Id);
|
||
Assert.True(menu[0].IsChecked);
|
||
Assert.Equal(Loc.L("Export.Preset.4kHevc"), menu[0].Label);
|
||
Assert.Equal("4k-hevc details", menu[0].Details);
|
||
Assert.Same(Select, menu[0].Command);
|
||
Assert.Equal("4k-hevc", menu[0].CommandParameter);
|
||
Assert.Count(1, menu.SelectMany(m => m.Flatten()).Where(m => m.IsChecked));
|
||
|
||
var top = menu.TakeWhile(m => m.Kind != RenderMenuItemKind.Submenu).ToList();
|
||
Assert.SequenceEqual(
|
||
[
|
||
"preset:4k-hevc", Loc.L("Editor.RenderMenu.Recommended"), "preset:4k-hevc10-archive", Loc.L("Export.Footer.Batch", 2), "preset:1080p-h264",
|
||
Loc.L("Editor.RenderMenu.Recent"), "preset:vertical-1080x1920", "preset:gif-preview", "preset:apng",
|
||
], top.Select(m => m.Id ?? m.Label).ToList());
|
||
Assert.True(top.Where(m => m.Kind == RenderMenuItemKind.Header).All(h => h.Command is null), "headers are titles");
|
||
Assert.Contains(Loc.L("Tooltips.Editor.RenderMenu.Recommended"), top[2].ToolTip!);
|
||
Assert.Contains(Loc.L("Tooltips.Editor.RenderMenu.Recent"), top[6].ToolTip!);
|
||
|
||
// Other presets ›: every preset not listed above, under its group's title, the groups in the Export step's order.
|
||
var other = Assert.Contains(menu, m => m.Id == "other");
|
||
Assert.Equal(RenderMenuItemKind.Submenu, other.Kind);
|
||
var headers = other.Children.Where(c => c.Kind == RenderMenuItemKind.Header).Select(c => c.Label).ToList();
|
||
Assert.SequenceEqual([.. new[] { "video", "social", "intermediate", "sequence" }.Select(RenderMenu.GroupLabel)], headers,
|
||
"the Web group, both of its presets already listed above, has no title of its own");
|
||
var listed = menu.SelectMany(m => m.Flatten()).Where(m => m.Kind == RenderMenuItemKind.Preset).Select(m => (string)m.CommandParameter!).ToList();
|
||
Assert.Equal(ExportPresets.BuiltIn.Count, listed.Count, "every preset once");
|
||
Assert.Equal(ExportPresets.BuiltIn.Count, listed.Distinct().Count());
|
||
Assert.True(menu.SelectMany(m => m.Flatten()).All(m => m.Kind is RenderMenuItemKind.Header or RenderMenuItemKind.Separator || m.ToolTip is { Length: > 0 }),
|
||
"every entry that does something has a tooltip");
|
||
|
||
// The lower part, in its order.
|
||
Assert.SequenceEqual(["batch", "queue", "frame", "videos"], menu.SkipWhile(m => m.Kind != RenderMenuItemKind.Separator).Skip(1).Select(m => m.Id!).ToList());
|
||
Assert.Equal(Loc.L("Editor.RenderMenu.Batch", 2), Assert.Contains(menu, m => m.Id == "batch").Label);
|
||
}
|
||
|
||
[Test]
|
||
public void APresetAlreadyRecommendedIsNotListedAgainAndACustomExportChecksNone()
|
||
{
|
||
var menu = RenderMenu.Build(new RenderMenuState
|
||
{
|
||
CurrentPresetId = null,
|
||
BasePresetId = "4k-hevc10-archive",
|
||
RecommendedPresetId = "4k-hevc10-archive",
|
||
Recent = ["4k-hevc10-archive"],
|
||
});
|
||
Assert.Equal(RenderMenuItemKind.Header, menu[0].Kind, "the base preset is the recommended one: no separate first entry");
|
||
Assert.Count(1, menu.SelectMany(m => m.Flatten()).Where(m => m.Id == "preset:4k-hevc10-archive"));
|
||
Assert.False(menu.SelectMany(m => m.Flatten()).Any(m => m.IsChecked), "Custom values match no preset");
|
||
Assert.False(menu.Any(m => m.Label == Loc.L("Editor.RenderMenu.Recent")), "no recent preset left to show");
|
||
}
|
||
|
||
[Test]
|
||
public void ThePresetDetailsFollowTheChosenProportions()
|
||
{
|
||
var portrait = new CameraSettings { Aspect = new Auto<string>().WithManual("9:16") };
|
||
Assert.Equal(Loc.L("Editor.RenderMenu.Details", "2160×3840", Loc.L("Export.Codec.HevcMain10"), Loc.L("Editor.Value.Fps", "24")),
|
||
RenderMenu.PresetDetails(new ExportSettings(), "4k-hevc10-archive", portrait, 6000, 4000));
|
||
Assert.True(RenderMenu.PresetDetails(new ExportSettings(), "png-sequence", new CameraSettings(), 6000, 4000).StartsWith("6000×4000", StringComparison.Ordinal),
|
||
"an image sequence keeps the source's size");
|
||
Assert.True(RenderMenu.PresetDetails(new ExportSettings(), "png-sequence", new CameraSettings(), 0, 0).StartsWith(Loc.L("Export.Resolution.Source"), StringComparison.Ordinal));
|
||
}
|
||
|
||
[Test]
|
||
public void RecentPresetsComeFromTheRenderHistoryNewestFirst()
|
||
{
|
||
var sequence = Guid.CreateVersion7();
|
||
var settings = new ProjectSettings { Export = new ExportSettings { Preset = new Auto<string>().WithManual("4k-h264") } }.ToJson();
|
||
var custom = new ProjectSettings { Export = new ExportSettings { Preset = new Auto<string>().WithManual("4k-h264"), Overrides = new ExportOverrides { BitRate = 1 } } }.ToJson();
|
||
IReadOnlyList<Render> renders =
|
||
[
|
||
Render(sequence, "whatever", settings),
|
||
Render(sequence, Loc.L("Export.Preset.Png"), null) with { Kind = RenderKind.Still },
|
||
Render(sequence, Loc.L("Export.Preset.1080pShare"), null),
|
||
Render(sequence, "Custom", custom),
|
||
Render(sequence, Loc.L("Export.Preset.4kH264"), settings),
|
||
Render(sequence, Loc.L("Export.Preset.Gif"), "{not json"),
|
||
Render(sequence, Loc.L("Export.Preset.Vertical"), null),
|
||
];
|
||
Assert.SequenceEqual(["4k-h264", "1080p-h264", "gif-preview"], [.. RenderMenu.RecentPresets(renders)],
|
||
"settings first, else the name; a saved frame, a custom export and a repeat do not count; three at most");
|
||
Assert.Null(RenderMenu.PresetOf(Render(sequence, "Custom", custom)));
|
||
}
|
||
|
||
[Test]
|
||
public void SaveFrameWaitsWithTheReason()
|
||
{
|
||
Assert.Equal(Loc.L("Tooltips.Export.StillReadOnly"), RenderMenu.SaveFrameBlockedReason(false, null, readOnly: true, hasFrame: true, true, null, null));
|
||
Assert.Equal(Loc.L("Tooltips.Export.StillNeedsFrame"), RenderMenu.SaveFrameBlockedReason(false, null, false, hasFrame: false, true, null, null));
|
||
Assert.Equal(Loc.L("Tooltips.Editor.Outdated", "Studio NAS"), RenderMenu.SaveFrameBlockedReason(outdated: true, "Studio NAS", true, false, true, null, null), "out of date first");
|
||
var older = ServerJobs.StillNeedsNewerServer(serverFormat: 2);
|
||
Assert.Equal(Loc.L("Tooltips.Server.NeedsNewerServer"), older);
|
||
Assert.Null(ServerJobs.StillNeedsNewerServer(RenderRules.StillFormat), "a format-3 server takes still jobs");
|
||
Assert.Equal(older, RenderMenu.SaveFrameBlockedReason(false, "Studio NAS", false, true, true, older, null));
|
||
Assert.Equal(Loc.L("Tooltips.Editor.Render.NameError", "bad"), RenderMenu.SaveFrameBlockedReason(false, null, false, true, true, null, "bad"));
|
||
Assert.Equal(Loc.L("Tooltips.Export.StillWorkspace"), RenderMenu.SaveFrameBlockedReason(false, null, false, true, sourceSavesFrames: false, null, null),
|
||
"a source that renders elsewhere without still jobs of its own");
|
||
Assert.Null(RenderMenu.SaveFrameBlockedReason(false, null, false, true, true, null, null));
|
||
|
||
// In the menu: Save frame › and its formats are disabled and say why.
|
||
var menu = RenderMenu.Build(new RenderMenuState { SaveFrameBlocked = older });
|
||
var frame = Assert.Contains(menu, m => m.Id == "frame");
|
||
Assert.False(frame.IsEnabled);
|
||
Assert.Equal(older, frame.ToolTip);
|
||
Assert.SequenceEqual(["frame:pngsequence", "frame:jpegsequence", "frame:tiff16sequence"], [.. frame.Children.Select(c => c.Id!)]);
|
||
Assert.True(frame.Children.All(c => !c.IsEnabled && c.ToolTip == older));
|
||
Assert.SequenceEqual(["PNG", "JPEG", Loc.L("Export.Codec.Tiff16Sequence")], [.. frame.Children.Select(c => c.Label)]);
|
||
|
||
var ready = Assert.Contains(RenderMenu.Build(new RenderMenuState()), m => m.Id == "frame");
|
||
Assert.True(ready.IsEnabled);
|
||
Assert.Equal(VideoCodec.JpegSequence, ready.Children[1].CommandParameter);
|
||
Assert.Equal(Loc.L("Tooltips.Editor.RenderMenu.SaveFormat", "JPEG"), ready.Children[1].ToolTip);
|
||
}
|
||
|
||
[Test]
|
||
public void APlaybackExportNeedsAFormatThreeServer()
|
||
{
|
||
var playback = new ExportSettings { Playback = new PlaybackSettings { Direction = PlaybackDirection.Boomerang } };
|
||
Assert.Equal(Loc.L("Tooltips.Server.NeedsNewerServer"), ServerJobs.RenderNeedsNewerServer(new ProjectSettings(), playback, 6000, 4000, serverFormat: 2));
|
||
Assert.Null(ServerJobs.RenderNeedsNewerServer(new ProjectSettings(), playback, 6000, 4000, serverFormat: 3));
|
||
Assert.Null(ServerJobs.RenderNeedsNewerServer(new ProjectSettings(), new ExportSettings(), 6000, 4000, serverFormat: 1), "no playback: format 1");
|
||
// The format is read from the export rendered, not from the project's own export.
|
||
Assert.NotNull(ServerJobs.RenderNeedsNewerServer(new ProjectSettings { Export = new ExportSettings() }, playback, 6000, 4000, serverFormat: 2));
|
||
}
|
||
|
||
[Test]
|
||
public async Task AStillJobCarriesTheFrameAndItsPhoto()
|
||
{
|
||
var content = EditorFixture.Content(EditorFixture.Sunset);
|
||
content = content with { Frames = [.. content.Frames.Select((f, i) => f with { Sha256 = $"{i:X64}" })] };
|
||
var source = new FakeSequenceSource(EditorFixture.Sunset, content);
|
||
await using var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20));
|
||
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.3 } });
|
||
Assert.True(session.CanSaveFrames);
|
||
|
||
var export = session.Project.Export with { Playback = new PlaybackSettings { Direction = PlaybackDirection.Reverse }, Batch = ["1080p-h264"] };
|
||
var request = Assert.Contains(Assert.NotNull(session.StillRequests(export, VideoCodec.PngSequence, 5)), _ => true);
|
||
Assert.Equal(JobKind.Render, request.Kind);
|
||
Assert.SequenceEqual([content.Sequence.Id], [.. request.Targets]);
|
||
var parameters = Assert.NotNull(JsonSerializer.Deserialize(request.ParametersJson!, ProtocolJson.Default.RenderJobParameters));
|
||
Assert.Equal(5, parameters.StillFrame);
|
||
Assert.Equal($"{5:x64}", parameters.StillPhoto, "the photo's hash, lower case");
|
||
Assert.True(parameters.IsStill);
|
||
Assert.GreaterOrEqual(parameters.RequiredSettingsFormat, RenderRules.StillFormat, "an older node never claims it");
|
||
Assert.Equal("pngsequence", parameters.Codec);
|
||
Assert.Equal(0.3, ProjectSettings.FromJson(parameters.SettingsJson!).Exposure.ExposureOffsetEv, "the project as the editor holds it");
|
||
Assert.Throws<ArgumentOutOfRangeException>(() => session.StillRequests(export, VideoCodec.PngSequence, content.Count));
|
||
|
||
// A server sequence: one job too.
|
||
var remote = new FakeSequenceSource(EditorFixture.Sunset, content) { IsRemote = true };
|
||
await using var remoteSession = new EditorSession(remote, content, [], TimeSpan.FromMilliseconds(20));
|
||
Assert.Count(1, Assert.NotNull(remoteSession.StillRequests(export, VideoCodec.Tiff16Sequence, 0)));
|
||
}
|
||
|
||
[Test]
|
||
public async Task AWorkspaceProjectSavesNoFrameUntilItMakesItsOwnStillJobs()
|
||
{
|
||
var content = EditorFixture.Content(EditorFixture.Sunset);
|
||
var fake = new FakeSequenceSource(EditorFixture.Sunset, content);
|
||
await using (var session = new EditorSession(new HomeRenders(fake), content, [], TimeSpan.FromMilliseconds(20)))
|
||
{
|
||
Assert.False(session.CanSaveFrames);
|
||
Assert.Null(session.StillRequests(session.Project.Export, VideoCodec.PngSequence, 0));
|
||
}
|
||
var stills = new HomeStills(fake);
|
||
await using (var session = new EditorSession(stills, content, [], TimeSpan.FromMilliseconds(20)))
|
||
{
|
||
Assert.True(session.CanSaveFrames);
|
||
Assert.Count(1, Assert.NotNull(session.StillRequests(session.Project.Export, VideoCodec.JpegSequence, 3)));
|
||
Assert.Equal((VideoCodec.JpegSequence, 3), stills.Asked);
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
public void TheRenderTooltipGivesThePresetTheSizeTheCodecAndTheEstimates()
|
||
{
|
||
var content = EditorFixture.Content(EditorFixture.Sunset);
|
||
var plan = Assert.NotNull(new ExportPlanner(content, [], EncoderHost.Client).Plan(content.Project with
|
||
{
|
||
Export = new ExportSettings { Preset = new Auto<string>().WithManual("4k-hevc10-archive") },
|
||
}));
|
||
var tip = RenderMenu.RenderToolTip(plan, null, null);
|
||
var (width, height) = plan.EncodedSize;
|
||
Assert.Contains(plan.PresetName, tip);
|
||
Assert.Contains(EditorText.Size(width, height), tip);
|
||
Assert.Contains(Loc.L("Export.Codec.HevcMain10"), tip);
|
||
Assert.Contains("Ctrl+R", tip);
|
||
|
||
var blocked = RenderMenu.RenderToolTip(plan, "Fix it first", "Studio NAS");
|
||
Assert.True(blocked.StartsWith("Fix it first" + Environment.NewLine, StringComparison.Ordinal), "the reason comes first");
|
||
Assert.False(blocked.Contains(Loc.L("Tooltips.Editor.RenderServer", "Studio NAS"), StringComparison.Ordinal));
|
||
Assert.True(RenderMenu.RenderToolTip(plan, null, "Studio NAS").EndsWith(Loc.L("Tooltips.Editor.RenderServer", "Studio NAS"), StringComparison.Ordinal));
|
||
Assert.Equal("Planning", RenderMenu.RenderToolTip(null, "Planning", null));
|
||
}
|
||
|
||
private static Render Render(Guid sequence, string presetName, string? settings) => new()
|
||
{
|
||
Id = Guid.CreateVersion7(),
|
||
SequenceId = sequence,
|
||
PresetName = presetName,
|
||
SettingsJson = settings,
|
||
OutputPath = "C:/out/" + presetName,
|
||
};
|
||
|
||
/// <summary>A source that renders at a home of its own (as a workspace project), delegating the rest.</summary>
|
||
private class HomeRenders(FakeSequenceSource inner) : ISequenceSource, IProjectRenders
|
||
{
|
||
public bool IsRemote => inner.IsRemote;
|
||
|
||
public bool IsReadOnly => inner.IsReadOnly;
|
||
|
||
public bool IsOutdated => inner.IsOutdated;
|
||
|
||
public bool RendersLocally => false;
|
||
|
||
public event Action? ReadOnlyChanged
|
||
{
|
||
add => inner.ReadOnlyChanged += value;
|
||
remove => inner.ReadOnlyChanged -= value;
|
||
}
|
||
|
||
public event Action<Job>? JobChanged
|
||
{
|
||
add => inner.JobChanged += value;
|
||
remove => inner.JobChanged -= value;
|
||
}
|
||
|
||
public IReadOnlyList<ArchiveJobRequest> RenderRequests(Sequence sequence, ProjectSettings project, ExportSettings export, int sourceWidth, int sourceHeight) => [];
|
||
|
||
public Task<SequenceContent> LoadAsync(CancellationToken cancellationToken) => inner.LoadAsync(cancellationToken);
|
||
|
||
public Task<bool> FramesCurrentAsync(CancellationToken cancellationToken) => inner.FramesCurrentAsync(cancellationToken);
|
||
|
||
public ValueTask<Core.Imaging.ImageBuffer?> DecodeAsync(int index, int maxLongEdge, Core.Imaging.DecodePurpose purpose, CancellationToken cancellationToken) =>
|
||
inner.DecodeAsync(index, maxLongEdge, purpose, cancellationToken);
|
||
|
||
public Task<ProjectSettings> SaveProjectAsync(ProjectSettings project, ProjectSettings basis, CancellationToken cancellationToken) =>
|
||
inner.SaveProjectAsync(project, basis, cancellationToken);
|
||
|
||
public Task<Guid> SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken) => inner.SubmitAsync(request, cancellationToken);
|
||
|
||
public Task<IReadOnlyList<Job>> ListJobsAsync(CancellationToken cancellationToken) => inner.ListJobsAsync(cancellationToken);
|
||
|
||
public Task CancelJobAsync(Guid jobId, CancellationToken cancellationToken) => inner.CancelJobAsync(jobId, cancellationToken);
|
||
|
||
public Task RetryJobAsync(Guid jobId, CancellationToken cancellationToken) => inner.RetryJobAsync(jobId, cancellationToken);
|
||
|
||
public ValueTask DisposeAsync() => inner.DisposeAsync();
|
||
}
|
||
|
||
/// <summary>A home-rendering source that makes its own still jobs.</summary>
|
||
private sealed class HomeStills(FakeSequenceSource inner) : HomeRenders(inner), IProjectStills
|
||
{
|
||
public (VideoCodec Codec, int Frame)? Asked { get; private set; }
|
||
|
||
public IReadOnlyList<ArchiveJobRequest> StillRequests(Sequence sequence, ProjectSettings project, ExportSettings export, VideoCodec codec, int frameIndex,
|
||
string? photoSha256, int sourceWidth, int sourceHeight)
|
||
{
|
||
Asked = (codec, frameIndex);
|
||
return [new ArchiveJobRequest(JobKind.Render, [sequence.Id], "still", null, JobPriority.User)];
|
||
}
|
||
}
|
||
}
|