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
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>
206 lines
11 KiB
C#
206 lines
11 KiB
C#
using Chronos.Core.Advice;
|
|
using Chronos.Core.Analysis;
|
|
using Chronos.Core.Analysis.Deep;
|
|
using Chronos.Core.Export;
|
|
using Chronos.Core.Motion;
|
|
using Chronos.Core.Project;
|
|
|
|
namespace Chronos.App.Editor;
|
|
|
|
/// <summary>An advisor-decided setting of the editor, whatever its value type.</summary>
|
|
public interface IAutoSetting
|
|
{
|
|
/// <summary><see cref="AdvisorParameters"/> id.</summary>
|
|
string Id { get; }
|
|
|
|
AdvisorSection Section { get; }
|
|
|
|
bool IsAuto(ProjectSettings project);
|
|
|
|
/// <summary>Drops the manual value so the advice applies.</summary>
|
|
ProjectSettings Reset(ProjectSettings project);
|
|
}
|
|
|
|
/// <summary>
|
|
/// One <see cref="Auto{T}"/> member of the project (BRIEF §10.4) and the value the engine uses when the advisor has
|
|
/// none (<see cref="Fallback"/>, from the deep analysis when it measured one).
|
|
/// </summary>
|
|
public sealed class AutoSetting<T>(
|
|
string id,
|
|
AdvisorSection section,
|
|
Func<ProjectSettings, Auto<T>> get,
|
|
Func<ProjectSettings, Auto<T>, ProjectSettings> set,
|
|
Func<ProjectSettings, DeepAnalysisReport?, T> fallback) : IAutoSetting
|
|
where T : notnull
|
|
{
|
|
public string Id { get; } = id;
|
|
|
|
public AdvisorSection Section { get; } = section;
|
|
|
|
public Auto<T> Get(ProjectSettings project) => get(project);
|
|
|
|
public bool IsAuto(ProjectSettings project) => get(project).IsAuto;
|
|
|
|
/// <summary>The advisor's value, else what the engine uses without advice.</summary>
|
|
public T AutoValue(ProjectSettings project, DeepAnalysisReport? deep) => get(project) is { HasAdvice: true, AutoValue: { } advised } ? advised : fallback(project, deep);
|
|
|
|
/// <summary>The value in force.</summary>
|
|
public T Effective(ProjectSettings project, DeepAnalysisReport? deep) => get(project).Resolve(fallback(project, deep));
|
|
|
|
/// <summary>Touching the control: the value becomes manual.</summary>
|
|
public ProjectSettings WithManual(ProjectSettings project, T value) => set(project, get(project).WithManual(value));
|
|
|
|
public ProjectSettings Reset(ProjectSettings project) => set(project, get(project).Reset());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Which collapsible groups of the editor are open, by group key ("export.encoding", "preset.social"): a group nobody
|
|
/// toggled opens as its default says. Until <see cref="Bind"/> attaches the app's settings the state lives for the run;
|
|
/// bound, each toggle is written there and saved.
|
|
/// </summary>
|
|
public sealed class GroupStates
|
|
{
|
|
private readonly Lock _lock = new();
|
|
private IDictionary<string, bool> _store = new Dictionary<string, bool>(StringComparer.Ordinal);
|
|
private Action? _save;
|
|
|
|
/// <summary>Keeps the state in <paramref name="store"/> (the app's settings), calling <paramref name="save"/> after each toggle.</summary>
|
|
public void Bind(IDictionary<string, bool> store, Action? save)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(store);
|
|
lock (_lock)
|
|
{
|
|
// What was toggled before the settings were attached stays.
|
|
foreach (var (key, open) in _store)
|
|
{
|
|
if (!store.ContainsKey(key)) store[key] = open;
|
|
}
|
|
(_store, _save) = (store, save);
|
|
}
|
|
}
|
|
|
|
/// <summary>Whether the group <paramref name="key"/> is open; <paramref name="fallback"/> when it was never toggled.</summary>
|
|
public bool IsExpanded(string key, bool fallback)
|
|
{
|
|
lock (_lock) return _store.TryGetValue(key, out var open) ? open : fallback;
|
|
}
|
|
|
|
/// <summary>Remembers that the group <paramref name="key"/> is open or closed.</summary>
|
|
public void Set(string key, bool expanded)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(key);
|
|
Action? save;
|
|
lock (_lock)
|
|
{
|
|
if (_store.TryGetValue(key, out var open) && open == expanded) return;
|
|
_store[key] = expanded;
|
|
save = _save;
|
|
}
|
|
save?.Invoke();
|
|
}
|
|
}
|
|
|
|
/// <summary>The Auto settings of the editor's sections, in panel order.</summary>
|
|
public static class EditorSettings
|
|
{
|
|
public static readonly AutoSetting<TimingMode> TimingMode = new(AdvisorParameters.TimingMode, AdvisorSection.Timing,
|
|
p => p.Timing.Mode, (p, a) => p with { Timing = p.Timing with { Mode = a } }, (_, _) => Core.Project.TimingMode.Constant);
|
|
|
|
/// <summary>Playback rate; without a value it equals the export frame rate (DECISIONS: export fps vs playback rate).</summary>
|
|
public static readonly AutoSetting<string> FrameRate = new(AdvisorParameters.FrameRate, AdvisorSection.Timing,
|
|
p => p.Timing.FrameRate, (p, a) => p with { Timing = p.Timing with { FrameRate = a } },
|
|
(p, _) => FrameRateText.Format(ExportResolver.Resolve(p.Export).FrameRate));
|
|
|
|
public static readonly AutoSetting<bool> Deflicker = new(AdvisorParameters.Deflicker, AdvisorSection.Exposure,
|
|
p => p.Exposure.Deflicker, (p, a) => p with { Exposure = p.Exposure with { Deflicker = a } }, (_, _) => false);
|
|
|
|
public static readonly AutoSetting<int> DeflickerWindow = new(AdvisorParameters.DeflickerWindow, AdvisorSection.Exposure,
|
|
p => p.Exposure.DeflickerWindow, (p, a) => p with { Exposure = p.Exposure with { DeflickerWindow = a } },
|
|
(_, deep) => deep?.Flicker.RecommendedWindow ?? DeflickerOptions.Default.Window);
|
|
|
|
public static readonly AutoSetting<double> DeflickerStrength = new(AdvisorParameters.DeflickerStrength, AdvisorSection.Exposure,
|
|
p => p.Exposure.DeflickerStrength, (p, a) => p with { Exposure = p.Exposure with { DeflickerStrength = a } }, (_, _) => DeflickerOptions.Default.Strength);
|
|
|
|
public static readonly AutoSetting<RegionMode> Regions = new(AdvisorParameters.Regions, AdvisorSection.Exposure,
|
|
p => p.Exposure.Regions, (p, a) => p with { Exposure = p.Exposure with { Regions = a } }, (_, _) => RegionMode.Off);
|
|
|
|
public static readonly AutoSetting<bool> HolyGrail = new(AdvisorParameters.HolyGrail, AdvisorSection.Exposure,
|
|
p => p.Exposure.HolyGrail, (p, a) => p with { Exposure = p.Exposure with { HolyGrail = a } }, (_, _) => false);
|
|
|
|
public static readonly AutoSetting<int> TransitionLength = new(AdvisorParameters.TransitionLength, AdvisorSection.Exposure,
|
|
p => p.Exposure.TransitionLength, (p, a) => p with { Exposure = p.Exposure with { TransitionLength = a } },
|
|
(_, deep) => deep?.Exposure.TransitionLength ?? new HolyGrailOptions().SingleStepTransitionFrames);
|
|
|
|
public static readonly AutoSetting<bool> WhiteBalance = new(AdvisorParameters.WhiteBalanceSmoothing, AdvisorSection.Exposure,
|
|
p => p.Exposure.WhiteBalanceSmoothing, (p, a) => p with { Exposure = p.Exposure with { WhiteBalanceSmoothing = a } }, (_, _) => false);
|
|
|
|
public static readonly AutoSetting<bool> MotionBlur = new(AdvisorParameters.MotionBlur, AdvisorSection.Motion,
|
|
p => p.Motion.MotionBlur, (p, a) => p with { Motion = p.Motion with { MotionBlur = a } }, (_, _) => false);
|
|
|
|
public static readonly AutoSetting<double> ShutterAngle = new(AdvisorParameters.TargetShutterAngle, AdvisorSection.Motion,
|
|
p => p.Motion.TargetShutterAngle, (p, a) => p with { Motion = p.Motion with { TargetShutterAngle = a } }, (_, _) => 180.0);
|
|
|
|
public static readonly AutoSetting<FlowQualitySetting> FlowQuality = new(AdvisorParameters.FlowQuality, AdvisorSection.Motion,
|
|
p => p.Motion.FlowQuality, (p, a) => p with { Motion = p.Motion with { FlowQuality = a } }, (_, _) => FlowQualitySetting.Balanced);
|
|
|
|
public static readonly AutoSetting<bool> Stabilize = new(AdvisorParameters.Stabilize, AdvisorSection.Motion,
|
|
p => p.Motion.Stabilize, (p, a) => p with { Motion = p.Motion with { Stabilize = a } }, (_, _) => false);
|
|
|
|
public static readonly AutoSetting<double> StabilizeSmoothing = new(AdvisorParameters.StabilizeSmoothing, AdvisorSection.Motion,
|
|
p => p.Motion.StabilizeSmoothing, (p, a) => p with { Motion = p.Motion with { StabilizeSmoothing = a } }, (_, _) => new StabilizerOptions().SmoothingSigma);
|
|
|
|
public static readonly AutoSetting<string> Aspect = new(AdvisorParameters.Aspect, AdvisorSection.Camera,
|
|
p => p.Camera.Aspect, (p, a) => p with { Camera = p.Camera with { Aspect = a } }, (_, _) => "source");
|
|
|
|
public static readonly AutoSetting<string> ExportPreset = new(AdvisorParameters.ExportPreset, AdvisorSection.Export,
|
|
p => p.Export.Preset, (p, a) => p with { Export = p.Export with { Preset = a } }, (_, _) => ExportResolver.DefaultPresetId);
|
|
|
|
public static IReadOnlyList<IAutoSetting> All { get; } =
|
|
[
|
|
TimingMode, FrameRate, Deflicker, DeflickerWindow, DeflickerStrength, Regions, HolyGrail, TransitionLength, WhiteBalance,
|
|
MotionBlur, ShutterAngle, FlowQuality, Stabilize, StabilizeSmoothing, Aspect, ExportPreset,
|
|
];
|
|
|
|
/// <summary>"Reset": every Auto setting of <paramref name="section"/> back to Auto; stacking (no advice) back to off.</summary>
|
|
public static ProjectSettings ResetSection(ProjectSettings project, AdvisorSection section)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(project);
|
|
foreach (var setting in All)
|
|
{
|
|
if (setting.Section == section) project = setting.Reset(project);
|
|
}
|
|
return section == AdvisorSection.Stack ? project with { Stack = new StackSettings() } : project;
|
|
}
|
|
|
|
/// <summary>True when every Auto setting of <paramref name="section"/> is in Auto.</summary>
|
|
public static bool IsSectionAuto(ProjectSettings project, AdvisorSection section) =>
|
|
All.Where(s => s.Section == section).All(s => s.IsAuto(project));
|
|
|
|
/// <summary>
|
|
/// The collapse state of the Export step's setting groups and preset groups (owner review 1, R3; DESIGN §4 collapsible
|
|
/// group): this user's, kept by the app and not in the project.
|
|
/// </summary>
|
|
public static GroupStates Groups { get; } = new();
|
|
|
|
/// <summary>
|
|
/// Whether <paramref name="setting"/> applies under the switches in force: the deflicker window, strength and regions
|
|
/// with deflicker on, the transition length with holy grail on, the shutter angle with motion blur on, the flow quality
|
|
/// with motion blur or interpolated timing, the stabiliser's smoothing with stabilisation on. A setting that does not
|
|
/// apply shows n/a in its row (which cannot be taken over by hand then), and the Edit path asks nothing about it.
|
|
/// </summary>
|
|
public static bool Applies(IAutoSetting setting, ProjectSettings project, DeepAnalysisReport? deep)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(setting);
|
|
ArgumentNullException.ThrowIfNull(project);
|
|
return setting.Id switch
|
|
{
|
|
AdvisorParameters.DeflickerWindow or AdvisorParameters.DeflickerStrength or AdvisorParameters.Regions => Deflicker.Effective(project, deep),
|
|
AdvisorParameters.TransitionLength => HolyGrail.Effective(project, deep),
|
|
AdvisorParameters.TargetShutterAngle => MotionBlur.Effective(project, deep),
|
|
AdvisorParameters.FlowQuality => MotionBlur.Effective(project, deep) || TimingMode.Effective(project, deep) == Core.Project.TimingMode.Interpolated,
|
|
AdvisorParameters.StabilizeSmoothing => Stabilize.Effective(project, deep),
|
|
_ => true,
|
|
};
|
|
}
|
|
}
|