diff --git a/src/Chronos.App/Editor/EditorViewModel.cs b/src/Chronos.App/Editor/EditorViewModel.cs index 64e68aec..cff714b2 100644 --- a/src/Chronos.App/Editor/EditorViewModel.cs +++ b/src/Chronos.App/Editor/EditorViewModel.cs @@ -551,10 +551,17 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable public bool CanRender => RenderBlockedReason is null; + /// The settings format a render of needs (). + private int RenderFormat => + Chronos.Data.Processing.ProcessingJobs.RequiredFormat(Session.Project, RenderExport, Session.Content.SourceWidth, Session.Content.SourceHeight); + /// Why the project's export cannot be rendered now, localised; null when it can. public string? RenderBlockedReason => Plan switch { _ when IsRemote && !Shell.Services.Sync.CanRender => Loc.L("Tooltips.Editor.Render.NoRight", ServerName), + // Settings or proportions the server would render otherwise (owner review 1, phase 4: an older server, Send and render too). + _ when IsRemote && ServerJobs.NeedsNewerServer(RenderFormat, Shell.Services.Sync.SettingsFormat) + is { } newer => newer, _ when IsOutdated => Loc.L("Tooltips.Editor.Outdated", ServerName), null when _planned => Loc.L("Tooltips.Editor.Render.NoSource"), null => Loc.L("Tooltips.Editor.Render.Planning"), diff --git a/src/Chronos.App/Editor/ServerJobs.cs b/src/Chronos.App/Editor/ServerJobs.cs index 31160330..890c3ff9 100644 --- a/src/Chronos.App/Editor/ServerJobs.cs +++ b/src/Chronos.App/Editor/ServerJobs.cs @@ -56,6 +56,13 @@ internal sealed class ServerJobs : IAsyncDisposable /// The connection the jobs travel on (the source's other calls use it too). public IRemoteSequenceApi Api { get; } + /// + /// Why something that needs settings format cannot go to a server that reads + /// (owner review 1, phase 4: a render, a push, Send and render); null when it can. The + /// desktop disables the action with this as its tooltip. + /// + public static string? NeedsNewerServer(int required, int serverFormat) => required > serverFormat ? Loc.L("Tooltips.Server.NeedsNewerServer") : null; + /// Queues on the server (its priority set after, when it is not the user's); returns the job id. /// The sequence is gone from the server. public async Task SubmitAsync(ArchiveJobRequest request, CancellationToken cancellationToken) diff --git a/src/Chronos.App/Sections/SequenceView.xaml b/src/Chronos.App/Sections/SequenceView.xaml index 5a6eb10f..2a12b9af 100644 --- a/src/Chronos.App/Sections/SequenceView.xaml +++ b/src/Chronos.App/Sections/SequenceView.xaml @@ -118,7 +118,7 @@ - + diff --git a/src/Chronos.App/Server/SyncHost.cs b/src/Chronos.App/Server/SyncHost.cs index c01162f2..a14e3f26 100644 --- a/src/Chronos.App/Server/SyncHost.cs +++ b/src/Chronos.App/Server/SyncHost.cs @@ -81,6 +81,16 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo public bool HasProjects => services.Server.IsConnected && services.Server.Flow.Info?.Capabilities is { } capabilities && capabilities.Contains(ServerCapabilities.Projects); + /// + /// The highest project settings format the signed-in server reads and renders (owner review 1, phase 4); 1 while signed + /// out and for an older server, which does not announce it. Pushes and renders that need more are held back + /// (). + /// + public int SettingsFormat => SettingsFormatOf(services.Server.IsConnected ? services.Server.Flow.Info : null); + + /// The settings format a server's server/info announces; 1 when it announces none (an older server). + public static int SettingsFormatOf(ServerInfo? info) => info?.SettingsFormat is > 0 and var format ? format : ProjectSettings.BaseVersion; + /// The home of a workspace project of server sequence ; null while signed out or when the server keeps no projects. public BundleHome? ServerHome(Guid remoteId) => Server is { } server && HasProjects ? new BundleHome(BundleHome.ServerKind, remoteId, null, server) : null; @@ -95,7 +105,7 @@ public sealed class SyncHost(AppServices services) : ISyncConnector, IAsyncDispo if (home.IsArchive || !HasProjects || Volatile.Read(ref _credentials) is not { } credentials || !string.Equals(home.Server, SyncService.ServerKey(credentials.Address), StringComparison.OrdinalIgnoreCase)) return null; - return new ServerProjectHome(SessionClient(credentials), home.SequenceId, services.Server.ServerName); + return new ServerProjectHome(SessionClient(credentials), home.SequenceId, services.Server.ServerName, SettingsFormat); } /// diff --git a/src/Chronos.App/Workspace/ProjectMenuViewModel.cs b/src/Chronos.App/Workspace/ProjectMenuViewModel.cs index cf835c23..300e5cf5 100644 --- a/src/Chronos.App/Workspace/ProjectMenuViewModel.cs +++ b/src/Chronos.App/Workspace/ProjectMenuViewModel.cs @@ -108,7 +108,7 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel _source = source; _session = session; _ui = ui; - _sync = new AsyncRelayCommand(() => SyncAsync(), () => !_isSyncing); + _sync = new AsyncRelayCommand(() => SyncAsync(), () => !_isSyncing && PushBlockedReason is null); _updateMedia = new AsyncRelayCommand(UpdateMediaAsync, () => _copyJob == Guid.Empty); SaveVersionCommand = new RelayCommand(OpenSaveVersion, () => CanSaveVersion); HistoryCommand = new AsyncRelayCommand(OpenHistoryAsync); @@ -146,6 +146,18 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel public string StateToolTip => WorkspaceText.StateToolTip(_status, _isSyncing, IsServerHome); + /// + /// Why the project cannot be sent to its server now (owner review 1, phase 4): its settings are of a format the server + /// does not read (an older Chronos Server, which would refuse them); null when they can, and for a project of this PC's + /// archive. Sync is disabled with this as its tooltip, and a render of the server's is held. + /// + public string? PushBlockedReason => IsServerHome && _source.Workspace is { } workspace && _host.HomeOf(workspace.Home) is { } home + ? ServerJobs.NeedsNewerServer(_session.Project.WrittenFormat, home.SettingsFormat) + : null; + + /// Sync in the menu: why it is disabled, else where the project stands. + public string SyncToolTip => PushBlockedReason ?? StateToolTip; + /// The ▾ button: its name, then where the project stands, then what the menu holds. public string MenuToolTip => Loc.L("Tooltips.Editor.Project.Menu", Name, StateText); @@ -270,6 +282,12 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel if (_host.Settings.WorkspaceVersionOnRender && !await SaveForRenderAsync()) return false; // Rendered on this PC from the originals the workspace holds (phase 5c): the project renders as it is. if (!IsServerHome || _source.RendersLocally) return true; + // Settings the server cannot read are neither sent nor rendered there (owner review 1, phase 4: an older server). + if (PushBlockedReason is { } newer) + { + _ui.Notify(Loc.L("Editor.Workspace.RenderHeld"), newer, isError: true); + return false; + } await StoreEditAsync(); var status = await _host.StatusAsync(ProjectId); if (_disposed) return false; @@ -386,6 +404,12 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel public async Task SyncAsync(bool quiet = false) { if (_isSyncing) return; + // Settings the server cannot read stay here until it is updated (owner review 1, phase 4): Sync says why. + if (PushBlockedReason is { } newer) + { + if (!quiet) _ui.Notify(Loc.L("Editor.Workspace.NotSent"), newer, isError: true); + return; + } SetSyncing(true); try { @@ -1026,6 +1050,8 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel OnPropertyChanged(nameof(StateText)); OnPropertyChanged(nameof(StateKind)); OnPropertyChanged(nameof(StateToolTip)); + OnPropertyChanged(nameof(PushBlockedReason)); + OnPropertyChanged(nameof(SyncToolTip)); OnPropertyChanged(nameof(MenuToolTip)); OnPropertyChanged(nameof(MenuName)); OnPropertyChanged(nameof(HasMediaUpdate)); @@ -1044,6 +1070,7 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel OnPropertyChanged(nameof(CopyOriginalsToolTip)); OnPropertyChanged(nameof(ProxiesOnlyToolTip)); _updateMedia.RaiseCanExecuteChanged(); + _sync.RaiseCanExecuteChanged(); CommandManager.InvalidateRequerySuggested(); } } diff --git a/src/Chronos.Core.Windows/MediaFoundation/MediaFoundationEncoderProvider.cs b/src/Chronos.Core.Windows/MediaFoundation/MediaFoundationEncoderProvider.cs index 6e5d95ad..d4fc9499 100644 --- a/src/Chronos.Core.Windows/MediaFoundation/MediaFoundationEncoderProvider.cs +++ b/src/Chronos.Core.Windows/MediaFoundation/MediaFoundationEncoderProvider.cs @@ -1,5 +1,6 @@ using System.Runtime.InteropServices; using Chronos.Core.Diagnostics; +using Chronos.Core.Export; using Chronos.Core.Video; using Chronos.Core.Windows.Interop; @@ -13,7 +14,8 @@ namespace Chronos.Core.Windows.MediaFoundation; public sealed class MediaFoundationEncoderProvider : IVideoEncoderProvider { private const string LogCategory = MediaFoundationEncoders.LogCategory; - private const int SoftwareH264MaxWidth = 4096, SoftwareH264MaxHeight = 2304; // Microsoft H.264 encoder, level 5.2 + // Microsoft H.264 encoder, level 5.2: long edge × short edge, portrait UHD included (EncoderSelector.Takes). + private const int SoftwareH264MaxWidth = 4096, SoftwareH264MaxHeight = 2304; private readonly Lazy> _capabilities = new(BuildCapabilities); public string Name => "Media Foundation"; @@ -25,7 +27,7 @@ public sealed class MediaFoundationEncoderProvider : IVideoEncoderProvider if (!SettingsSupported(settings)) return false; foreach (var c in Capabilities) { - if (Fits(c.Codec, c.Name, c.Hardware, c.SupportsTenBit, settings) && settings.Width <= c.MaxWidth && settings.Height <= c.MaxHeight) return true; + if (Fits(c.Codec, c.Name, c.Hardware, c.SupportsTenBit, settings) && EncoderSelector.Takes(c, settings.Width, settings.Height)) return true; } return false; } diff --git a/src/Chronos.Core/Export/EncoderSelector.cs b/src/Chronos.Core/Export/EncoderSelector.cs index 801baeb4..b4338b94 100644 --- a/src/Chronos.Core/Export/EncoderSelector.cs +++ b/src/Chronos.Core/Export/EncoderSelector.cs @@ -182,6 +182,17 @@ public static class EncoderSelector return new EncoderSelection { Status = EncoderSelectionStatus.Unavailable, Settings = settings, Notices = notices }; } + /// + /// The capability's size limit takes a × frame either way round: the + /// limit is a long edge × short edge (owner review 1, phase 4: Media Foundation's software H.264 encoder, announced as + /// 4096×2304, writes portrait UHD 2160×3840 too; checked on a real encode). + /// + public static bool Takes(EncoderCapability capability, int width, int height) + { + ArgumentNullException.ThrowIfNull(capability); + return (width <= capability.MaxWidth && height <= capability.MaxHeight) || (height <= capability.MaxWidth && width <= capability.MaxHeight); + } + private static List<(IVideoEncoderProvider Provider, EncoderCapability Capability)> Candidates(IReadOnlyList providers, VideoCodec codec) => [.. providers.SelectMany(p => p.Capabilities.Where(c => c.Codec == codec).Select(c => (p, c)))]; @@ -203,12 +214,16 @@ public static class EncoderSelector s = s with { Width = check.SuggestedWidth, Height = check.SuggestedHeight }; notices.Add(new EncoderNotice(EncoderNotices.ResolutionCappedByLevel, check.HighestLevel.Name, Size(s))); } - if (s.Width > capability.MaxWidth || s.Height > capability.MaxHeight) + if (!Takes(capability, s.Width, s.Height)) { - var scale = double.Min((double)capability.MaxWidth / s.Width, (double)capability.MaxHeight / s.Height); + // The limit turned to the frame's orientation (long edge × short edge, Takes). + var (maxWidth, maxHeight) = (s.Width >= s.Height) == (capability.MaxWidth >= capability.MaxHeight) + ? (capability.MaxWidth, capability.MaxHeight) + : (capability.MaxHeight, capability.MaxWidth); + var scale = double.Min((double)maxWidth / s.Width, (double)maxHeight / s.Height); var width = int.Max(2, (int)(s.Width * scale) & ~1); var height = int.Max(2, (int)double.Round(width * (double)s.Height / s.Width / 2) * 2); - if (height > capability.MaxHeight) height = capability.MaxHeight & ~1; + if (height > maxHeight) height = maxHeight & ~1; s = s with { Width = width, Height = height }; notices.Add(new EncoderNotice(EncoderNotices.ResolutionCappedByEncoder, capability.Name, Size(s))); } diff --git a/src/Chronos.Data/Processing/Jobs/ManagedRenderJobHandler.cs b/src/Chronos.Data/Processing/Jobs/ManagedRenderJobHandler.cs index 63c6c6b2..56a409eb 100644 --- a/src/Chronos.Data/Processing/Jobs/ManagedRenderJobHandler.cs +++ b/src/Chronos.Data/Processing/Jobs/ManagedRenderJobHandler.cs @@ -2,6 +2,8 @@ using Chronos.Core.Diagnostics; 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.Jobs; using Chronos.Protocol; @@ -32,8 +34,11 @@ internal sealed class ManagedRenderJobHandler(RenderJobHandler render, Processin try { parameters = ProcessingJobs.ReadParameters(job.ParametersJson); - // Most jobs are decided by the main codec, before the export is read. - if (Produces(parameters.Codec) && RenderJobHandler.Targets(ProcessingJobs.ReadExport(parameters.PresetJson), parameters.PresetName).All(t => Produces(t.Export))) + // Most jobs are decided by the main codec, before the export is read. The job's own output is checked at the size the + // job names (the server's: the chosen proportions fitted in a fixed-size preset, owner review 1, phase 4). + if (Produces(parameters.Codec) && RenderJobHandler.Targets(ProcessingJobs.ReadExport(parameters.PresetJson), parameters.PresetName) + .Select((t, i) => i == 0 && t.Export is { Width: > 0, Height: > 0 } ? Produces(t.Export, parameters.Width, parameters.Height) : Produces(t.Export)) + .All(produced => produced)) return true; } catch (Exception ex) when (ex is not OperationCanceledException) @@ -55,7 +60,7 @@ internal sealed class ManagedRenderJobHandler(RenderJobHandler render, Processin } public Task RunAsync(JobContext context) => - render.RunAsync(context, target => Produces(target.Export) ? target : Fallback(context, target)); + render.RunAsync(context, (target, project) => Produces(target.Export, project) ? target : Fallback(context, target)); /// The output as MJPEG in AVI with the managed preset's quality, at the size and frame rate asked for. private static ExportTarget Fallback(JobContext context, ExportTarget target) @@ -83,6 +88,21 @@ internal sealed class ManagedRenderJobHandler(RenderJobHandler render, Processin private bool Produces(string codec) => _capabilities.Any(c => string.Equals(ProcessingJobs.CodecName(c.Codec), codec, StringComparison.OrdinalIgnoreCase)); - private bool Produces(ResolvedExport export) => - _capabilities.Any(c => c.Codec == export.Codec && export.Width <= c.MaxWidth && export.Height <= c.MaxHeight); + /// A managed encoder writes at the preset's size (a free-size preset is not checked by size). + private bool Produces(ResolvedExport export) => Produces(export, export.Width, export.Height); + + /// + /// A managed encoder writes at the size gives it: a fixed-size preset + /// adapted to the chosen proportions (, 4K at 9:16 = 2160×3840). + /// + private bool Produces(ResolvedExport export, ProjectSettings project) + { + if (export is not { Width: > 0, Height: > 0 }) return Produces(export); + // A fixed-size preset's output does not depend on the source's size. + var (width, height) = RenderSize.Of(project.Camera, export, export.Width, export.Height); + return Produces(export, width, height); + } + + private bool Produces(ResolvedExport export, int width, int height) => + _capabilities.Any(c => c.Codec == export.Codec && EncoderSelector.Takes(c, width, height)); } diff --git a/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs b/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs index ecf525e1..8b25f92a 100644 --- a/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs +++ b/src/Chronos.Data/Processing/Jobs/RenderJobHandler.cs @@ -30,10 +30,13 @@ internal sealed class RenderJobHandler(ChronosDatabase db, ProcessingOptions opt { public JobKind Kind => JobKind.Render; - public Task RunAsync(JobContext context) => RunAsync(context, target => target); + public Task RunAsync(JobContext context) => RunAsync(context, (target, _) => target); - /// Runs the job with each output still to render passed through (the server's managed stand-ins). - internal async Task RunAsync(JobContext context, Func adapt) + /// + /// Runs the job with each output still to render passed through with the settings rendered (the + /// server's managed stand-ins, which look at the size those settings give the output). + /// + internal async Task RunAsync(JobContext context, Func adapt) { var cancellation = context.Cancellation; var (parameters, export) = ProcessingJobs.ReadRender(context.Job.ParametersJson); @@ -72,7 +75,7 @@ internal sealed class RenderJobHandler(ChronosDatabase db, ProcessingOptions opt Discard(output, keepOutput: recorded.Any(r => r.OutputPath == Stored(paths, output))); names.Release(output); // free again for the entry's new attempt } - var targets = all.Select((t, i) => (i, t)).Where(t => !done.Contains(t.i)).Select(t => (t.i, adapt(t.t))).ToList(); + var targets = all.Select((t, i) => (i, t)).Where(t => !done.Contains(t.i)).Select(t => (t.i, adapt(t.t, project))).ToList(); if (targets.Count == 0) return; var companions = await GprCompanions.FindAsync(db, archive, frames.Frames, cancellation).ConfigureAwait(false); diff --git a/src/Chronos.Data/Processing/ProcessingJobs.cs b/src/Chronos.Data/Processing/ProcessingJobs.cs index e9632516..008ed9ef 100644 --- a/src/Chronos.Data/Processing/ProcessingJobs.cs +++ b/src/Chronos.Data/Processing/ProcessingJobs.cs @@ -5,6 +5,7 @@ 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; @@ -28,15 +29,17 @@ public static class ProcessingJobs /// /// of one sequence. (preset, overrides, name template, /// folder, batch) replaces the project's export section; embeds the settings to render, - /// null renders the sequence's current project. × - /// stands in for a preset without a fixed size, so render nodes can match the job by resolution. + /// null renders the sequence's current project. × (the + /// frames' Exif-oriented size) gives the output size of the settings rendered (; the sequence's + /// own when is null), so render nodes can match the job by resolution, and the settings + /// format the render needs (). /// public static ArchiveJobRequest Render(Sequence sequence, ExportSettings export, int sourceWidth, int sourceHeight, ProjectSettings? project = null, bool useProxies = false) { ArgumentNullException.ThrowIfNull(sequence); ArgumentNullException.ThrowIfNull(export); - var parameters = Parameters(export, sourceWidth, sourceHeight, project?.ToJson(), useProxies); + var parameters = Parameters(export, sourceWidth, sourceHeight, project?.ToJson(), useProxies, project ?? ReadSettings(sequence.SettingsJson)); return new ArchiveJobRequest(JobKind.Render, [sequence.Id], RenderLabel(sequence.DisplayTitle, parameters.PresetName), JsonSerializer.Serialize(parameters, ProtocolJson.Default.RenderJobParameters), JobPriority.User); } @@ -80,20 +83,22 @@ public static class ProcessingJobs /// /// A posted render job as one job per preset, as makes them (a render node uploads one file /// per job): the job itself when it has no batch; otherwise its own preset, then each batch preset with its own values, - /// all with the job's project and proxy choice. × stands in - /// for a batch preset without a fixed size. + /// all with the job's project and proxy choice. × (the + /// frames' Exif-oriented size) stands in for a batch preset without a fixed size. With the + /// the job renders, every job gets the output size and the settings format its render needs (); + /// without them, the job keeps the size it was posted with and each batch preset its preset's. /// /// The preset JSON is not an export section. - public static IReadOnlyList Split(RenderJobParameters parameters, int sourceWidth, int sourceHeight) + public static IReadOnlyList Split(RenderJobParameters parameters, int sourceWidth, int sourceHeight, ProjectSettings? settings = null) { ArgumentNullException.ThrowIfNull(parameters); var export = ReadExport(parameters.PresetJson); var batch = BatchPresets(export).ToList(); - if (batch.Count == 0) return [parameters]; + var own = batch.Count == 0 ? parameters : parameters with { PresetJson = JsonSerializer.Serialize(export with { Batch = [] }, ProcessingJson.Default.ExportSettings) }; return [ - parameters with { PresetJson = JsonSerializer.Serialize(export with { Batch = [] }, ProcessingJson.Default.ExportSettings) }, - .. batch.Select(id => Parameters(BatchExport(export, id), sourceWidth, sourceHeight, parameters.SettingsJson, parameters.UseProxies) with + settings is null ? own : Routed(own, settings, sourceWidth, sourceHeight), + .. batch.Select(id => Parameters(BatchExport(export, id), sourceWidth, sourceHeight, parameters.SettingsJson, parameters.UseProxies, settings) with { ProjectId = parameters.ProjectId, ProjectVersionId = parameters.ProjectVersionId, @@ -101,6 +106,61 @@ public static class ProcessingJobs ]; } + /// + /// A render job's parameters with the output size and the settings format a render of needs + /// (owner review 1, phase 4: the chosen proportions win over a fixed-size preset, a quarter turn swaps a source-sized + /// output). A fixed-size preset's box is the size the job was posted with: an older client posts the preset's, this one + /// the adapted size, which adapts to itself. Other presets are sized on the source. The format is at least the one the + /// job was posted with. + /// + /// The preset JSON is not an export section. + public static RenderJobParameters Routed(RenderJobParameters parameters, ProjectSettings settings, int sourceWidth, int sourceHeight) + { + ArgumentNullException.ThrowIfNull(parameters); + ArgumentNullException.ThrowIfNull(settings); + var resolved = ExportResolver.Resolve(ReadExport(parameters.PresetJson)); + var box = resolved.Width > 0 && resolved.Height > 0 && parameters.Width > 0 && parameters.Height > 0 + ? resolved with { Width = parameters.Width, Height = parameters.Height } + : resolved; + var (width, height) = Size(settings, box, sourceWidth, sourceHeight) ?? (parameters.Width, parameters.Height); + return parameters with + { + Width = width, + Height = height, + RequiredSettingsFormat = int.Max(parameters.RequiredSettingsFormat, RequiredFormat(settings, resolved, sourceWidth, sourceHeight)), + }; + } + + /// + /// The settings format a render of with and each of its batch + /// presets needs (the highest of them): what a server or a render node must read + /// to render it as this Chronos would. + /// + public static int RequiredFormat(ProjectSettings settings, ExportSettings export, int sourceWidth, int sourceHeight) + { + ArgumentNullException.ThrowIfNull(settings); + ArgumentNullException.ThrowIfNull(export); + return BatchPresets(export).Select(id => ExportResolver.Resolve(BatchExport(export, id))).Prepend(ExportResolver.Resolve(export)) + .Max(resolved => RequiredFormat(settings, resolved, sourceWidth, sourceHeight)); + } + + /// + /// Project settings read for their output size and format, a newer Chronos's too (its format stands); null when there + /// are none or the text is not a project. + /// + public static ProjectSettings? ReadSettings(string? settingsJson) + { + if (string.IsNullOrWhiteSpace(settingsJson)) return null; + try + { + return ProjectSettings.FromJson(settingsJson, allowNewer: true); + } + catch (JsonException) + { + return null; + } + } + /// /// One job per preset of : its preset, then each batch preset with its /// own values. For a server: a render node uploads one file per job, so a batch must not travel as one job. @@ -128,13 +188,27 @@ public static class ProcessingJobs internal static ExportSettings BatchExport(ExportSettings export, string presetId) => new() { Preset = new Auto().WithManual(presetId), NameTemplate = export.NameTemplate, Folder = export.Folder }; - private static RenderJobParameters Parameters(ExportSettings export, int sourceWidth, int sourceHeight, string? settingsJson, bool useProxies) + /// The settings rendered, for the output size and the format (else read from ); unknown, the preset's size. + private static RenderJobParameters Parameters(ExportSettings export, int sourceWidth, int sourceHeight, string? settingsJson, bool useProxies, + ProjectSettings? settings = null) { var resolved = ExportResolver.Resolve(export); + settings ??= ReadSettings(settingsJson); + var (width, height) = (settings is null ? null : Size(settings, resolved, sourceWidth, sourceHeight)) + ?? (resolved.Width > 0 ? resolved.Width : sourceWidth, resolved.Height > 0 ? resolved.Height : sourceHeight); + var format = settings is null ? ProjectSettings.BaseVersion : RequiredFormat(settings, resolved, sourceWidth, sourceHeight); return new RenderJobParameters(PresetName(resolved), JsonSerializer.Serialize(export, ProcessingJson.Default.ExportSettings), CodecName(resolved.Codec), - resolved.Width > 0 ? resolved.Width : sourceWidth, resolved.Height > 0 ? resolved.Height : sourceHeight, useProxies, settingsJson); + width, height, useProxies, settingsJson, RequiredSettingsFormat: format); } + /// The output size of with (); null without a source size. + private static (int Width, int Height)? Size(ProjectSettings settings, ResolvedExport export, int sourceWidth, int sourceHeight) => + sourceWidth > 0 && sourceHeight > 0 ? RenderSize.Of(settings.Camera, export, sourceWidth, sourceHeight) : null; + + /// ; without a source size, the format the settings are written in. + private static int RequiredFormat(ProjectSettings settings, ResolvedExport export, int sourceWidth, int sourceHeight) => + sourceWidth > 0 && sourceHeight > 0 ? RenderRules.RequiredFormat(settings, export, sourceWidth, sourceHeight) : settings.WrittenFormat; + /// Codec name in job parameters and render-node capabilities ("h264", "hevc", "mjpeg", "pngsequence"…). public static string CodecName(VideoCodec codec) => codec.ToString().ToLowerInvariant(); diff --git a/src/Chronos.Data/Processing/ProjectStore.cs b/src/Chronos.Data/Processing/ProjectStore.cs index 915e4648..8d9dafd3 100644 --- a/src/Chronos.Data/Processing/ProjectStore.cs +++ b/src/Chronos.Data/Processing/ProjectStore.cs @@ -1,6 +1,7 @@ using System.Text.Json; using Chronos.Core.Archiving; using Chronos.Core.IO; +using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data.Archiving; @@ -22,7 +23,10 @@ internal sealed class ProjectStore(ChronosDatabase db, SequenceWriter writer) public static ProjectSettings Read(Sequence sequence, SequencePaths folder) => Parse(sequence.SettingsJson ?? (File.Exists(folder.ProjectPath) ? AtomicFile.ReadAllText(folder.ProjectPath) : null)); - /// The settings are not valid JSON or come from a newer Chronos. + /// + /// The settings are not valid JSON, or come from a newer Chronos (Errors.Render.NewerSettings, which a render's + /// job shows as its error). + /// public static ProjectSettings Parse(string? json) { if (string.IsNullOrWhiteSpace(json)) return new ProjectSettings(); @@ -34,6 +38,11 @@ internal sealed class ProjectStore(ChronosDatabase db, SequenceWriter writer) { throw new InvalidDataException(ex.Message, ex); } + catch (InvalidDataException ex) + { + // A settings format above this Chronos's (owner review 1, phase 4: a server, a node or a desktop that is older). + throw new InvalidDataException(Loc.L("Errors.Render.NewerSettings"), ex); + } } /// Applies to the settings in force and stores the result when it differs; false when nothing changed. diff --git a/src/Chronos.Data/Processing/RenderNodeClient.cs b/src/Chronos.Data/Processing/RenderNodeClient.cs index 377eb994..5108bab3 100644 --- a/src/Chronos.Data/Processing/RenderNodeClient.cs +++ b/src/Chronos.Data/Processing/RenderNodeClient.cs @@ -7,6 +7,7 @@ using Chronos.Core.Export; using Chronos.Core.Imaging; using Chronos.Core.Localization; using Chronos.Core.Model; +using Chronos.Core.Project; using Chronos.Core.Render; using Chronos.Core.Video; using Chronos.Data.Archiving; @@ -117,10 +118,11 @@ public sealed class RenderNodeClient : IAsyncDisposable /// Registers this node (again) and returns its id. public async Task RegisterAsync(CancellationToken cancellationToken) { - // Each encoder carries its own limit; the node-wide one (for servers that read only that) is the largest offered. + // Each encoder carries its own limit; the node-wide one (for servers that read only that) is the largest offered. The + // settings format the node reads keeps it from jobs it would render otherwise than asked (owner review 1, phase 4). var encoders = Encoders; var request = new RegisterNodeRequest(_options.ClientName, encoders, encoders.Select(e => e.MaxWidth).DefaultIfEmpty().Max(), - encoders.Select(e => e.MaxHeight).DefaultIfEmpty().Max()); + encoders.Select(e => e.MaxHeight).DefaultIfEmpty().Max(), ProjectSettings.CurrentVersion); var node = await _client.RegisterNodeAsync(request, cancellationToken).ConfigureAwait(false); _nodeId = node.Id; return node.Id; diff --git a/src/Chronos.Data/Projects/IProjectHome.cs b/src/Chronos.Data/Projects/IProjectHome.cs index e8bbd859..6776bd4f 100644 --- a/src/Chronos.Data/Projects/IProjectHome.cs +++ b/src/Chronos.Data/Projects/IProjectHome.cs @@ -76,6 +76,12 @@ public interface IProjectHome /// then. Null from a home that keeps none: the frames are read every time. /// Task FramesStampAsync(CancellationToken cancellationToken) => Task.FromResult(null); + + /// + /// The highest project settings format the home stores and renders (owner review 1, phase 4); a version of a higher one + /// is not pushed to it (an older server refuses it, 422 newer_format). This PC's archive reads what this Chronos does. + /// + int SettingsFormat => ProjectSettings.CurrentVersion; } /// A sequence of this PC's archive as its projects' home: the archive's . diff --git a/src/Chronos.Data/Projects/ServerProjectHome.cs b/src/Chronos.Data/Projects/ServerProjectHome.cs index 30386207..7f97ddb3 100644 --- a/src/Chronos.Data/Projects/ServerProjectHome.cs +++ b/src/Chronos.Data/Projects/ServerProjectHome.cs @@ -27,15 +27,20 @@ public sealed class ServerProjectHome : IProjectHome private const int MaxPage = 200; /// The server's name as its server/info gives it, for the project file; the address's host when null. - public ServerProjectHome(ChronosClient client, Guid sequenceId, string? serverName = null) + /// The settings format its server/info announces (); null, an older server's 1. + public ServerProjectHome(ChronosClient client, Guid sequenceId, string? serverName = null, int? settingsFormat = null) { ArgumentNullException.ThrowIfNull(client); Client = client; SequenceId = sequenceId; Server = SyncService.ServerKey(client.BaseAddress); ServerName = string.IsNullOrWhiteSpace(serverName) ? client.BaseAddress.Host : serverName.Trim(); + SettingsFormat = settingsFormat is > 0 and var format ? format : ProjectSettings.BaseVersion; } + /// The highest settings format the server reads (owner review 1, phase 4); 1 for an older server, which does not announce it. + public int SettingsFormat { get; } + public ChronosClient Client { get; } /// The server's sequence. diff --git a/src/Chronos.Server/Api/JobEndpoints.cs b/src/Chronos.Server/Api/JobEndpoints.cs index e919a9a7..9f40e190 100644 --- a/src/Chronos.Server/Api/JobEndpoints.cs +++ b/src/Chronos.Server/Api/JobEndpoints.cs @@ -1,6 +1,7 @@ using System.Text.Json; using Microsoft.AspNetCore.Mvc; using Chronos.Core.Model; +using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Jobs; @@ -102,20 +103,20 @@ public static class JobEndpoints // A render of a project version (owner review 2, R8): of the sequence's projects, a project alone pinned to its head. var (render, missing) = await ProjectRenderAsync(db, archives, targets[0], parsed, ct); if (missing is not null) return ApiErrors.NotFound(context, missing); - var parametersJson = render == parsed ? request.ParametersJson : JsonSerializer.Serialize(render, ProtocolJson.Default.RenderJobParameters); - // A batch becomes one job per preset: a render node uploads one file per job (BRIEF §14.7). + // A batch becomes one job per preset: a render node uploads one file per job (BRIEF §14.7). Each gets the size and the + // settings format of the settings it renders (owner review 1, phase 4), so it goes only to a node that renders it as asked. IReadOnlyList each; try { var (width, height) = await SourceSizeAsync(db, targets[0], render, ct); - each = ProcessingJobs.Split(render, width, height); + each = ProcessingJobs.Split(render, width, height, await RenderedSettingsAsync(db, targets[0], render, ct)); } catch (InvalidDataException) { return ApiErrors.BadRequest(context, "invalid_parameters", "parametersJson"); } - queue = each.Count == 1 - ? [(ProcessingJobs.RenderLabel(label, render.PresetName), parametersJson)] + queue = each is [var one] && one == parsed + ? [(ProcessingJobs.RenderLabel(label, render.PresetName), request.ParametersJson)] : [.. each.Select(p => (ProcessingJobs.RenderLabel(label, p.PresetName), (string?)JsonSerializer.Serialize(p, ProtocolJson.Default.RenderJobParameters)))]; } else if (request.ParametersJson is not null && !IsJsonObject(request.ParametersJson)) @@ -186,8 +187,22 @@ public static class JobEndpoints } } + /// + /// The settings a render job renders, for its size and settings format: those it embeds, else the project version's it + /// names, else the sequence's own; a newer Chronos's too (their format stands). Null when they cannot be read (or the + /// version is not there): the job keeps the size it was posted with, and its render says why it cannot read them. + /// + internal static async Task RenderedSettingsAsync(ChronosDatabase db, Guid sequenceId, RenderJobParameters render, CancellationToken ct) + { + if (render.SettingsJson is { } embedded) return ProcessingJobs.ReadSettings(embedded); + if (render.ProjectVersionId is { } versionId) + return await db.Projects.GetVersionAsync(versionId, ct) is { } version ? ProcessingJobs.ReadSettings(version.SettingsJson) : null; + if (await db.Sequences.GetAsync(sequenceId, ct) is not { } sequence) return null; + return sequence.SettingsJson is null ? new ProjectSettings() : ProcessingJobs.ReadSettings(sequence.SettingsJson); + } + /// The oriented size of the sequence's first frame (what a preset without a fixed size renders at), else the job's size. - private static async Task<(int Width, int Height)> SourceSizeAsync(ChronosDatabase db, Guid sequenceId, RenderJobParameters render, CancellationToken ct) => + internal static async Task<(int Width, int Height)> SourceSizeAsync(ChronosDatabase db, Guid sequenceId, RenderJobParameters render, CancellationToken ct) => (await db.Frames.ListBySequenceAsync(sequenceId, limit: 1, cancellationToken: ct)).FirstOrDefault() is { Width: > 0, Height: > 0 } frame ? frame.Orientation is >= 5 and <= 8 ? (frame.Height, frame.Width) : (frame.Width, frame.Height) : (render.Width, render.Height); diff --git a/src/Chronos.Server/Api/SystemEndpoints.cs b/src/Chronos.Server/Api/SystemEndpoints.cs index 1525d7c0..949e8e8e 100644 --- a/src/Chronos.Server/Api/SystemEndpoints.cs +++ b/src/Chronos.Server/Api/SystemEndpoints.cs @@ -2,6 +2,7 @@ using System.Globalization; using System.Reflection; using Chronos.Core.Imaging; using Chronos.Core.Localization; +using Chronos.Core.Project; using Chronos.Data; using Chronos.Protocol; using Chronos.Server.Configuration; @@ -47,7 +48,8 @@ public static class SystemEndpoints state.TlsFingerprint, ["jpeg", "png", "tiff", "dng", "cr2", "cr3", "nef", "arw", "raf", "orf", "rw2", "pef", "heic", "webp"], new ServerLimits(options.MaxUploadBytes, options.ChunkSizeBytes, PasswordHasher.MinimumLength), - PhotoExtensions), ProtocolJson.Default.ServerInfo)).AllowAnonymousCaller(); + PhotoExtensions, + ProjectSettings.CurrentVersion), ProtocolJson.Default.ServerInfo)).AllowAnonymousCaller(); api.MapGet("/i18n/{culture}", (string culture) => { diff --git a/src/Chronos.Server/Jobs/RenderNodeAvailability.cs b/src/Chronos.Server/Jobs/RenderNodeAvailability.cs index f2702816..c19712d4 100644 --- a/src/Chronos.Server/Jobs/RenderNodeAvailability.cs +++ b/src/Chronos.Server/Jobs/RenderNodeAvailability.cs @@ -11,8 +11,9 @@ namespace Chronos.Server.Jobs; /// Whether a queued render job that needs a platform encoder still waits for a render node (BRIEF §14.7); once it does /// not, the server's own engine renders it in a managed format. A job waits at least as long as a node may stay silent /// (), so a node that is restarting or reconnecting takes it back, and -/// then as long as an online node can encode its codec at its size. The server's render handler asks for every queued -/// job it examines, so the online nodes are read at most once a second. +/// then as long as an online node reads the settings format it needs () +/// and can encode its codec at its size. The server's render handler asks for every queued job it examines, so the online +/// nodes are read at most once a second. /// public sealed class RenderNodeAvailability(ChronosDatabase db, ServerOptions options, TimeProvider time) { @@ -34,7 +35,7 @@ public sealed class RenderNodeAvailability(ChronosDatabase db, ServerOptions opt snapshot = new Snapshot(Stopwatch.GetTimestamp(), [.. online.Select(Dto.Capabilities).OfType()]); Volatile.Write(ref _snapshot, snapshot); } - return snapshot.Nodes.Any(node => RenderNodeService.CanEncode(node, parameters)); + return snapshot.Nodes.Any(node => RenderNodeService.Renders(node, parameters)); } /// What the online nodes announced, and when it was read (a timestamp). diff --git a/src/Chronos.Server/Jobs/RenderNodeService.cs b/src/Chronos.Server/Jobs/RenderNodeService.cs index 668dd023..0b3318ee 100644 --- a/src/Chronos.Server/Jobs/RenderNodeService.cs +++ b/src/Chronos.Server/Jobs/RenderNodeService.cs @@ -6,6 +6,7 @@ using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Jobs; +using Chronos.Data.Processing; using Chronos.Data.Projects; using Chronos.Data.Repositories; using Chronos.Protocol; @@ -86,7 +87,10 @@ public sealed class RenderNodeService( // A render the server's own engine started (it left a checkpoint) resumes there: only it knows that attempt's // leftovers and the batch entries it recorded. if (queued.Checkpoint is not null) continue; - if (JobEndpoints.ParseRender(queued.ParametersJson) is not { } parameters || capabilities is null || !CanEncode(capabilities, parameters)) continue; + if (JobEndpoints.ParseRender(queued.ParametersJson) is not { } parameters || capabilities is null || !Renders(capabilities, parameters)) continue; + // What the job renders now decides too (owner review 1, phase 4): the sequence's own settings may have changed + // since it was queued, and a job of an older server carries no settings format. + if (await RoutedAsync(queued, parameters, cancellationToken) is { } routed && !Renders(capabilities, routed)) continue; if (await db.Jobs.TryClaimAsync(queued.Id, NodeKey(node), cancellationToken) is not { } job) continue; jobs.Publish(job); if (job.TargetIds.Count != 1 || await db.Sequences.GetAsync(job.TargetIds[0], cancellationToken) is not { } sequence) @@ -134,6 +138,27 @@ public sealed class RenderNodeService( : null; } + /// + /// The job's parameters with the output size and settings format of the settings a node would render now + /// (); null when they cannot be told (no sequence, settings that cannot be read, a + /// version that is not the sequence's), which the claim reports as it does today. + /// + private async Task RoutedAsync(Job queued, RenderJobParameters parameters, CancellationToken cancellationToken) + { + if (queued.TargetIds is not [var sequenceId] || await db.Sequences.GetAsync(sequenceId, cancellationToken) is not { } sequence) return null; + if (await SettingsAsync(parameters, sequence, cancellationToken) is not { } settings || ProcessingJobs.ReadSettings(settings.Json) is not { } read) return null; + try + { + var (width, height) = await JobEndpoints.SourceSizeAsync(db, sequence.Id, parameters, cancellationToken); + return ProcessingJobs.Routed(parameters, read, width, height); + } + catch (InvalidDataException) + { + // Not an export section: the render says so. + return null; + } + } + /// Settings with positions that wait for their photos (a project version's portable form, settings synced from another copy). private static bool Waits(string settingsJson) => settingsJson.Contains("pendingFrames", StringComparison.OrdinalIgnoreCase); @@ -311,14 +336,25 @@ public sealed class RenderNodeService( if (state != node.State) events.Publish(new NodeStateEvent(node.Id, node.ClientName, state)); } + /// + /// The node renders the job as asked: it reads the settings format the job needs (, + /// 1 for an older node) and can encode it (). + /// + internal static bool Renders(RegisterNodeRequest node, RenderJobParameters job) => job.RequiredSettingsFormat <= node.SettingsFormat && CanEncode(node, job); + /// /// The node has an encoder for the job's codec that handles its resolution: the encoder's own limit, else the node's - /// (0 = no announced limit). + /// (0 = no announced limit). A node of settings format 2 or more takes the limit as a long edge × short edge, as its + /// encoders do (: portrait UHD on a 4096×2304 encoder); an older node + /// would shrink a portrait frame to the limit as announced, so it is held to it. /// internal static bool CanEncode(RegisterNodeRequest node, RenderJobParameters job) => node.Encoders.Any(e => string.Equals(e.Codec, job.Codec, StringComparison.OrdinalIgnoreCase) - && Fits(job.Width, e.MaxWidth > 0 ? e.MaxWidth : node.MaxWidth) - && Fits(job.Height, e.MaxHeight > 0 ? e.MaxHeight : node.MaxHeight)); + && Fits(job.Width, job.Height, e.MaxWidth > 0 ? e.MaxWidth : node.MaxWidth, e.MaxHeight > 0 ? e.MaxHeight : node.MaxHeight, + eitherWay: node.SettingsFormat >= 2)); + + private static bool Fits(int width, int height, int maxWidth, int maxHeight, bool eitherWay) => + (Fits(width, maxWidth) && Fits(height, maxHeight)) || (eitherWay && Fits(height, maxWidth) && Fits(width, maxHeight)); private static bool Fits(int size, int limit) => limit <= 0 || size <= limit; diff --git a/tests/Chronos.App.Tests/Workspace/ServerHomeTests.cs b/tests/Chronos.App.Tests/Workspace/ServerHomeTests.cs index a9755843..43343f78 100644 --- a/tests/Chronos.App.Tests/Workspace/ServerHomeTests.cs +++ b/tests/Chronos.App.Tests/Workspace/ServerHomeTests.cs @@ -244,6 +244,55 @@ public sealed class ServerHomeTests(TestContext context) } } + [Test] + public async Task AServerThatReadsAnOlderFormatIsNotSentSettingsItCannotRead() + { + Assert.Null(ServerJobs.NeedsNewerServer(ProjectSettings.BaseVersion, ProjectSettings.BaseVersion)); + Assert.Equal(Loc.L("Tooltips.Server.NeedsNewerServer"), ServerJobs.NeedsNewerServer(2, ProjectSettings.BaseVersion)); + // A server that says no format reads the base one; a session-less home too. + Assert.Equal(ProjectSettings.BaseVersion, Chronos.App.Server.SyncHost.SettingsFormatOf(new ServerInfo("Studio NAS", "1.3.0", 1, [], null, [], new ServerLimits(0, 0)))); + Assert.Equal(ProjectSettings.BaseVersion, Chronos.App.Server.SyncHost.SettingsFormatOf(null)); + Assert.Equal(ProjectSettings.CurrentVersion, Chronos.App.Server.SyncHost.SettingsFormatOf( + new ServerInfo("Studio NAS", "1.4.0", 1, [], null, [], new ServerLimits(0, 0), SettingsFormat: ProjectSettings.CurrentVersion))); + + await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); + var host = bed.Host(new AppSettings { WorkspaceAutoSync = false, WorkspaceVersionOnRender = false }); + var server = new FakeServer(bed) { SettingsFormat = ProjectSettings.BaseVersion }; + Connect(host, server); + var projectId = await CheckoutAsync(bed, host); + var source = new WorkspaceSequenceSource(host.Sync, projectId, bed.Db, DecoderFactory.CreateClient(null), bed.Engine, + new WorkspaceServerHome(() => null, () => null)); + var content = await source.LoadAsync(bed.Ct); + var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); + var ui = new RecordingUi(); + await using (session) + using (var menu = new ProjectMenuViewModel(host, source, session, ui)) + { + await menu.RefreshAsync(); + // A change of the base format goes to the older server as before. + Assert.True(session.SetHero(2)); + Assert.Null(menu.PushBlockedReason); + Assert.True(menu.SyncCommand.CanExecute(null)); + + // A turn needs format 2: Sync is disabled saying why, and a render of it is held. + Assert.True(session.Edit(p => p with { Camera = p.Camera with { Rotate = 90 } })); + Assert.True(await session.FlushAsync()); + Assert.Equal(Loc.L("Tooltips.Server.NeedsNewerServer"), menu.PushBlockedReason); + Assert.Equal(menu.PushBlockedReason, menu.SyncToolTip); + Assert.False(menu.SyncCommand.CanExecute(null)); + Assert.False(await menu.ReadyToRenderAsync(), "the server cannot read it"); + Assert.Equal((Loc.L("Editor.Workspace.RenderHeld"), true), (ui.Toasts[^1].Title, ui.Toasts[^1].IsError)); + var before = host.Store.Find(projectId)!.ReadBundle().Workspace!.Base!.VersionId; + await menu.SyncAsync(); + Assert.Equal(before, host.Store.Find(projectId)!.ReadBundle().Workspace!.Base!.VersionId, "nothing was sent"); + + // A server of this format takes it. + server.SettingsFormat = ProjectSettings.CurrentVersion; + Assert.Null(menu.PushBlockedReason); + Assert.True(menu.SyncCommand.CanExecute(null)); + } + } + /// The home a workspace project of the test sequence names on . private static BundleHome ServerHome(WorkspaceTestBed bed) => new(BundleHome.ServerKind, bed.SequenceId, null, Server); @@ -276,6 +325,9 @@ public sealed class ServerHomeTests(TestContext context) public HashSet Deleted { get; } = []; + /// The settings format the server reads, as its info says. + public int SettingsFormat { get; set; } = ProjectSettings.CurrentVersion; + public async Task SequenceAsync(CancellationToken cancellationToken) { var sequence = await Reach(() => Inner.SequenceAsync(cancellationToken)); diff --git a/tests/Chronos.Core.Tests/Export/EncoderSelectorTests.cs b/tests/Chronos.Core.Tests/Export/EncoderSelectorTests.cs index c3347578..8185b09d 100644 --- a/tests/Chronos.Core.Tests/Export/EncoderSelectorTests.cs +++ b/tests/Chronos.Core.Tests/Export/EncoderSelectorTests.cs @@ -128,6 +128,22 @@ public sealed class EncoderSelectorTests Assert.Equal((1080, 606), (odd.Settings.Width, odd.Settings.Height)); } + [Test] + public void APortraitFrameReadsTheLimitTurned() + { + // An encoder announced as 4096×2304 takes 4K at 9:16: its limit is long edge × short edge. + var portrait = EncoderSelector.Select(Request(VideoCodec.H264, 2160, 3840), Client(SoftwareH264), EncoderHost.Client); + Assert.Equal((2160, 3840), (portrait.Settings.Width, portrait.Settings.Height)); + Assert.False(portrait.Notices.Any(n => n.Key is EncoderNotices.ResolutionCappedByEncoder or EncoderNotices.ResolutionCappedByLevel), "not capped"); + + var capped = EncoderSelector.Select(Request(VideoCodec.H264, 4320, 7680), Client(SoftwareH264), EncoderHost.Client); + Assert.Equal((2304, 4096), (capped.Settings.Width, capped.Settings.Height)); + Assert.True(capped.Notices.Any(n => n.Key == EncoderNotices.ResolutionCappedByEncoder)); + + Assert.True(EncoderSelector.Takes(SoftwareH264, 2304, 4096)); + Assert.False(EncoderSelector.Takes(SoftwareH264, 2400, 3840), "the short edge is over the limit"); + } + [Test] public void BitRateIsCappedByTheHighestLevel() { diff --git a/tests/Chronos.Core.Tests/Render/CapturingEncoderProvider.cs b/tests/Chronos.Core.Tests/Render/CapturingEncoderProvider.cs index 9ce98ac7..9d4fc14c 100644 --- a/tests/Chronos.Core.Tests/Render/CapturingEncoderProvider.cs +++ b/tests/Chronos.Core.Tests/Render/CapturingEncoderProvider.cs @@ -1,3 +1,4 @@ +using Chronos.Core.Export; using Chronos.Core.Imaging; using Chronos.Core.Video; @@ -26,7 +27,7 @@ internal sealed class CapturingEncoderProvider(string name, params EncoderCapabi public (int Frame, Exception Error)? FailAt { get; set; } public bool CanEncode(EncodeSettings settings) => capabilities.Any(c => - c.Codec == settings.Codec && settings.Width <= c.MaxWidth && settings.Height <= c.MaxHeight && (settings.BitDepth == 8 || c.SupportsTenBit)); + c.Codec == settings.Codec && EncoderSelector.Takes(c, settings.Width, settings.Height) && (settings.BitDepth == 8 || c.SupportsTenBit)); public IVideoEncoderSession Open(EncodeSettings settings) { diff --git a/tests/Chronos.Core.Windows.Tests/MediaFoundation/MediaFoundationEncoderTests.cs b/tests/Chronos.Core.Windows.Tests/MediaFoundation/MediaFoundationEncoderTests.cs index dd24d666..8a9bc2b7 100644 --- a/tests/Chronos.Core.Windows.Tests/MediaFoundation/MediaFoundationEncoderTests.cs +++ b/tests/Chronos.Core.Windows.Tests/MediaFoundation/MediaFoundationEncoderTests.cs @@ -1,3 +1,4 @@ +using Chronos.Core.Export; using Chronos.Core.Imaging; using Chronos.Core.Video; using Chronos.Core.Windows.MediaFoundation; @@ -143,6 +144,61 @@ public sealed class MediaFoundationEncoderTests(TestContext context) Assert.Equal(60, report.FrameCount); } + /// + /// Owner review 1, phase 4: 4K at 9:16 is 2160×3840. Each H.264 encoder of this machine is asked for portrait UHD and + /// its landscape twin: none takes one and refuses the other, so the announced limits are a long edge × short edge + /// (), and portrait UHD is announced wherever landscape UHD is. Encoders that refuse + /// both (Microsoft's DX12 encoder on some GPUs) are left to the provider, which then opens the next one. + /// + [Test] + [WindowsOnly] + [Timeout(180_000)] + public void PortraitUhdH264EncodesWhereLandscapeDoes() + { + RequireMediaFoundation(); + var provider = new MediaFoundationEncoderProvider(); + var h264 = provider.Capabilities.Where(c => c.Codec == VideoCodec.H264).ToList(); + if (h264.Count == 0) TestContext.Skip("No H.264 encoder on this machine"); + foreach (var capability in h264) + { + var (portrait, landscape) = (Accepts(capability, 2160, 3840), Accepts(capability, 3840, 2160)); + Assert.Equal(landscape, portrait, $"{capability.Name} takes portrait UHD as it takes landscape UHD"); + Assert.Equal(EncoderSelector.Takes(capability, 3840, 2160), EncoderSelector.Takes(capability, 2160, 3840), "announced either way round"); + } + var request = Settings(Path.Combine(context.CreateTempDirectory(), "portrait.mp4"), VideoCodec.H264, 8); + Assert.Equal(provider.CanEncode(request with { Width = 3840, Height = 2160 }), provider.CanEncode(request with { Width = 2160, Height = 3840 })); + + bool Accepts(EncoderCapability capability, int width, int height) + { + var settings = Settings(Path.Combine(context.CreateTempDirectory(), $"{width}x{height}.mp4"), VideoCodec.H264, 8) with + { + Width = width, + Height = height, + EncoderName = capability.Name, + PreferHardware = capability.Hardware, + BitRate = 20_000_000, + }; + try + { + using (var session = provider.Open(settings)) + { + using var frame = new ImageBuffer(width, height); + for (var c = 0; c < 3; c++) frame.Plane(c).Fill(0.25f); + for (var f = 0; f < 3; f++) session.WriteFrame(frame, Frame30); + session.Complete(); + } + var report = Mp4Inspector.Inspect(settings.OutputPath); + context.Log($"{capability.Name} {width}×{height}: {report}"); + return report.IsValid && (report.Width, report.Height) == (width, height); + } + catch (NotSupportedException ex) + { + context.Log($"{capability.Name} {width}×{height}: refused ({ex.InnerException?.Message ?? ex.Message})"); + return false; + } + } + } + [Test] [WindowsOnly] [Timeout(60_000)] diff --git a/tests/Chronos.Data.Tests/Processing/ProjectStoreTests.cs b/tests/Chronos.Data.Tests/Processing/ProjectStoreTests.cs new file mode 100644 index 00000000..829bad62 --- /dev/null +++ b/tests/Chronos.Data.Tests/Processing/ProjectStoreTests.cs @@ -0,0 +1,54 @@ +using Chronos.Core.Diagnostics.Synthetic; +using Chronos.Core.Localization; +using Chronos.Core.Project; +using Chronos.Data.Archiving; +using Chronos.Data.Processing; +using Chronos.Testing; + +namespace Chronos.Data.Tests.Processing; + +/// +/// The project of a sequence as the engine reads and writes it (owner review 1, phase 4): a format-1 project stays format 1 +/// through every edit that uses nothing newer, a transform raises it to 2 and its removal brings it back, and settings of +/// a newer Chronos are refused saying so in the user's language. +/// +[Category("processing")] +public sealed class ProjectStoreTests(TestContext context) +{ + [Test] + public async Task AnEditNeverRaisesTheFormatOfAProjectThatUsesNothingNewer() + { + await using var fixture = await ProcessingFixture.CreateAsync(context); + var sequence = await fixture.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { Width = 64, Height = 48, FrameCount = 4 })); + var store = new ProjectStore(fixture.Db, new SequenceWriter(new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) })); + async Task StoredFormatAsync() + { + var row = (await fixture.Db.Sequences.GetAsync(sequence.Id, fixture.Ct))!; + var file = await File.ReadAllTextAsync(fixture.Folder(sequence).ProjectPath, fixture.Ct); + Assert.Equal(row.SettingsJson, file, "the index and project.json hold the same text"); + return ProjectContent.FormatOf(file); + } + + Assert.True(await store.UpdateAsync(fixture.Archive.Paths, sequence, p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.5 } }, fixture.Ct)); + Assert.Equal(ProjectSettings.BaseVersion, await StoredFormatAsync()); + // A read project of the base format is never stamped higher, even when it says the highest this Chronos reads. + Assert.True(await store.UpdateAsync(fixture.Archive.Paths, sequence, p => p with { Version = ProjectSettings.CurrentVersion, HeroFrame = 2 }, fixture.Ct)); + Assert.Equal(ProjectSettings.BaseVersion, await StoredFormatAsync()); + + Assert.True(await store.UpdateAsync(fixture.Archive.Paths, sequence, p => p with { Camera = p.Camera with { Rotate = 90 } }, fixture.Ct)); + Assert.Equal(2, await StoredFormatAsync()); + Assert.True(await store.UpdateAsync(fixture.Archive.Paths, sequence, p => p with { Camera = p.Camera with { Rotate = 0 } }, fixture.Ct)); + Assert.Equal(ProjectSettings.BaseVersion, await StoredFormatAsync()); + Assert.False(await store.UpdateAsync(fixture.Archive.Paths, sequence, p => p with { Version = ProjectSettings.BaseVersion }, fixture.Ct), "nothing changed"); + } + + [Test] + public void SettingsOfANewerChronosAreRefusedSayingSo() + { + var refused = Assert.Throws(() => ProjectStore.Parse("""{"version":3,"camera":{"rotate":90}}""")); + Assert.Equal(Loc.L("Errors.Render.NewerSettings"), refused.Message); + Assert.Equal(90, ProjectStore.Parse("""{"version":2,"camera":{"rotate":90}}""").Camera.Rotate); + // Text that is not a project keeps its own reason. + Assert.NotEqual(Loc.L("Errors.Render.NewerSettings"), Assert.Throws(() => ProjectStore.Parse("[1]")).Message); + } +} diff --git a/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs b/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs index c764a9f1..e68c4aa5 100644 --- a/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs +++ b/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs @@ -599,6 +599,65 @@ public sealed class RenderJobTests(TestContext context) Assert.SequenceEqual(["mjpeg", "gif"], ProcessingJobs.Split(posted, 96, 64).Select(p => p.Codec)); } + /// + /// 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 (). + /// + [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().WithManual("4k-h264") }; + var portrait = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto().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().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"); + 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)); + } + + /// Settings of a newer Chronos fail the render with the reason in the user's language, never as an English message. + [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)); + } + /// MJPEG job parameters whose preset JSON is . 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); diff --git a/tests/Chronos.Server.Tests/Api/ProjectTests.cs b/tests/Chronos.Server.Tests/Api/ProjectTests.cs index 67648ae8..6b53274c 100644 --- a/tests/Chronos.Server.Tests/Api/ProjectTests.cs +++ b/tests/Chronos.Server.Tests/Api/ProjectTests.cs @@ -498,6 +498,42 @@ public sealed class ProjectTests(TestContext context) Assert.Contains(ServerCapabilities.Projects, (await client.GetInfoAsync(context.Cancellation)).Capabilities); } + /// + /// Owner review 1, phase 4: the server announces the settings format it reads, and takes the versions of the formats it + /// reads (1, and 2 with a turn or a look), refusing a newer one with 422 newer_format, nothing stored. + /// + [Test] + public async Task TheServerTakesTheSettingsFormatsItAnnounces() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + using (var anonymous = new ChronosClient(server.HttpBase, new CertificatePinning([]), "tests")) + Assert.Equal(ProjectSettings.CurrentVersion, (await anonymous.GetInfoAsync(context.Cancellation)).SettingsFormat); + Assert.Equal(2, ProjectSettings.CurrentVersion); + + var (http, _, token) = await server.UserAsync("alberto", "editor"); + using var alberto = Client(server, token); + var sid = await SequenceAsync(server, token, 2); + var main = (await alberto.ListProjectsAsync(sid)).Single(p => p.IsMain); + var head = await alberto.GetProjectHeadAsync(sid, main.Id); + var home = ProjectWire.ToHomeFrames(await alberto.GetProjectFramesAsync(sid)); + + var plain = Version(head, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.3 } }, home); + Assert.Equal(1, plain.SettingsFormat); + var v2 = Assert.NotNull((await alberto.PushProjectVersionAsync(sid, main.Id, plain)).Version); + var turned = Version(v2, new ProjectSettings { Camera = new CameraSettings { Rotate = 90, Mirror = true }, Look = new LookSettings { Filter = "sepia" } }, home); + Assert.Equal(2, turned.SettingsFormat); + var v3 = Assert.NotNull((await alberto.PushProjectVersionAsync(sid, main.Id, turned)).Version); + Assert.Equal(2, ProjectContent.FormatOf(v3.SettingsJson)); + var mirrored = ProjectSettings.FromJson(Assert.NotNull((await server.Database.Sequences.GetAsync(sid))!.SettingsJson)); + Assert.Equal((90, true, "sepia"), (mirrored.Camera.Rotate, mirrored.Camera.Mirror, mirrored.Look?.Filter), "Main's head is the sequence's settings"); + + const string future = """{"version":3,"camera":{"rotate":90}}"""; + var newer = Version(v3, new ProjectSettings(), home) with { SettingsJson = future, ContentHash = ProjectContent.Hash(future), SettingsFormat = 3 }; + using (var raw = await http.PostAsJsonAsync($"/api/v1/sequences/{sid}/projects/{main.Id}/versions", newer, ProtocolJson.Default.ProjectVersionDto)) + await raw.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, ProjectErrors.NewerFormat); + Assert.Equal(3, (await alberto.GetProjectAsync(sid, main.Id)).HeadNumber); + } + [Test] public async Task TheFramesOfAHomeAreOfOneFramesVersionWithTheAliasesOfItsConversions() { diff --git a/tests/Chronos.Server.Tests/Jobs/RenderNodeClientTests.cs b/tests/Chronos.Server.Tests/Jobs/RenderNodeClientTests.cs index 0d6b90bc..0ab7a182 100644 --- a/tests/Chronos.Server.Tests/Jobs/RenderNodeClientTests.cs +++ b/tests/Chronos.Server.Tests/Jobs/RenderNodeClientTests.cs @@ -132,6 +132,9 @@ public sealed class RenderNodeClientTests(TestContext context) Assert.SequenceEqual(["apng", "gif", "mjpeg"], registered.Encoders.Select(e => e.Codec).Order(StringComparer.Ordinal)); // Each encoder announces its own largest output, so the server matches job sizes per codec. Assert.True(registered.Encoders.All(e => (e.MaxWidth, e.MaxHeight) == (65535, 65535)), "per-encoder limits"); + // And the settings format it renders (owner review 1, phase 4), so the server gives it only jobs it renders as asked. + var stored = Assert.NotNull(Chronos.Server.Api.Dto.Capabilities(Assert.NotNull(await server.Database.RenderNodes.GetAsync(id)))); + Assert.Equal(ProjectSettings.CurrentVersion, stored.SettingsFormat); } [Test] diff --git a/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs b/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs index 678f37dc..0fe0dce2 100644 --- a/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs +++ b/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs @@ -3,10 +3,14 @@ using System.Net.Http.Json; using System.Text.Json; using Microsoft.Extensions.DependencyInjection; using Chronos.Core.Archiving; +using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Archiving; +using Chronos.Data.Processing; +using Chronos.Data.Repositories; using Chronos.Protocol; using Chronos.Protocol.Client; +using Chronos.Server.Api; using Chronos.Server.Jobs; using Chronos.Server.Storage; using Chronos.Testing; @@ -94,6 +98,96 @@ public sealed class RenderNodeTests(TestContext context) Assert.Equal(uhd.Id, (await claim.ReadAsync(ProtocolJson.Default.ClaimedJob)).Job.Id); } + /// + /// Owner review 1, phase 4: a node that does not announce its settings format (an older Chronos) reads format 1, and is + /// never given a job it would render otherwise than asked: settings of format 2 (a turn), the chosen proportions in a + /// fixed-size preset (4K at 9:16 = 2160×3840), or a sequence's settings changed to format 2 after the job was queued. A + /// node of format 2 takes them, a portrait UHD frame on an encoder announced as 4096×2304 included. + /// + [Test] + public async Task OnlyNodesThatReadTheSettingsFormatTakeTheJobsThatNeedIt() + { + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); + using var old = await editor.PostAsync("/api/v1/nodes/register", new StringContent( + """{"clientName":"old-pc","encoders":[{"codec":"h264","name":"H.264 Encoder MFT","hardware":false,"tenBit":false}],"maxWidth":4096,"maxHeight":4096}""", + System.Text.Encoding.UTF8, "application/json")); + var older = await old.ReadAsync(ProtocolJson.Default.RenderNodeDto); + var stored = Assert.NotNull(Dto.Capabilities(Assert.NotNull(await server.Database.RenderNodes.GetAsync(older.Id)))); + Assert.Equal(1, stored.SettingsFormat); + + var sequence = await JobApiTests.CreateSequenceAsync(editor); + var turned = new ProjectSettings { Camera = new CameraSettings { Rotate = 90 } }.ToJson(); + var portrait = new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto().WithManual("9:16") } }.ToJson(); + var v2 = await JobApiTests.CreateAsync(editor, "render", sequence, WithSettings(H264Job(3840, 2160), turned)); + var proportions = await JobApiTests.CreateAsync(editor, "render", sequence, WithSettings(H264Job(3840, 2160), portrait)); + var routed = ProcessingJobs.ReadRender((await server.Database.Jobs.GetAsync(proportions.Id))!.ParametersJson).Parameters; + Assert.Equal((2160, 3840, 2), (routed.Width, routed.Height, routed.RequiredSettingsFormat), "the server sized the job posted at the preset's size"); + // Queued as format 1, then the sequence's own settings took a turn. + var plain = await JobApiTests.CreateAsync(editor, "render", sequence, H264Job(3840, 2160)); + Assert.Equal(1, ProcessingJobs.ReadRender((await server.Database.Jobs.GetAsync(plain.Id))!.ParametersJson).Parameters.RequiredSettingsFormat); + var row = (await server.Database.Sequences.GetAsync(sequence))!; + await server.Database.Sequences.EditAsync(sequence, new SequenceEdit { SettingsJson = turned }, row.SettingsVersion); + using (var none = await editor.PostAsync($"/api/v1/nodes/{older.Id}/claim", null)) await none.ExpectAsync(HttpStatusCode.NoContent); + + // The software H.264 encoder takes portrait UHD as a long edge × short edge, on a node that knows it. + using var registered = await editor.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("studio-pc", + [new NodeEncoder("h264", "H.264 Encoder MFT", false, false, 4096, 2304)], 4096, 2304, SettingsFormat: 2), ProtocolJson.Default.RegisterNodeRequest); + var newer = await registered.ReadAsync(ProtocolJson.Default.RenderNodeDto); + var claimed = new List(); + for (var i = 0; i < 3; i++) + { + using var claim = await editor.PostAsync($"/api/v1/nodes/{newer.Id}/claim", null); + claimed.Add((await claim.ReadAsync(ProtocolJson.Default.ClaimedJob)).Job.Id); + } + Assert.SequenceEqual(new[] { v2.Id, proportions.Id, plain.Id }.Order(), claimed.Order()); + } + + /// + /// An encoder's limit is a long edge × short edge on a node of format 2 (its encoders take portrait UHD within 4096×2304); + /// an older node shrinks a frame to the limit as announced, so it is held to that. + /// + [Test] + public void APortraitFrameFitsALandscapeLimitOnlyOnANodeThatKnowsIt() + { + var job = new RenderJobParameters("4K", "{}", "h264", 2160, 3840, UseProxies: false, null, RequiredSettingsFormat: 2); + NodeEncoder[] software = [new("h264", "H.264 Encoder MFT", false, false, 4096, 2304)]; + var older = new RegisterNodeRequest("old-pc", software, 4096, 2304); + var newer = older with { ClientName = "studio-pc", SettingsFormat = 2 }; + Assert.False(RenderNodeService.CanEncode(older, job)); + Assert.True(RenderNodeService.CanEncode(newer, job)); + Assert.True(RenderNodeService.Renders(newer, job)); + Assert.False(RenderNodeService.Renders(older, job with { Width = 1080, Height = 1920 }), "format 2 is never sent to a format-1 node"); + Assert.True(RenderNodeService.Renders(older, job with { Width = 3840, Height = 2160, RequiredSettingsFormat = 1 })); + Assert.False(RenderNodeService.CanEncode(newer, job with { Width = 2400 }), "both edges above the short limit"); + } + + /// A job waits for a node only while one online could render it: one of an older settings format cannot. + [Test] + public async Task AJobDoesNotWaitForNodesThatCannotReadItsSettings() + { + await using var server = await TestServer.StartAsync(context, o => o.NodeTimeoutSeconds = 60); + var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); + await RegisterAsync(editor, "old-pc", "h264", 4096); + var sequence = await JobApiTests.CreateSequenceAsync(editor); + var turned = new ProjectSettings { Camera = new CameraSettings { Rotate = 90 } }.ToJson(); + var created = await JobApiTests.CreateAsync(editor, "render", sequence, WithSettings(H264Job(1920, 1080), turned)); + var queued = (await server.Database.Jobs.GetAsync(created.Id))!; + var parameters = ProcessingJobs.ReadRender(queued.ParametersJson).Parameters; + Assert.Equal(2, parameters.RequiredSettingsFormat); + // Waited longer than a node may stay silent: only an online node that renders it keeps it waiting. + var job = queued with { Created = DateTimeOffset.UtcNow - TimeSpan.FromSeconds(61) }; + RenderNodeAvailability Availability() => new(server.Database, server.Options, TimeProvider.System); + + Assert.True(await Availability().AwaitsNodeAsync(queued with { Created = DateTimeOffset.UtcNow }, parameters, context.Cancellation), "a node may be reconnecting"); + Assert.False(await Availability().AwaitsNodeAsync(job, parameters, context.Cancellation), "only a node of format 1 is online"); + Assert.True(await Availability().AwaitsNodeAsync(job, parameters with { RequiredSettingsFormat = 1 }, context.Cancellation), "it renders a job of format 1"); + using (var registered = await editor.PostAsJsonAsync("/api/v1/nodes/register", new RegisterNodeRequest("studio-pc", [new NodeEncoder("h264", "NVENC", true, false)], + 4096, 4096, SettingsFormat: 2), ProtocolJson.Default.RegisterNodeRequest)) + await registered.ExpectAsync(HttpStatusCode.OK); + Assert.True(await Availability().AwaitsNodeAsync(job, parameters, context.Cancellation), "a node of format 2 is online"); + } + [Test] public async Task TheOutputUploadBecomesARenderAndFinishesTheJob() { @@ -244,6 +338,10 @@ public sealed class RenderNodeTests(TestContext context) new RenderJobParameters("H.264", """{"preset":{"isAuto":false,"manual":"4k-h264"}}""", "h264", width, height, UseProxies: false, null), ProtocolJson.Default.RenderJobParameters); + /// Render job parameters with embedded. + private static string WithSettings(string parametersJson, string settingsJson) => JsonSerializer.Serialize( + JsonSerializer.Deserialize(parametersJson, ProtocolJson.Default.RenderJobParameters)! with { SettingsJson = settingsJson }, ProtocolJson.Default.RenderJobParameters); + internal static async Task RegisterAsync(HttpClient client, string name, string codec, int maxWidth) { using var response = await client.PostAsJsonAsync("/api/v1/nodes/register",