diff --git a/src/Titano.App/Editor/CameraTab.cs b/src/Titano.App/Editor/CameraTab.cs
new file mode 100644
index 00000000..0ef6c3cc
--- /dev/null
+++ b/src/Titano.App/Editor/CameraTab.cs
@@ -0,0 +1,265 @@
+using System.Collections.ObjectModel;
+using System.Windows;
+using System.Windows.Input;
+using Titano.App.Infrastructure;
+using Titano.Core.Advice;
+using Titano.Core.Export;
+using Titano.Core.Localization;
+using Titano.Core.Mathematics;
+using Titano.Core.Project;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Editor;
+
+///
+/// Camera (BRIEF §12.3): output aspect and crop placement, and virtual-camera keyframes edited as a zoom curve over the
+/// sequence (X = frame, Y = zoom) with the selected keyframe's framing below.
+///
+public sealed class CameraTab : EditorTab
+{
+ /// Zoom at the top of the curve editor.
+ public const double MaxZoom = 4;
+
+ private int _selectedKey = -1;
+
+ public CameraTab(EditorViewModel editor)
+ : base(editor, "Camera", AdvisorSection.Camera)
+ {
+ var s = editor.Session;
+ Rows =
+ [
+ new AutoChoiceRow(s, EditorSettings.Aspect, "Editor.Camera.Aspect", "Tooltips.Editor.Camera.Aspect",
+ [
+ new Choice("source", "Editor.Aspect.Source"), new Choice("16:9", "Editor.Aspect.Ratio", "16:9"), new Choice("21:9", "Editor.Aspect.Ratio", "21:9"),
+ new Choice("4:3", "Editor.Aspect.Ratio", "4:3"), new Choice("3:2", "Editor.Aspect.Ratio", "3:2"), new Choice("1:1", "Editor.Aspect.Ratio", "1:1"),
+ new Choice("9:16", "Editor.Aspect.Ratio", "9:16"), new Choice("4:5", "Editor.Aspect.Ratio", "4:5"),
+ ]),
+ new NumberRow(s, "Editor.Camera.OffsetX", "Tooltips.Editor.Camera.OffsetX", -1, 1, 0.05, p => p.Camera.OffsetX,
+ (p, v) => p with { Camera = p.Camera with { OffsetX = v } }, Placement),
+ new NumberRow(s, "Editor.Camera.OffsetY", "Tooltips.Editor.Camera.OffsetY", -1, 1, 0.05, p => p.Camera.OffsetY,
+ (p, v) => p with { Camera = p.Camera with { OffsetY = v } }, Placement),
+ ];
+ AddKeyCommand = new RelayCommand(AddKey, () => !Editor.IsBusy && Keys.All(k => k.Frame != Editor.CurrentIndex));
+ RemoveKeyCommand = new RelayCommand(RemoveKey, () => !Editor.IsBusy && SelectedKey >= 0);
+ Refresh();
+ }
+
+ /// Keyframes as curve points: X = frame / (count − 1), Y = (zoom − 1) / ( − 1). Edited in place by the curve editor.
+ public ObservableCollection KeyPoints { get; } = [];
+
+ public int SelectedKey
+ {
+ get => _selectedKey;
+ set
+ {
+ if (!Set(ref _selectedKey, value)) return;
+ OnSelectedKeyChanged();
+ }
+ }
+
+ public bool HasSelectedKey => SelectedKey >= 0 && SelectedKey < Keys.Count;
+
+ /// Framing of the selected keyframe: centre (0–1) and zoom.
+ public double SelectedCenterX
+ {
+ get => HasSelectedKey ? Keys[SelectedKey].CenterX : 0.5;
+ set => EditSelected(k => k with { CenterX = double.Clamp(value, 0, 1) });
+ }
+
+ public double SelectedCenterY
+ {
+ get => HasSelectedKey ? Keys[SelectedKey].CenterY : 0.5;
+ set => EditSelected(k => k with { CenterY = double.Clamp(value, 0, 1) });
+ }
+
+ public double SelectedZoom
+ {
+ get => HasSelectedKey ? Keys[SelectedKey].Zoom : 1;
+ set => EditSelected(k => k with { Zoom = double.Clamp(value, 1, MaxZoom) });
+ }
+
+ public string SelectedZoomText => Loc.L("Editor.Value.Zoom", SelectedZoom.ToString("0.00", Loc.Culture));
+
+ /// "Keyframe 2 of 3 · frame 0413".
+ public string KeyText => HasSelectedKey
+ ? Loc.L("Editor.Camera.KeyOf", SelectedKey + 1, Keys.Count, (Keys[SelectedKey].Frame + 1).ToString("D4", Loc.Culture))
+ : Loc.Plural("Editor.Camera.Keys", Keys.Count);
+
+ public double Playhead => Editor.FrameCount > 1 ? (double)Editor.CurrentIndex / (Editor.FrameCount - 1) : double.NaN;
+
+ public Func XFormatter => x => EditorText.Position((int)double.Round(x * (Editor.FrameCount - 1)), Editor.FrameCount);
+
+ public Func YFormatter { get; } = y => Loc.L("Editor.Value.Zoom", (1 + y * (MaxZoom - 1)).ToString("0.00", Loc.Culture));
+
+ public ICommand AddKeyCommand { get; }
+
+ public ICommand RemoveKeyCommand { get; }
+
+ private IReadOnlyList Keys => Editor.Session.Project.Camera.Keyframes;
+
+ public override void Refresh()
+ {
+ base.Refresh();
+ var points = Keys.OrderBy(k => k.Frame).Select(ToPoint).ToList();
+ if (!points.SequenceEqual(KeyPoints))
+ {
+ KeyPoints.Clear();
+ foreach (var p in points) KeyPoints.Add(p);
+ }
+ if (SelectedKey >= Keys.Count) SelectedKey = Keys.Count - 1;
+ OnSelectedKeyChanged();
+ }
+
+ /// The curve editor finished an edit (add, move, delete): the points become the keyframes, keeping each one's framing.
+ public void CommitCurve()
+ {
+ var old = Keys.OrderBy(k => k.Frame).ToList();
+ var keys = new List();
+ foreach (var point in KeyPoints.OrderBy(p => p.X))
+ {
+ var frame = (int)double.Round(point.X * double.Max(1, Editor.FrameCount - 1));
+ var zoom = 1 + double.Clamp(point.Y, 0, 1) * (MaxZoom - 1);
+ var nearest = old.MinBy(k => int.Abs(k.Frame - frame));
+ keys.Add(nearest is null ? new CameraKey(frame, 0.5, 0.5, zoom, 0) : nearest with { Frame = frame, Zoom = zoom });
+ }
+ Editor.Session.Edit(p => p with { Camera = p.Camera with { Keyframes = [.. keys.DistinctBy(k => k.Frame)] } });
+ }
+
+ public void OnCurrentFrameChanged() => OnPropertyChanged(nameof(Playhead));
+
+ private static string Placement(double value) => value == 0 ? Loc.L("Editor.Value.Centred") : value.ToString("+0.00;−0.00", Loc.Culture);
+
+ private Point ToPoint(CameraKey key) => new(Editor.FrameCount > 1 ? (double)key.Frame / (Editor.FrameCount - 1) : 0, (key.Zoom - 1) / (MaxZoom - 1));
+
+ private void AddKey()
+ {
+ var frame = Editor.CurrentIndex;
+ var key = new CameraKey(frame, 0.5, 0.5, 1, 0);
+ Editor.Session.Edit(p => p with { Camera = p.Camera with { Keyframes = [.. p.Camera.Keyframes.Append(key).OrderBy(k => k.Frame)] } });
+ SelectedKey = Keys.Select((k, i) => (k, i)).First(t => t.k.Frame == frame).i;
+ }
+
+ private void RemoveKey()
+ {
+ if (!HasSelectedKey) return;
+ var frame = Keys[SelectedKey].Frame;
+ Editor.Session.Edit(p => p with { Camera = p.Camera with { Keyframes = [.. p.Camera.Keyframes.Where(k => k.Frame != frame)] } });
+ }
+
+ private void EditSelected(Func change)
+ {
+ if (!HasSelectedKey) return;
+ var index = SelectedKey;
+ Editor.Session.Edit(p =>
+ {
+ var keys = p.Camera.Keyframes.OrderBy(k => k.Frame).ToList();
+ keys[index] = change(keys[index]);
+ return p with { Camera = p.Camera with { Keyframes = keys } };
+ }, "Camera.Key");
+ }
+
+ private void OnSelectedKeyChanged()
+ {
+ OnPropertyChanged(nameof(HasSelectedKey));
+ OnPropertyChanged(nameof(SelectedCenterX));
+ OnPropertyChanged(nameof(SelectedCenterY));
+ OnPropertyChanged(nameof(SelectedZoom));
+ OnPropertyChanged(nameof(SelectedZoomText));
+ OnPropertyChanged(nameof(KeyText));
+ }
+}
+
+///
+/// Time (BRIEF §12.3): timing mode, playback rate, fit-to duration and the time-remap curve (output time → source
+/// position, Fritsch–Carlson as the render evaluates it), with the plan in numbers.
+///
+public sealed class TimeTab : EditorTab
+{
+ private Func? _evaluator;
+ private string? _planText;
+
+ public TimeTab(EditorViewModel editor)
+ : base(editor, "Time", AdvisorSection.Timing)
+ {
+ var s = editor.Session;
+ Rows =
+ [
+ new AutoChoiceRow(s, EditorSettings.TimingMode, "Editor.Time.Mode", "Tooltips.Editor.Time.Mode",
+ [
+ new Choice(TimingMode.Constant, "Editor.Timing.Constant"), new Choice(TimingMode.Adaptive, "Editor.Timing.Adaptive"),
+ new Choice(TimingMode.Interpolated, "Editor.Timing.Interpolated"), new Choice(TimingMode.Remapped, "Editor.Timing.Remapped"),
+ ]),
+ new AutoChoiceRow(s, EditorSettings.FrameRate, "Editor.Time.Rate", "Tooltips.Editor.Time.Rate",
+ [.. ExportPresets.FrameRates.Select(r => new Choice(FrameRateText.Format(r), "Editor.Value.Fps", EditorText.FrameRate(r)))]),
+ new NumberRow(s, "Editor.Time.Fit", "Tooltips.Editor.Time.Fit", 0, 600, 5, p => p.Timing.FitToSeconds ?? 0,
+ (p, v) => p with { Timing = p.Timing with { FitToSeconds = v > 0 ? v : null } },
+ v => v > 0 ? Formatting.Duration(TimeSpan.FromSeconds(v)) : Loc.L("Editor.Value.Off")),
+ ];
+ Refresh();
+ }
+
+ /// Remap control points (output fraction → source fraction), edited in place by the curve editor.
+ public ObservableCollection RemapPoints { get; } = [];
+
+ /// The monotone spline through .
+ public Func? Evaluator { get => _evaluator; private set => Set(ref _evaluator, value); }
+
+ /// "3,600 frames → 2 min 30 s · 24 fps".
+ public string? PlanText { get => _planText; private set => Set(ref _planText, value); }
+
+ public double Playhead => Editor.FrameCount > 1 ? (double)Editor.CurrentIndex / (Editor.FrameCount - 1) : double.NaN;
+
+ public Func XFormatter { get; } = x => Loc.L("Editor.Time.Output", (x * 100).ToString("0", Loc.Culture));
+
+ public Func YFormatter { get; } = y => Loc.L("Editor.Time.Source", (y * 100).ToString("0", Loc.Culture));
+
+ public override void Refresh()
+ {
+ base.Refresh();
+ var curve = Editor.Session.Project.Timing.RemapCurve;
+ var points = curve.Select(p => new Point(p.X, p.Y)).ToList();
+ if (!points.SequenceEqual(RemapPoints))
+ {
+ RemapPoints.Clear();
+ foreach (var p in points) RemapPoints.Add(p);
+ }
+ Evaluator = Spline(points);
+ }
+
+ public override void OnPlanChanged()
+ {
+ if (Editor.Plan is not { } plan)
+ {
+ PlanText = null;
+ return;
+ }
+ var render = plan.Setup.Plan;
+ PlanText = Loc.Plural("Editor.Time.Plan", render.Frames.Count, Formatting.Duration(TimeSpan.FromSeconds(render.DurationSeconds)),
+ EditorText.FrameRate(render.FrameRate));
+ }
+
+ /// The curve editor finished an edit: the points become the remap curve, and the timing mode follows it.
+ public void CommitCurve()
+ {
+ var curve = RemapPoints.OrderBy(p => p.X).Select(p => new CurvePoint(double.Clamp(p.X, 0, 1), double.Clamp(p.Y, 0, 1))).ToList();
+ Editor.Session.Edit(p => p with
+ {
+ Timing = p.Timing with
+ {
+ RemapCurve = curve,
+ Mode = EditorSettings.TimingMode.Effective(p, null) == TimingMode.Remapped ? p.Timing.Mode : p.Timing.Mode.WithManual(TimingMode.Remapped),
+ },
+ });
+ }
+
+ public void OnCurrentFrameChanged() => OnPropertyChanged(nameof(Playhead));
+
+ private static Func? Spline(IReadOnlyList points)
+ {
+ if (points.Count < 2) return null;
+ var ordered = points.OrderBy(p => p.X).DistinctBy(p => p.X).ToList();
+ if (ordered.Count < 2) return null;
+ var spline = new MonotoneSpline([.. ordered.Select(p => p.X)], [.. ordered.Select(p => p.Y)]);
+ return x => double.Clamp(spline.Evaluate(x), 0, 1);
+ }
+}
diff --git a/src/Titano.App/Editor/EditorImages.cs b/src/Titano.App/Editor/EditorImages.cs
new file mode 100644
index 00000000..aebf09a6
--- /dev/null
+++ b/src/Titano.App/Editor/EditorImages.cs
@@ -0,0 +1,53 @@
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using Titano.Core.Diagnostics;
+using Titano.Core.Imaging;
+using Titano.Ui.Visuals;
+
+namespace Titano.App.Editor;
+
+/// Linear-light frames as frozen sRGB bitmaps the UI thread can show (created on any thread).
+public static class EditorImages
+{
+ public static BitmapSource ToBitmap(ImageBuffer image)
+ {
+ ArgumentNullException.ThrowIfNull(image);
+ var channels = int.Min(3, image.Channels);
+ var pixels = PixelConvert.ToInterleaved8(image, channels);
+ var format = channels == 1 ? PixelFormats.Gray8 : PixelFormats.Rgb24;
+ var bitmap = BitmapSource.Create(image.Width, image.Height, 96, 96, format, null, pixels, image.Width * channels);
+ bitmap.Freeze();
+ return bitmap;
+ }
+}
+
+///
+/// Filmstrip thumbnails decoded through the editor's (embedded previews when large
+/// enough), at most a few at a time so scrolling the strip never floods the decoders.
+///
+public sealed class EditorThumbnails(ISequenceSource source, int count) : IThumbnailSource
+{
+ private readonly SemaphoreSlim _decoders = new(int.Clamp(Environment.ProcessorCount / 2, 2, 6));
+
+ public int Count { get; } = count;
+
+ public async ValueTask GetAsync(int index, int pixelWidth, CancellationToken cancellationToken)
+ {
+ await _decoders.WaitAsync(cancellationToken);
+ try
+ {
+ // Long edge for frames up to 16:9 tall or wide; the cache rounds requests, so nearby widths share a decode.
+ using var frame = await source.DecodeAsync(index, int.Clamp(pixelWidth, 32, 512), DecodePurpose.Thumbnail, cancellationToken);
+ return frame is null ? null : EditorImages.ToBitmap(frame);
+ }
+ catch (Exception ex) when (ex is not OperationCanceledException)
+ {
+ Log.Debug("editor", $"No thumbnail for frame {index}: {ex.Message}");
+ return null;
+ }
+ finally
+ {
+ _decoders.Release();
+ }
+ }
+}
diff --git a/src/Titano.App/Editor/EditorSession.cs b/src/Titano.App/Editor/EditorSession.cs
index 4fc40fef..4a243957 100644
--- a/src/Titano.App/Editor/EditorSession.cs
+++ b/src/Titano.App/Editor/EditorSession.cs
@@ -98,6 +98,24 @@ public sealed class EditorSession : IAsyncDisposable
/// Makes the hero frame (sequence thumbnail).
public bool SetHero(int frame) => (uint)frame < (uint)Content.Count && Edit(p => p with { HeroFrame = frame });
+ ///
+ /// Applies a sequence preset (BRIEF §10.3) as one undoable step: its timing, exposure, motion, aspect and export
+ /// preset; the user's frames (exclusions, hero), crop, keyframes, remap curve, exposure offset and output naming stay.
+ ///
+ public bool ApplyPreset(SequencePreset preset)
+ {
+ ArgumentNullException.ThrowIfNull(preset);
+ var s = preset.Settings;
+ return Edit(p => p with
+ {
+ Timing = s.Timing with { RemapCurve = p.Timing.RemapCurve, FitToSeconds = p.Timing.FitToSeconds },
+ Exposure = s.Exposure with { ExposureOffsetEv = p.Exposure.ExposureOffsetEv, HighlightKnee = p.Exposure.HighlightKnee },
+ Motion = s.Motion,
+ Camera = p.Camera with { Aspect = s.Camera.Aspect },
+ Export = p.Export with { Preset = s.Export.Preset, Overrides = new ExportOverrides() },
+ });
+ }
+
///
/// A render of with the project as it is now (the job embeds it, so a render queued before
/// the save lands still renders what the user sees).
diff --git a/src/Titano.App/Editor/EditorTab.cs b/src/Titano.App/Editor/EditorTab.cs
new file mode 100644
index 00000000..99fa5247
--- /dev/null
+++ b/src/Titano.App/Editor/EditorTab.cs
@@ -0,0 +1,72 @@
+using System.Windows.Input;
+using Titano.Core.Advice;
+using Titano.Core.Localization;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Editor;
+
+///
+/// One section of the editor (BRIEF §12.3): a tab with its measuring tool below the filmstrip and its settings column on
+/// the right, with "Optimise section" and "Reset". runs after every project change.
+///
+public abstract class EditorTab : LocalizedViewModel
+{
+ protected EditorTab(EditorViewModel editor, string key, AdvisorSection section)
+ {
+ Editor = editor;
+ Key = key;
+ Section = section;
+ OptimiseCommand = new RelayCommand(() => Editor.Optimise(Section), () => CanOptimise && !Editor.IsBusy);
+ ResetCommand = new RelayCommand(() => Editor.Session.ResetSection(Section), () => CanReset && !Editor.IsBusy);
+ }
+
+ public EditorViewModel Editor { get; }
+
+ /// "Frames", "Exposure"… (resource key suffix).
+ public string Key { get; }
+
+ public AdvisorSection Section { get; }
+
+ public string Header => Loc.L("Editor.Tab." + Key);
+
+ public string ToolTip => Loc.L("Tooltips.Editor.Tab." + Key);
+
+ /// Settings rows of the right column (empty for tabs with their own panel).
+ public IReadOnlyList Rows { get; protected init; } = [];
+
+ /// The advisor has heavier decisions for this section (stacking has none).
+ public virtual bool CanOptimise => true;
+
+ public virtual bool CanReset => true;
+
+ public string OptimiseToolTip => Loc.L(CanOptimise ? "Tooltips.Editor.OptimiseSection" : "Tooltips.Editor.OptimiseNone");
+
+ public ICommand OptimiseCommand { get; }
+
+ public ICommand ResetCommand { get; }
+
+ /// Re-reads the project (any change).
+ public virtual void Refresh()
+ {
+ foreach (var row in Rows) row.Refresh();
+ }
+
+ /// The sequence was read again: new analyses (charts, findings).
+ public virtual void OnContentChanged() => Refresh();
+
+ /// The preview's corrections were prepared for the current settings (target curves).
+ public virtual void OnCorrectionsChanged()
+ {
+ }
+
+ /// The export plan of the project changed (durations, sizes).
+ public virtual void OnPlanChanged()
+ {
+ }
+
+ public override void Dispose()
+ {
+ foreach (var row in Rows) row.Dispose();
+ base.Dispose();
+ }
+}
diff --git a/src/Titano.App/Editor/EditorText.cs b/src/Titano.App/Editor/EditorText.cs
new file mode 100644
index 00000000..c47c97e4
--- /dev/null
+++ b/src/Titano.App/Editor/EditorText.cs
@@ -0,0 +1,104 @@
+using Titano.App.Infrastructure;
+using Titano.Core.Export;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Core.Video;
+
+namespace Titano.App.Editor;
+
+/// The editor's composed texts (header summary, shot data, preset card lines), in the current UI language.
+public static class EditorText
+{
+ private const string Separator = " · ";
+
+ /// "3,600 frames · Canon EOS R5 · 2 s interval · 2 h 00 m · 3 warnings".
+ public static string Summary(SequenceContent content, int warnings)
+ {
+ ArgumentNullException.ThrowIfNull(content);
+ var s = content.Sequence;
+ var parts = new List { Loc.Plural("Editor.Summary.Frames", content.Count) };
+ if (s.CameraModel is { Length: > 0 } camera) parts.Add(camera);
+ if (content.Light.MedianIntervalSeconds is > 0 and var interval) parts.Add(Loc.L("Editor.Summary.Interval", Number(interval)));
+ if (content.Light.CaptureSpan > TimeSpan.Zero) parts.Add(Formatting.Duration(content.Light.CaptureSpan));
+ if (warnings > 0) parts.Add(Loc.Plural("Editor.Summary.Warnings", warnings));
+ return string.Join(Separator, parts);
+ }
+
+ /// "0413 / 3,600 · 18:02:11 · 1/8 s · f/8 · ISO 400 · 24 mm".
+ public static string Shot(Frame frame, int index, int count)
+ {
+ ArgumentNullException.ThrowIfNull(frame);
+ var parts = new List { Position(index, count) };
+ if (frame.CapturedAt is { } at) parts.Add(at.ToString("T", Loc.Culture));
+ if (frame.ExposureTime is > 0 and var t) parts.Add(Shutter(t));
+ if (frame.FNumber is > 0 and var f) parts.Add(Loc.L("Editor.Shot.Aperture", Number(f)));
+ if (frame.Iso is > 0 and var iso) parts.Add(Loc.L("Editor.Shot.Iso", iso));
+ if (frame.FocalLength is > 0 and var mm) parts.Add(Loc.L("Editor.Shot.Focal", Number(mm)));
+ return string.Join(Separator, parts);
+ }
+
+ /// "0413 / 3,600".
+ public static string Position(int index, int count) =>
+ (index + 1).ToString("D4", Loc.Culture) + " / " + count.ToString("N0", Loc.Culture);
+
+ /// "1/250 s", "1/8 s", "2 s".
+ public static string Shutter(double seconds) => seconds >= 0.3
+ ? Loc.L("Editor.Shot.Shutter", Number(seconds))
+ : Loc.L("Editor.Shot.Shutter", "1/" + double.Round(1 / seconds).ToString("0", Loc.Culture));
+
+ /// "MP4 · HEVC Main10 · 3840×2160 · 24 fps".
+ public static string Format(ResolvedExport export, int width, int height)
+ {
+ ArgumentNullException.ThrowIfNull(export);
+ var parts = new List { Loc.L("Export.Container." + VideoCodecInfo.DefaultContainer(export.Codec)), CodecName(export.Codec, export.Profile, export.BitDepth) };
+ if (width > 0 && height > 0) parts.Add(Size(width, height));
+ parts.Add(Loc.L("Editor.Export.Fps", FrameRate(export.FrameRate)));
+ return string.Join(Separator, parts);
+ }
+
+ /// "120 Mb/s · 0.07 bpp · NVENC" for video, "Quality 95 · Titano" for frames.
+ public static string Encoding(ResolvedExport export, long bitRate, string? encoder)
+ {
+ ArgumentNullException.ThrowIfNull(export);
+ var parts = new List();
+ if (!VideoCodecInfo.IsManaged(export.Codec))
+ {
+ parts.Add(BitRate(bitRate));
+ var bpp = export.BitsPerPixel > 0 ? export.BitsPerPixel : ExportPreset.DefaultBitsPerPixel(export.Codec);
+ if (export.BitRate == 0 && bpp > 0) parts.Add(Loc.L("Editor.Export.Bpp", bpp.ToString("0.00", Loc.Culture)));
+ }
+ else if (export.Codec is VideoCodec.Mjpeg or VideoCodec.JpegSequence or VideoCodec.Gif)
+ {
+ parts.Add(Loc.L("Editor.Export.QualityValue", export.Quality));
+ }
+ if (encoder is { Length: > 0 }) parts.Add(encoder);
+ return string.Join(Separator, parts);
+ }
+
+ /// "2.2 GB · about 5 min".
+ public static string Estimate(ExportEstimate estimate)
+ {
+ ArgumentNullException.ThrowIfNull(estimate);
+ return Formatting.Bytes(estimate.Bytes) + Separator + Loc.L("Editor.Export.About", Formatting.Duration(estimate.Time));
+ }
+
+ /// "120 Mb/s".
+ public static string BitRate(long bitsPerSecond) => Loc.L("Editor.Export.Mbps", (bitsPerSecond / 1e6).ToString(bitsPerSecond >= 10_000_000 ? "0" : "0.#", Loc.Culture));
+
+ /// "3840×2160".
+ public static string Size(int width, int height) => width.ToString(Loc.Culture) + "×" + height.ToString(Loc.Culture);
+
+ /// "23.976", "24".
+ public static string FrameRate(Rational rate) => rate.Denominator == 1 ? rate.Numerator.ToString(Loc.Culture) : rate.Value.ToString("0.###", Loc.Culture);
+
+ /// Technical codec name ("H.264 High", "HEVC Main10", "PNG"…).
+ public static string CodecName(VideoCodec codec, CodecProfile profile, int bitDepth) => codec switch
+ {
+ VideoCodec.Hevc when profile == CodecProfile.HevcMain10 || bitDepth > 8 => Loc.L("Export.Codec.HevcMain10"),
+ VideoCodec.Hevc => Loc.L("Export.Codec.Hevc"),
+ VideoCodec.H264 => Loc.L("Export.Codec.H264"),
+ _ => Loc.L("Export.Codec." + codec),
+ };
+
+ private static string Number(double value) => value.ToString(value >= 10 ? "0" : "0.#", Loc.Culture);
+}
diff --git a/src/Titano.App/Editor/EditorViewModel.cs b/src/Titano.App/Editor/EditorViewModel.cs
new file mode 100644
index 00000000..09ccf623
--- /dev/null
+++ b/src/Titano.App/Editor/EditorViewModel.cs
@@ -0,0 +1,675 @@
+using System.Collections;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+using Titano.App.Shell;
+using Titano.Core.Advice;
+using Titano.Core.Analysis;
+using Titano.Core.Diagnostics;
+using Titano.Core.Export;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Core.Project;
+using Titano.Core.Render;
+using Titano.Core.Video;
+using Titano.Ui.Mvvm;
+using Titano.Ui.Visuals;
+
+namespace Titano.App.Editor;
+
+///
+/// The sequence editor of one open sequence (BRIEF §12.3, Editor.html): header actions, the preview with its tools
+/// (wipe compare, zoom, overlays) rendered through the pipeline at preview size, the filmstrip with markers, the
+/// section tabs and the keyboard (space, arrows, Ctrl+Z/Y, Ctrl+0/1, Ctrl+R). Preview frames, corrections, the export
+/// plan and the card estimates are computed off the UI thread; each request cancels the previous one. While an analysis
+/// or render of this sequence runs, settings are disabled and viewing tools stay live.
+///
+public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable
+{
+ public const int DefaultPreviewEdge = 1280;
+ private static readonly TimeSpan Debounce = TimeSpan.FromMilliseconds(150);
+
+ private readonly IReadOnlyList _encoders;
+ private readonly EncoderHost _host;
+ private readonly Dispatcher _dispatcher;
+ private readonly LatestRunner _preview = new(Debounce);
+ private readonly LatestRunner _corrections = new(Debounce);
+ private readonly LatestRunner _plans = new(Debounce);
+ private readonly DispatcherTimer _player;
+ private readonly Dictionary _jobs = [];
+ private PreviewRenderer _renderer;
+ private int _currentIndex;
+ private EditorTab _selectedTab;
+ private ImageSource? _previewImage;
+ private ImageSource? _originalImage;
+ private bool _isCompare = true;
+ private bool _showVectors;
+ private bool _showRegions;
+ private bool _showCropMask;
+ private PreviewZoomMode _zoomMode = PreviewZoomMode.Fit;
+ private Rect _cropRect = new(0, 0, 1, 1);
+ private IReadOnlyList? _regionBoundary;
+ private IReadOnlyList? _motionVectors;
+ private int _previewEdge = DefaultPreviewEdge;
+ private int _previewVersion;
+ private bool _previewBusy;
+ private RenderCorrections? _correctionsValue;
+ private ExportPlan? _plan;
+ private IReadOnlyList _markers = [];
+ private IThumbnailSource _thumbnails;
+ private int _playLimit;
+ private bool _disposed;
+
+ public EditorViewModel(ShellViewModel shell, EditorSession session, IReadOnlyList encoders, EncoderHost host)
+ {
+ Shell = shell;
+ Session = session;
+ _encoders = encoders;
+ _host = host;
+ _dispatcher = Dispatcher.CurrentDispatcher;
+ _renderer = new PreviewRenderer(session.Content, session.Source);
+ Planner = new ExportPlanner(session.Content, encoders, host);
+ _thumbnails = new EditorThumbnails(session.Source, session.Content.Count);
+ _player = new DispatcherTimer(DispatcherPriority.Background, _dispatcher);
+ _player.Tick += (_, _) => Advance();
+
+ Frames = new FramesTab(this);
+ Exposure = new ExposureTab(this);
+ Tabs = [Frames, Exposure, new MotionTab(this), new CameraTab(this), new TimeTab(this), new StackTab(this), new ExportTab(this)];
+ _selectedTab = Exposure;
+ _currentIndex = session.Project.HeroFrame is { } hero && (uint)hero < (uint)FrameCount ? hero : 0;
+ RenderChoices = [.. ExportPresets.BuiltIn.Select(p => new Choice(p.Id, p.NameKey))];
+
+ BackCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Library));
+ AnalyseCommand = new AsyncRelayCommand(AnalyseAsync, () => !IsBusy);
+ OptimiseAllCommand = new RelayCommand(OptimiseAll, () => !IsBusy);
+ RenderCommand = new AsyncRelayCommand(() => RenderAsync(JobPriority.User, batch: false), () => CanRender);
+ UndoCommand = new RelayCommand(() => Session.Undo(), () => !IsBusy && Session.History.CanUndo);
+ RedoCommand = new RelayCommand(() => Session.Redo(), () => !IsBusy && Session.History.CanRedo);
+ PlayCommand = new RelayCommand(() => TogglePlay(limit: 0));
+ PreviewClipCommand = new RelayCommand(() => TogglePlay(limit: ClipFrames()));
+ StepBackCommand = new RelayCommand(() => CurrentIndex--);
+ StepForwardCommand = new RelayCommand(() => CurrentIndex++);
+ FitCommand = new RelayCommand(() => ZoomMode = PreviewZoomMode.Fit);
+ ActualSizeCommand = new RelayCommand(() => ZoomMode = PreviewZoomMode.Actual);
+
+ session.ProjectChanged += OnProjectChanged;
+ session.ContentChanged += OnContentChanged;
+ session.SaveFailed += OnSaveFailed;
+ if (shell.Services.Jobs is { } jobs) jobs.JobChanged += OnJobChanged;
+ UpdateMarkers();
+ RequestCorrections();
+ RequestPlan();
+ RequestPreview(immediate: true);
+ }
+
+ public ShellViewModel Shell { get; }
+
+ public EditorSession Session { get; }
+
+ public ExportPlanner Planner { get; private set; }
+
+ public string Title => Session.Content.Sequence.DisplayTitle;
+
+ /// "3,600 frames · Canon EOS R5 · 2 s interval · 2 h 00 m · 3 warnings".
+ public string Summary => EditorText.Summary(Session.Content, Session.Advice.Findings.Count(f => f.Severity >= FindingSeverity.Warning));
+
+ public FramesTab Frames { get; }
+
+ public ExposureTab Exposure { get; }
+
+ public IReadOnlyList Tabs { get; }
+
+ public EditorTab SelectedTab
+ {
+ get => _selectedTab;
+ set
+ {
+ if (value is null || !Set(ref _selectedTab, value)) return;
+ OnPropertyChanged(nameof(IsExportTab));
+ if (IsExportTab && !ShowCropMask) ShowCropMask = true;
+ UpdateInfo();
+ }
+ }
+
+ /// The Export tab swaps the preview tools for compare, crop mask and a 10-second preview (Export.html).
+ public bool IsExportTab => SelectedTab is ExportTab;
+
+ // ---- Frames ----
+
+ public int FrameCount => Session.Content.Count;
+
+ /// The frame on screen; the filmstrip, the charts and the frame table seek it.
+ public int CurrentIndex
+ {
+ get => _currentIndex;
+ set
+ {
+ var clamped = FrameCount == 0 ? 0 : int.Clamp(value, 0, FrameCount - 1);
+ if (!Set(ref _currentIndex, clamped)) return;
+ Frames.OnCurrentFrameChanged();
+ foreach (var tab in Tabs.OfType()) tab.OnCurrentFrameChanged();
+ foreach (var tab in Tabs.OfType()) tab.OnCurrentFrameChanged();
+ UpdateInfo();
+ RequestPreview(immediate: _player.IsEnabled);
+ }
+ }
+
+ public IThumbnailSource Thumbnails { get => _thumbnails; private set => Set(ref _thumbnails, value); }
+
+ /// Exposure steps (as received), warnings and keyframes above the filmstrip.
+ public IReadOnlyList Markers { get => _markers; private set => Set(ref _markers, value); }
+
+ // ---- Preview ----
+
+ public ImageSource? PreviewImage { get => _previewImage; private set => Set(ref _previewImage, value); }
+
+ public ImageSource? OriginalImage { get => _originalImage; private set => Set(ref _originalImage, value); }
+
+ public bool IsCompare { get => _isCompare; set => Set(ref _isCompare, value); }
+
+ public bool ShowVectors
+ {
+ get => _showVectors;
+ set
+ {
+ if (Set(ref _showVectors, value)) RequestPreview(immediate: true);
+ }
+ }
+
+ public bool ShowRegions
+ {
+ get => _showRegions;
+ set
+ {
+ if (Set(ref _showRegions, value)) RequestPreview(immediate: true);
+ }
+ }
+
+ public bool ShowCropMask
+ {
+ get => _showCropMask;
+ set
+ {
+ if (Set(ref _showCropMask, value)) RequestPreview(immediate: true);
+ }
+ }
+
+ public PreviewZoomMode ZoomMode
+ {
+ get => _zoomMode;
+ set
+ {
+ if (Set(ref _zoomMode, value)) OnPropertyChanged(nameof(IsActualSize));
+ }
+ }
+
+ /// The 1:1 tool (raw pixels).
+ public bool IsActualSize
+ {
+ get => _zoomMode == PreviewZoomMode.Actual;
+ set => ZoomMode = value ? PreviewZoomMode.Actual : PreviewZoomMode.Fit;
+ }
+
+ public Rect CropRect { get => _cropRect; private set => Set(ref _cropRect, value); }
+
+ public IReadOnlyList? RegionBoundary { get => _regionBoundary; private set => Set(ref _regionBoundary, value); }
+
+ public IReadOnlyList? MotionVectors { get => _motionVectors; private set => Set(ref _motionVectors, value); }
+
+ /// Gain on vector lengths so a pixel of motion stays visible.
+ public double VectorScale => 4;
+
+ public string WipeLabel => Loc.L("Editor.Preview.Wipe");
+
+ /// Shot data (bottom-right pill): frame, time, exposure; on the Export tab output time and size.
+ public string? InfoText { get; private set; }
+
+ /// Long edge of the preview picture in device pixels (the view reports its size).
+ public int PreviewEdge
+ {
+ get => _previewEdge;
+ set
+ {
+ var rounded = int.Clamp((value + 63) / 64 * 64, 256, 4096);
+ if (Set(ref _previewEdge, rounded)) RequestPreview();
+ }
+ }
+
+ // ---- Analysis, plan, jobs ----
+
+ /// The corrections of the current exposure settings, once prepared (target curves).
+ public RenderCorrections? Corrections { get => _correctionsValue; private set => Set(ref _correctionsValue, value); }
+
+ /// What the project's export will produce (size, time, encoder, name).
+ public ExportPlan? Plan { get => _plan; private set => Set(ref _plan, value); }
+
+ /// An analysis or render of this sequence is running: settings wait, viewing tools stay live.
+ public bool IsBusy => _jobs.Values.Any(j => j.State == JobState.Running);
+
+ public bool IsEditable => !IsBusy;
+
+ public string? BusyToolTip => IsBusy ? Loc.L("Tooltips.Editor.Busy") : null;
+
+ public bool IsPlaying => _player.IsEnabled;
+
+ public string PlayToolTip => Loc.L(IsPlaying ? "Tooltips.Editor.Pause" : "Tooltips.Editor.Play");
+
+ // ---- Render ----
+
+ public IReadOnlyList RenderChoices { get; }
+
+ /// The export preset the Render button renders (choosing another one sets it).
+ public Choice? SelectedRenderChoice
+ {
+ get => RenderChoices.FirstOrDefault(c => string.Equals((string)c.Value, Plan?.Export.PresetId ?? EditorSettings.ExportPreset.Effective(Session.Project, null),
+ StringComparison.OrdinalIgnoreCase));
+ set
+ {
+ if (value?.Value is not string id) return;
+ Session.Edit(p => p with { Export = p.Export with { Preset = p.Export.Preset.WithManual(id), Overrides = new ExportOverrides() } });
+ }
+ }
+
+ /// "Render · 4K archive".
+ public string RenderText => Loc.L("Editor.Render", Plan?.PresetName ?? string.Empty);
+
+ public string RenderToolTip => Plan is { } plan && !plan.Setup.Encoder.IsReady && plan.Setup.Encoder.Notices.LastOrDefault() is { } notice
+ ? Loc.L(notice.Key, [.. notice.Args])
+ : Loc.L("Tooltips.Editor.Render");
+
+ public bool CanRender => Plan is { NameError: null, Setup: { Encoder.IsReady: true, Plan.Frames.Count: > 0 } };
+
+ public ICommand BackCommand { get; }
+ public ICommand AnalyseCommand { get; }
+ public ICommand OptimiseAllCommand { get; }
+ public ICommand RenderCommand { get; }
+ public ICommand UndoCommand { get; }
+ public ICommand RedoCommand { get; }
+ public ICommand PlayCommand { get; }
+ public ICommand PreviewClipCommand { get; }
+ public ICommand StepBackCommand { get; }
+ public ICommand StepForwardCommand { get; }
+ public ICommand FitCommand { get; }
+ public ICommand ActualSizeCommand { get; }
+
+ /// Exposure steps of the sequence: as received by the pixels when the deep analysis measured them, else from the metadata.
+ public static IReadOnlyList StepMarkers(SequenceContent content)
+ {
+ ArgumentNullException.ThrowIfNull(content);
+ if (content.Deep is { } deep)
+ {
+ return [.. deep.Exposure.Steps.Select(s => new TimelineMarker(s.Index, s.Received ? MarkerKind.ExposureStep : MarkerKind.Warning,
+ Loc.L(s.Received ? "Editor.Marker.Step" : "Editor.Marker.StepIgnored", Ev(s.MeasuredEv ?? s.ExpectedEv))))];
+ }
+ return [.. content.Light.ExposureSteps.Select(s => new TimelineMarker(s.Index, MarkerKind.ExposureStep, Loc.L("Editor.Marker.Step", Ev(s.DeltaEv))))];
+ }
+
+ /// "Optimise section": the advisor's heavier decisions, reported in a toast (what changed, from what to what).
+ public void Optimise(AdvisorSection section) => Report(Session.Optimise(section));
+
+ /// Queues a render of the project's export (with its batch presets when ).
+ public async Task RenderAsync(JobPriority priority, bool batch)
+ {
+ var export = batch ? Session.Project.Export : Session.Project.Export with { Batch = [] };
+ var request = Session.RenderRequest(export) with { Priority = priority };
+ await Session.SubmitAsync(request);
+ Shell.Notify(Loc.L("Editor.Render.Queued"), request.Label, Loc.L("Shell.Nav.Jobs"), Loc.L("Tooltips.Nav.Jobs"), () => Shell.Navigate(SectionKey.Jobs));
+ }
+
+ /// Loads the jobs of this sequence already queued or running (busy state).
+ public async Task AttachJobsAsync()
+ {
+ if (Shell.Services.Jobs is not { } jobs) return;
+ var page = await jobs.ListAsync(null, 200);
+ foreach (var job in page.Items) Track(job);
+ OnBusyChanged();
+ }
+
+ public async ValueTask DisposeAsync()
+ {
+ if (_disposed) return;
+ _disposed = true;
+ _player.Stop();
+ _preview.Dispose();
+ _corrections.Dispose();
+ _plans.Dispose();
+ Session.ProjectChanged -= OnProjectChanged;
+ Session.ContentChanged -= OnContentChanged;
+ Session.SaveFailed -= OnSaveFailed;
+ if (Shell.Services.Jobs is { } jobs) jobs.JobChanged -= OnJobChanged;
+ foreach (var tab in Tabs) tab.Dispose();
+ base.Dispose();
+ await Session.DisposeAsync();
+ }
+
+ public override void Dispose() => _ = DisposeAsync().AsTask();
+
+ // ---- Preview pipeline ----
+
+ private void RequestPreview(bool immediate = false)
+ {
+ if (_disposed || FrameCount == 0) return;
+ var framing = ShowCropMask || ShowRegions ? PreviewFraming.Source : PreviewFraming.Output;
+ var request = new PreviewRequest(CurrentIndex, Session.Project, PreviewEdge, framing, ShowVectors);
+ var version = ++_previewVersion;
+ _ = RunPreviewAsync(request, version, immediate);
+ }
+
+ private async Task RunPreviewAsync(PreviewRequest request, int version, bool immediate)
+ {
+ var renderer = _renderer;
+ PreviewResult? result = null;
+ _previewBusy = true;
+ try
+ {
+ await _preview.Schedule(async token =>
+ {
+ using var frame = await renderer.RenderAsync(request, renderer.Cached(request.Project) ?? renderer.Latest, token);
+ if (frame is not null) result = PreviewResult.From(frame);
+ }, immediate);
+ }
+ catch (Exception ex) when (ex is not OperationCanceledException)
+ {
+ Log.Warning("editor", $"Preview of frame {request.Index + 1} failed", ex);
+ }
+ finally
+ {
+ if (version == _previewVersion) _previewBusy = false;
+ }
+ if (result is not { } r || version != _previewVersion || _disposed) return;
+ PreviewImage = r.Corrected;
+ OriginalImage = r.Original;
+ CropRect = r.Crop;
+ RegionBoundary = ShowRegions ? r.Horizon : null;
+ MotionVectors = ShowVectors ? r.Vectors : null;
+ }
+
+ private void RequestCorrections()
+ {
+ if (_disposed) return;
+ var renderer = _renderer;
+ var project = Session.Project;
+ if (renderer.Cached(project) is { } cached)
+ {
+ Corrections = cached;
+ NotifyCorrections();
+ return;
+ }
+ _ = RunCorrectionsAsync(renderer, project);
+ }
+
+ private async Task RunCorrectionsAsync(PreviewRenderer renderer, ProjectSettings project)
+ {
+ RenderCorrections? prepared = null;
+ try
+ {
+ await _corrections.Schedule(async token => prepared = await renderer.PrepareAsync(project, token));
+ }
+ catch (Exception ex) when (ex is not OperationCanceledException)
+ {
+ Log.Warning("editor", "Preparing the preview corrections failed", ex);
+ }
+ if (prepared is null || _disposed || !ReferenceEquals(renderer, _renderer) || !ReferenceEquals(project, Session.Project)) return;
+ Corrections = prepared;
+ NotifyCorrections();
+ RequestPreview(immediate: true);
+ }
+
+ private void NotifyCorrections()
+ {
+ foreach (var tab in Tabs) tab.OnCorrectionsChanged();
+ }
+
+ private void RequestPlan() => _ = RunPlanAsync(Planner, Session.Project);
+
+ private async Task RunPlanAsync(ExportPlanner planner, ProjectSettings project)
+ {
+ ExportPlan? plan = null;
+ try
+ {
+ await _plans.Schedule(_ =>
+ {
+ plan = planner.Plan(project);
+ return Task.CompletedTask;
+ });
+ }
+ catch (Exception ex) when (ex is ArgumentException or InvalidOperationException or RenderException)
+ {
+ Log.Warning("editor", "Planning the export failed", ex);
+ }
+ if (_disposed || !ReferenceEquals(planner, Planner) || !ReferenceEquals(project, Session.Project)) return;
+ Plan = plan;
+ OnPropertyChanged(nameof(RenderText));
+ OnPropertyChanged(nameof(RenderToolTip));
+ OnPropertyChanged(nameof(SelectedRenderChoice));
+ foreach (var tab in Tabs) tab.OnPlanChanged();
+ UpdateInfo();
+ CommandManager.InvalidateRequerySuggested();
+ }
+
+ // ---- Playback ----
+
+ private void TogglePlay(int limit)
+ {
+ if (_player.IsEnabled)
+ {
+ _player.Stop();
+ }
+ else
+ {
+ if (CurrentIndex >= FrameCount - 1) CurrentIndex = 0;
+ _playLimit = limit;
+ var fps = double.Clamp(Plan?.Setup.Plan.FrameRate.Value ?? 24, 5, 30);
+ _player.Interval = TimeSpan.FromSeconds(1 / fps);
+ _player.Start();
+ }
+ OnPropertyChanged(nameof(IsPlaying));
+ OnPropertyChanged(nameof(PlayToolTip));
+ }
+
+ /// Next frame while playing; frames are skipped rather than queued when the preview is slower than the clock.
+ private void Advance()
+ {
+ if (_previewBusy) return;
+ if (CurrentIndex >= FrameCount - 1 || (_playLimit > 0 && --_playLimit == 0))
+ {
+ TogglePlay(0);
+ return;
+ }
+ CurrentIndex++;
+ }
+
+ /// Source frames that make ten seconds of video.
+ private int ClipFrames()
+ {
+ if (Plan is not { } plan || plan.Setup.Plan.DurationSeconds <= 0) return 240;
+ return int.Max(1, (int)(plan.Setup.Plan.IncludedFrames.Count * double.Min(1, 10 / plan.Setup.Plan.DurationSeconds)));
+ }
+
+ // ---- Changes ----
+
+ private void OnProjectChanged()
+ {
+ foreach (var tab in Tabs) tab.Refresh();
+ UpdateMarkers();
+ RequestCorrections();
+ RequestPlan();
+ RequestPreview();
+ CommandManager.InvalidateRequerySuggested();
+ }
+
+ private void OnContentChanged()
+ {
+ _renderer = new PreviewRenderer(Session.Content, Session.Source);
+ Planner = new ExportPlanner(Session.Content, _encoders, _host);
+ if (Thumbnails.Count != FrameCount) Thumbnails = new EditorThumbnails(Session.Source, FrameCount);
+ Corrections = null;
+ foreach (var tab in Tabs) tab.OnContentChanged();
+ OnPropertyChanged(nameof(Summary));
+ OnPropertyChanged(nameof(FrameCount));
+ CurrentIndex = int.Min(CurrentIndex, int.Max(0, FrameCount - 1));
+ UpdateMarkers();
+ RequestCorrections();
+ RequestPlan();
+ RequestPreview(immediate: true);
+ }
+
+ private void OnSaveFailed(Exception ex) => Shell.ReportError(ex);
+
+ private void UpdateMarkers()
+ {
+ var content = Session.Content;
+ var markers = new List(StepMarkers(content));
+ foreach (var finding in Session.Advice.Findings.Where(f => f.Severity >= FindingSeverity.Warning))
+ {
+ var text = Loc.L(finding.Key, finding.Arguments);
+ markers.AddRange(finding.Frames.Take(64).Select(i => new TimelineMarker(i, finding.Severity == FindingSeverity.Error ? MarkerKind.Error : MarkerKind.Warning, text)));
+ }
+ markers.AddRange(Session.Project.Camera.Keyframes.Select(k => new TimelineMarker(k.Frame, MarkerKind.Keyframe, Loc.L("Editor.Marker.Keyframe"))));
+ if (!markers.SequenceEqual(Markers)) Markers = markers;
+ }
+
+ private void UpdateInfo()
+ {
+ if (FrameCount == 0)
+ {
+ InfoText = null;
+ }
+ else if (IsExportTab && Plan is { } plan)
+ {
+ var settings = plan.Setup.Encoder.Settings;
+ var position = plan.Setup.Plan.DurationSeconds * CurrentIndex / double.Max(1, FrameCount - 1);
+ InfoText = string.Join(" · ", EditorText.Position(CurrentIndex, FrameCount),
+ Loc.L("Editor.Preview.OutputTime", Clock(position), Clock(plan.Setup.Plan.DurationSeconds)),
+ Loc.L("Editor.Preview.OutputSize", EditorText.Size(settings.Width, settings.Height)));
+ }
+ else
+ {
+ InfoText = EditorText.Shot(Session.Content.Frames[CurrentIndex], CurrentIndex, FrameCount);
+ }
+ OnPropertyChanged(nameof(InfoText));
+ }
+
+ private void OptimiseAll() => Report(Session.OptimiseAll());
+
+ private void Report(IReadOnlyList changes)
+ {
+ if (changes.Count == 0)
+ {
+ Shell.Notify(Loc.L("Editor.Optimise.Nothing"));
+ return;
+ }
+ var lines = changes.Select(c => Loc.L("Editor.Optimise.Change", ParameterLabel(c.Parameter), ValueText(c.Before), ValueText(c.After)));
+ Shell.Notify(Loc.Plural("Editor.Optimise.Done", changes.Count), string.Join(Environment.NewLine, lines));
+ }
+
+ private async Task AnalyseAsync()
+ {
+ await Session.SubmitAsync(Session.AnalysisRequest());
+ Shell.Notify(Loc.L("Editor.Analyse.Queued"), Title, Loc.L("Shell.Nav.Jobs"), Loc.L("Tooltips.Nav.Jobs"), () => Shell.Navigate(SectionKey.Jobs));
+ }
+
+ private void OnJobChanged(Job job)
+ {
+ if (!job.TargetIds.Contains(Session.Content.Sequence.Id) || job.Kind is not (JobKind.DeepAnalyse or JobKind.LightAnalyse or JobKind.Render)) return;
+ _dispatcher.BeginInvoke(() =>
+ {
+ if (_disposed) return;
+ var wasActive = _jobs.ContainsKey(job.Id);
+ Track(job);
+ OnBusyChanged();
+ if (wasActive && job.State == JobState.Done) _ = ReloadAsync();
+ });
+ }
+
+ private void Track(Job job)
+ {
+ if (!job.TargetIds.Contains(Session.Content.Sequence.Id) || job.Kind is not (JobKind.DeepAnalyse or JobKind.LightAnalyse or JobKind.Render)) return;
+ if (job.State is JobState.Queued or JobState.Running) _jobs[job.Id] = job;
+ else _jobs.Remove(job.Id);
+ }
+
+ private async Task ReloadAsync()
+ {
+ try
+ {
+ await Session.ReloadAsync();
+ }
+ catch (Exception ex) when (ex is System.IO.IOException or System.IO.InvalidDataException or InvalidOperationException)
+ {
+ Shell.ReportError(ex);
+ }
+ }
+
+ private void OnBusyChanged()
+ {
+ OnPropertyChanged(nameof(IsBusy));
+ OnPropertyChanged(nameof(IsEditable));
+ OnPropertyChanged(nameof(BusyToolTip));
+ CommandManager.InvalidateRequerySuggested();
+ }
+
+ private static string Clock(double seconds)
+ {
+ var t = TimeSpan.FromSeconds(double.Max(0, seconds));
+ return ((int)t.TotalMinutes).ToString("00", Loc.Culture) + ":" + t.Seconds.ToString("00", Loc.Culture) + Loc.Culture.NumberFormat.NumberDecimalSeparator
+ + (t.Milliseconds / 100).ToString(Loc.Culture);
+ }
+
+ private static string Ev(double ev) => ev.ToString("+0.0;−0.0;0.0", Loc.Culture);
+
+ private static string ParameterLabel(string parameter) => parameter switch
+ {
+ AdvisorParameters.Hero => Loc.L("Editor.Frames.HeroLabel"),
+ AdvisorParameters.Excluded => Loc.L("Editor.Frames.ExcludedLabel"),
+ AdvisorParameters.TimingMode => Loc.L("Editor.Time.Mode"),
+ AdvisorParameters.FrameRate => Loc.L("Editor.Time.Rate"),
+ AdvisorParameters.FitToSeconds => Loc.L("Editor.Time.Fit"),
+ AdvisorParameters.Deflicker => Loc.L("Editor.Exposure.Deflicker"),
+ AdvisorParameters.DeflickerWindow => Loc.L("Editor.Exposure.Window"),
+ AdvisorParameters.DeflickerStrength => Loc.L("Editor.Exposure.Strength"),
+ AdvisorParameters.Regions => Loc.L("Editor.Exposure.Regions"),
+ AdvisorParameters.HolyGrail => Loc.L("Editor.Exposure.HolyGrail"),
+ AdvisorParameters.TransitionLength => Loc.L("Editor.Exposure.Transitions"),
+ AdvisorParameters.WhiteBalanceSmoothing => Loc.L("Editor.Exposure.WhiteBalance"),
+ AdvisorParameters.MotionBlur => Loc.L("Editor.Motion.Blur"),
+ AdvisorParameters.TargetShutterAngle => Loc.L("Editor.Motion.Shutter"),
+ AdvisorParameters.FlowQuality => Loc.L("Editor.Motion.Flow"),
+ AdvisorParameters.Stabilize => Loc.L("Editor.Motion.Stabilize"),
+ AdvisorParameters.StabilizeSmoothing => Loc.L("Editor.Motion.Smoothing"),
+ AdvisorParameters.Aspect => Loc.L("Editor.Camera.Aspect"),
+ AdvisorParameters.OffsetY => Loc.L("Editor.Camera.OffsetY"),
+ AdvisorParameters.ExportPreset => Loc.L("Editor.Export.Preset"),
+ AdvisorParameters.Resolution => Loc.L("Editor.Export.Resolution"),
+ _ => parameter,
+ };
+
+ private static string ValueText(object? value) => value switch
+ {
+ null => Loc.L("Editor.Value.None"),
+ bool b => Loc.L(b ? "Editor.Value.On" : "Editor.Value.Off"),
+ TimingMode m => Loc.L("Editor.Timing." + m),
+ RegionMode m => m == RegionMode.Off ? Loc.L("Editor.Value.Off") : Loc.L("Editor.Regions." + m),
+ FlowQualitySetting q => Loc.L("Editor.Flow." + q),
+ string id when ExportPresets.Find(id) is { } preset => Loc.L(preset.NameKey),
+ string text => text,
+ double d => d.ToString("0.##", Loc.Culture),
+ IEnumerable list => Loc.Plural("Editor.Value.Frames", list.Cast
public sealed class ExportPlanner(SequenceContent content, IReadOnlyList encoders, EncoderHost host, ThroughputModel? model = null)
{
+ /// Encoder providers of the machine that renders, in priority order.
+ public IReadOnlyList Encoders { get; } = encoders;
+
/// Sequence presets that fit the content, then every built-in export preset.
public static IReadOnlyList Choices(IReadOnlyList presets, AdvisorResult advice)
{
@@ -69,7 +72,7 @@ public sealed class ExportPlanner(SequenceContent content, IReadOnlyListA preset card of the Export tab (Export.html): what it renders and what it will cost on this machine.
+public sealed class PresetCard(ExportTab owner, ExportChoice choice) : ObservableObject
+{
+ private string? _format;
+ private string? _encoding;
+ private string? _estimate;
+ private bool _isSelected;
+
+ public ExportChoice Choice { get; } = choice;
+
+ public string Name => Choice.Name;
+
+ public bool IsRecommended => Choice.IsRecommended;
+
+ /// Sequence presets apply full settings; export presets only choose the output.
+ public bool IsSequencePreset => Choice.Sequence is not null;
+
+ public string ToolTip => Choice.Reason is { } reason
+ ? Loc.L(IsSequencePreset ? "Tooltips.Editor.Export.ApplyPreset" : "Tooltips.Editor.Export.Recommended", reason)
+ : Loc.L("Tooltips.Editor.Export.Preset", Name);
+
+ /// "MP4 · HEVC Main10 · 3840×2160 · 24 fps".
+ public string? Format { get => _format; private set => Set(ref _format, value); }
+
+ /// "120 Mb/s · 0.07 bpp · NVENC".
+ public string? Encoding { get => _encoding; private set => Set(ref _encoding, value); }
+
+ /// "2.2 GB · about 5 min".
+ public string? Estimate { get => _estimate; private set => Set(ref _estimate, value); }
+
+ public bool IsSelected { get => _isSelected; set => Set(ref _isSelected, value); }
+
+ /// Ticked for "Batch…" (export presets only).
+ public bool IsInBatch
+ {
+ get => owner.IsInBatch(Choice.ExportPresetId);
+ set => owner.SetInBatch(Choice.ExportPresetId, value);
+ }
+
+ public bool CanBatch => !IsSequencePreset;
+
+ public ICommand SelectCommand => owner.SelectCommand;
+
+ public void Update(ExportPlan? plan)
+ {
+ if (plan is null)
+ {
+ Format = Encoding = Estimate = null;
+ return;
+ }
+ var settings = plan.Setup.Encoder.Settings;
+ Format = EditorText.Format(plan.Export, settings.Width, settings.Height);
+ Encoding = EditorText.Encoding(plan.Export, settings.BitRate, plan.Setup.Encoder.Capability?.Name);
+ Estimate = plan.Setup.Encoder.IsReady ? EditorText.Estimate(plan.Estimate) : Loc.L("Editor.Export.Unavailable");
+ }
+
+ public void RefreshBatch() => OnPropertyChanged(nameof(IsInBatch));
+}
+
+/// A codec choice of the Output panel with the profile and depth it implies.
+public sealed record CodecChoice(VideoCodec Codec, CodecProfile Profile, int BitDepth)
+{
+ public ContainerFormat Container => VideoCodecInfo.DefaultContainer(Codec);
+
+ public string Label => EditorText.CodecName(Codec, Profile, BitDepth);
+}
+
+/// Where renders go: the sequence's exports folder or a folder the user picked.
+public sealed record SaveChoice(string? Folder, bool Browse = false)
+{
+ public string Label => Browse ? Loc.L("Editor.Export.Browse") : Folder is null ? Loc.L("Editor.Export.SequenceFolder") : Path.GetFileName(Folder.TrimEnd('\\', '/'));
+}
+
+///
+/// Export (Export.html, BRIEF §11.4–11.5): preset cards with size and time estimates, the Output panel (container,
+/// codec, size, frame rate, quality, encoder, colour depth, name template, folder) with the estimate and the encoder's
+/// notices, and the render actions (now, queue, batch). Editing a value makes the preset "Custom" (§11.4).
+///
+public sealed class ExportTab : EditorTab
+{
+ public static IReadOnlyList Codecs { get; } =
+ [
+ new(VideoCodec.H264, CodecProfile.H264High, 8), new(VideoCodec.Hevc, CodecProfile.HevcMain, 8), new(VideoCodec.Hevc, CodecProfile.HevcMain10, 10),
+ new(VideoCodec.Av1, CodecProfile.Av1Main, 10), new(VideoCodec.Mjpeg, CodecProfile.Auto, 8), new(VideoCodec.Gif, CodecProfile.Auto, 8),
+ new(VideoCodec.Apng, CodecProfile.Auto, 8), new(VideoCodec.PngSequence, CodecProfile.Auto, 8), new(VideoCodec.JpegSequence, CodecProfile.Auto, 8),
+ new(VideoCodec.Tiff16Sequence, CodecProfile.Auto, 16), new(VideoCodec.LinearDngSequence, CodecProfile.Auto, 16),
+ ];
+
+ private readonly LatestRunner _estimates = new(TimeSpan.FromMilliseconds(250));
+ private IReadOnlyList _cards = [];
+ private IReadOnlyList _codecChoices = [];
+ private IReadOnlyList _encoders = [];
+ private IReadOnlyList _saveChoices = [];
+ private IReadOnlyList _depths = [];
+ private IReadOnlyList _notices = [];
+ private bool _refreshing;
+
+ public ExportTab(EditorViewModel editor)
+ : base(editor, "Export", AdvisorSection.Export)
+ {
+ SelectCommand = new RelayCommand(p => Select(p as PresetCard), _ => !Editor.IsBusy);
+ RenderNowCommand = new AsyncRelayCommand(() => Editor.RenderAsync(JobPriority.User, batch: false), () => Editor.CanRender);
+ AddToQueueCommand = new AsyncRelayCommand(() => Editor.RenderAsync(JobPriority.Normal, batch: false), () => Editor.CanRender);
+ BatchCommand = new AsyncRelayCommand(() => Editor.RenderAsync(JobPriority.User, batch: true), () => Editor.CanRender && Batch.Count > 0);
+ HistoryCommand = new RelayCommand(() => Editor.Shell.Navigate(Shell.SectionKey.Jobs));
+ ResetFrameRateCommand = new RelayCommand(() => EditOverrides(o => o with { FrameRate = null }));
+ Width = new EditableField(string.Empty, ValidateSize, v => EditOverrides(o => o with { Width = ParseSize(v) }), () => Loc.L("Tooltips.Editor.Export.Width"));
+ Height = new EditableField(string.Empty, ValidateSize, v => EditOverrides(o => o with { Height = ParseSize(v) }), () => Loc.L("Tooltips.Editor.Export.Height"));
+ NameTemplate = new EditableField(string.Empty, ValidateTemplate, v => EditExport(e => e with { NameTemplate = v }), () => Loc.L("Tooltips.Editor.Export.Name"));
+ LoadCards();
+ Refresh();
+ }
+
+ public IReadOnlyList Cards { get => _cards; private set => Set(ref _cards, value); }
+
+ public ICommand SelectCommand { get; }
+
+ public ICommand RenderNowCommand { get; }
+
+ public ICommand AddToQueueCommand { get; }
+
+ public ICommand BatchCommand { get; }
+
+ public ICommand HistoryCommand { get; }
+
+ public ICommand ResetFrameRateCommand { get; }
+
+ /// "Output · 4K archive".
+ public string Title => Loc.L("Editor.Export.Output", Editor.Plan?.PresetName ?? ProcessingJobs.PresetName(ExportResolver.Resolve(Export)));
+
+ public IReadOnlyList Containers { get; } =
+ [
+ new(ContainerFormat.Mp4, "Export.Container.Mp4"), new(ContainerFormat.Avi, "Export.Container.Avi"), new(ContainerFormat.Gif, "Export.Container.Gif"),
+ new(ContainerFormat.Apng, "Export.Container.Apng"), new(ContainerFormat.ImageSequence, "Export.Container.ImageSequence"),
+ ];
+
+ public Choice? SelectedContainer
+ {
+ get => Containers.FirstOrDefault(c => Equals(c.Value, Resolved.Container));
+ set
+ {
+ if (_refreshing || value?.Value is not ContainerFormat container || container == Resolved.Container) return;
+ SelectCodec(Codecs.First(c => c.Container == container));
+ }
+ }
+
+ public IReadOnlyList CodecChoices { get => _codecChoices; private set => Set(ref _codecChoices, value); }
+
+ public CodecChoice? SelectedCodec
+ {
+ get => CodecChoices.FirstOrDefault(c => c.Codec == Resolved.Codec && (c.Codec != VideoCodec.Hevc || (c.BitDepth > 8) == (Resolved.BitDepth > 8)));
+ set
+ {
+ if (!_refreshing && value is not null) SelectCodec(value);
+ }
+ }
+
+ public EditableField Width { get; }
+
+ public EditableField Height { get; }
+
+ /// "16:9".
+ public string AspectText => Editor.Plan is { } plan ? Aspect(plan.Setup.Encoder.Settings.Width, plan.Setup.Encoder.Settings.Height) : string.Empty;
+
+ public IReadOnlyList FrameRates { get; } = [.. ExportPresets.FrameRates.Select(r => new Choice(FrameRateText.Format(r), "Editor.Value.Number", EditorText.FrameRate(r)))];
+
+ public Choice? SelectedFrameRate
+ {
+ get => FrameRates.FirstOrDefault(c => FrameRateText.TryParse((string)c.Value, out var r) && FrameRateText.AreEqual(r, Resolved.FrameRate));
+ set
+ {
+ if (!_refreshing && value?.Value is string rate) EditOverrides(o => o with { FrameRate = rate });
+ }
+ }
+
+ /// The preset's own frame rate is in force (no override).
+ public bool IsFrameRateAuto => Export.Overrides.FrameRate is null;
+
+ public string FrameRateAutoToolTip => Loc.L("Tooltips.Editor.Export.FrameRateAuto", EditorText.FrameRate(ExportResolver.Resolve(Export with { Overrides = new ExportOverrides() }).FrameRate));
+
+ /// Bit rate in Mb/s (video) or quality 1–100 (JPEG, MJPEG, GIF).
+ public double Quality
+ {
+ get => IsBitRate ? (Editor.Plan?.Setup.Encoder.Settings.BitRate ?? Resolved.BitRate) / 1e6 : Resolved.Quality;
+ set
+ {
+ if (_refreshing) return;
+ if (IsBitRate) EditOverrides(o => o with { BitRate = (long)(double.Round(value) * 1e6) }, "Export.Quality");
+ else EditOverrides(o => o with { Quality = (int)double.Round(value) }, "Export.Quality");
+ }
+ }
+
+ public bool IsBitRate => !VideoCodecInfo.IsManaged(Resolved.Codec);
+
+ public double QualityMaximum => IsBitRate ? 400 : 100;
+
+ public bool IsQualityApplicable => IsBitRate || Resolved.Codec is VideoCodec.Mjpeg or VideoCodec.JpegSequence or VideoCodec.Gif;
+
+ public string? QualityNotApplicable => IsQualityApplicable ? null : Loc.L("Tooltips.Editor.NotApplicable.Lossless");
+
+ public string QualityText => IsBitRate ? EditorText.BitRate((long)(Quality * 1e6)) : Quality.ToString("0", Loc.Culture);
+
+ public string QualityToolTip => Loc.L(IsBitRate ? "Tooltips.Editor.Export.BitRate" : "Tooltips.Editor.Export.Quality");
+
+ public IReadOnlyList Encoders { get => _encoders; private set => Set(ref _encoders, value); }
+
+ public Choice? SelectedEncoder
+ {
+ get => Encoders.FirstOrDefault(e => Equals(e.Value, Export.Overrides.Encoder ?? string.Empty));
+ set
+ {
+ if (!_refreshing && value?.Value is string name) EditOverrides(o => o with { Encoder = name.Length == 0 ? null : name });
+ }
+ }
+
+ /// "hardware", "software" (the word, not a colour, carries the state).
+ public string? EncoderKind => Editor.Plan?.Setup.Encoder.Capability is { } c ? Loc.L(c.Hardware ? "Editor.Export.Hardware" : "Editor.Export.Software") : null;
+
+ public bool IsHardware => Editor.Plan?.Setup.Encoder.Capability?.Hardware == true;
+
+ public IReadOnlyList Depths { get => _depths; private set => Set(ref _depths, value); }
+
+ public Choice? SelectedDepth
+ {
+ get => Depths.FirstOrDefault(d => (int)d.Value == Resolved.BitDepth) ?? Depths[0];
+ set
+ {
+ if (_refreshing || value?.Value is not int depth || depth == Resolved.BitDepth) return;
+ EditOverrides(o => o with
+ {
+ BitDepth = depth,
+ Profile = Resolved.Codec == VideoCodec.Hevc ? (depth > 8 ? CodecProfile.HevcMain10 : CodecProfile.HevcMain).ToString() : o.Profile,
+ });
+ }
+ }
+
+ public bool CanChooseDepth => Depths.Count > 1;
+
+ public EditableField NameTemplate { get; }
+
+ public IReadOnlyList SaveChoices { get => _saveChoices; private set => Set(ref _saveChoices, value); }
+
+ public SaveChoice? SelectedSave
+ {
+ get => SaveChoices.FirstOrDefault(c => !c.Browse && c.Folder == Export.Folder);
+ set
+ {
+ if (_refreshing || value is null) return;
+ if (!value.Browse)
+ {
+ EditExport(e => e with { Folder = value.Folder });
+ return;
+ }
+ var folder = Editor.Shell.Services.Dialogs.PickFolder(Loc.L("Editor.Export.Browse"), Export.Folder ?? Editor.Session.Content.ExportsFolder);
+ if (folder is not null) EditExport(e => e with { Folder = folder });
+ else OnPropertyChanged(nameof(SelectedSave));
+ }
+ }
+
+ public string SaveToolTip => Loc.L("Tooltips.Editor.Export.Folder", Export.Folder ?? Editor.Session.Content.ExportsFolder ?? string.Empty);
+
+ public string? EstimatedSize => Editor.Plan is { Setup.Encoder.IsReady: true } plan ? Formatting.Bytes(plan.Estimate.Bytes) : null;
+
+ public string? EstimatedTime => Editor.Plan is { Setup.Encoder.IsReady: true } plan
+ ? Loc.L("Editor.Export.About", Formatting.Duration(plan.Estimate.Time)) + (plan.Setup.Encoder.Capability is { } c ? " · " + c.Name : string.Empty)
+ : null;
+
+ public string? ResultName => Editor.Plan?.FileName;
+
+ /// What the encoder changed or cannot do (localised notices and render remarks).
+ public IReadOnlyList Notices { get => _notices; private set => Set(ref _notices, value); }
+
+ /// "Previous renders of this sequence: 2 · last 2026-09-21".
+ public string HistoryText => Editor.Session.Content.Renders is { Count: > 0 } renders
+ ? Loc.Plural("Editor.Export.History", renders.Count, Formatting.Date(renders[0].Created))
+ : Loc.L("Editor.Export.NoHistory");
+
+ public IReadOnlyList Batch => Export.Batch;
+
+ private ExportSettings Export => Editor.Session.Project.Export;
+
+ private ResolvedExport Resolved => Editor.Plan?.Export ?? ExportResolver.Resolve(Export);
+
+ public bool IsInBatch(string presetId) => Export.Batch.Contains(presetId, StringComparer.OrdinalIgnoreCase);
+
+ public void SetInBatch(string presetId, bool value)
+ {
+ if (value == IsInBatch(presetId)) return;
+ EditExport(e => e with { Batch = value ? [.. e.Batch, presetId] : [.. e.Batch.Where(b => !b.Equals(presetId, StringComparison.OrdinalIgnoreCase))] });
+ }
+
+ public override void Refresh()
+ {
+ base.Refresh();
+ _refreshing = true;
+ try
+ {
+ UpdateLists();
+ SaveChoices = Export.Folder is { } folder
+ ? [new SaveChoice(null), new SaveChoice(folder), new SaveChoice(null, Browse: true)]
+ : [new SaveChoice(null), new SaveChoice(null, Browse: true)];
+ if (!NameTemplate.IsDirty) NameTemplate.Load(Export.NameTemplate);
+ OnAllPropertiesChanged();
+ }
+ finally
+ {
+ _refreshing = false;
+ }
+ foreach (var card in Cards)
+ {
+ card.IsSelected = card.Choice.Sequence is null && string.Equals(card.Choice.ExportPresetId, Resolved.PresetId, StringComparison.OrdinalIgnoreCase);
+ card.RefreshBatch();
+ }
+ _ = EstimateCardsAsync();
+ }
+
+ public override void OnPlanChanged()
+ {
+ _refreshing = true;
+ try
+ {
+ var settings = Editor.Plan?.Setup.Encoder.Settings;
+ if (!Width.IsDirty) Width.Load(settings?.Width.ToString(CultureInfo.InvariantCulture) ?? string.Empty);
+ if (!Height.IsDirty) Height.Load(settings?.Height.ToString(CultureInfo.InvariantCulture) ?? string.Empty);
+ UpdateLists();
+ Notices = Editor.Plan is { } plan
+ ? [.. plan.Setup.Warnings.Select(w => Loc.L(w.Key, [.. w.Args])).Concat(plan.Export.Warnings.Select(k => Loc.L(k))).Distinct()]
+ : [];
+ OnAllPropertiesChanged();
+ }
+ finally
+ {
+ _refreshing = false;
+ }
+ }
+
+ public override void OnContentChanged()
+ {
+ LoadCards();
+ base.OnContentChanged();
+ }
+
+ public override void Dispose()
+ {
+ _estimates.Dispose();
+ base.Dispose();
+ }
+
+ /// The choices that depend on the resolved codec (new lists only when they change, so selections stay bound).
+ private void UpdateLists()
+ {
+ var resolved = Resolved;
+ if (CodecChoices.FirstOrDefault()?.Container != resolved.Container) CodecChoices = [.. Codecs.Where(c => c.Container == resolved.Container)];
+ var encoders = EncoderChoices(resolved.Codec);
+ if (!encoders.Select(e => e.Value).SequenceEqual(Encoders.Select(e => e.Value))) Encoders = encoders;
+ int[] depths = resolved.Codec switch
+ {
+ VideoCodec.Hevc or VideoCodec.Av1 => [8, 10],
+ VideoCodec.PngSequence or VideoCodec.Tiff16Sequence => [8, 16],
+ _ => [resolved.BitDepth],
+ };
+ if (!depths.SequenceEqual(Depths.Select(d => (int)d.Value))) Depths = [.. depths.Select(d => new Choice(d, "Editor.Export.Depth", d))];
+ }
+
+ private void LoadCards() => Cards = [.. ExportPlanner.Choices(Editor.Session.Presets, Editor.Session.Advice).Select(c => new PresetCard(this, c))];
+
+ /// Estimates every card off the UI thread for the project as it is now (latest request wins).
+ private async Task EstimateCardsAsync()
+ {
+ var project = Editor.Session.Project;
+ var cards = Cards;
+ var plans = new ExportPlan?[cards.Count];
+ try
+ {
+ await _estimates.Schedule(token =>
+ {
+ for (var i = 0; i < cards.Count; i++)
+ {
+ token.ThrowIfCancellationRequested();
+ var export = project.Export with { Preset = project.Export.Preset.WithManual(cards[i].Choice.ExportPresetId), Overrides = new ExportOverrides(), Batch = [] };
+ plans[i] = Editor.Planner.Plan(project, export);
+ }
+ return Task.CompletedTask;
+ });
+ }
+ catch (Exception ex) when (ex is ArgumentException or InvalidOperationException)
+ {
+ Core.Diagnostics.Log.Warning("editor", "Preset estimates failed", ex);
+ return;
+ }
+ if (!ReferenceEquals(cards, Cards) || !ReferenceEquals(project, Editor.Session.Project)) return;
+ for (var i = 0; i < cards.Count; i++) cards[i].Update(plans[i]);
+ }
+
+ private void Select(PresetCard? card)
+ {
+ if (card is null) return;
+ if (card.Choice.Sequence is { } preset) Editor.Session.ApplyPreset(preset);
+ else EditExport(e => e with { Preset = e.Preset.WithManual(card.Choice.ExportPresetId), Overrides = new ExportOverrides() });
+ }
+
+ private void SelectCodec(CodecChoice choice) => EditOverrides(o => o with
+ {
+ Codec = ProcessingJobs.CodecName(choice.Codec),
+ Profile = choice.Profile == CodecProfile.Auto ? null : choice.Profile.ToString(),
+ BitDepth = choice.BitDepth,
+ BitRate = null,
+ Encoder = null,
+ });
+
+ private IReadOnlyList EncoderChoices(VideoCodec codec)
+ {
+ var names = Editor.Planner.Encoders.SelectMany(p => p.Capabilities).Where(c => c.Codec == codec).Select(c => c.Name).Distinct();
+ return [new Choice(string.Empty, "Editor.Export.EncoderAuto"), .. names.Select(n => new Choice(n, "Editor.Value.Text", n))];
+ }
+
+ private void EditExport(Func change, string? mergeKey = null) =>
+ Editor.Session.Edit(p => p with { Export = change(p.Export) }, mergeKey);
+
+ private void EditOverrides(Func change, string? mergeKey = null) =>
+ EditExport(e => e with { Overrides = change(e.Overrides) }, mergeKey);
+
+ private static string? ValidateSize(string text) =>
+ text.Length == 0 || (int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var v) && v is >= 16 and <= 16384)
+ ? null
+ : Loc.L("Tooltips.Editor.Export.SizeInvalid");
+
+ private static int? ParseSize(string text) => int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var v) ? v : null;
+
+ private static string? ValidateTemplate(string text) => ExportPlanner.NameError(ExportNaming.Expand(text, new ExportNameContext
+ {
+ Date = DateTime.Today,
+ PresetName = "x",
+ Codec = VideoCodec.H264,
+ }).Errors);
+
+ private static string Aspect(int width, int height)
+ {
+ if (width <= 0 || height <= 0) return string.Empty;
+ var gcd = (int)Gcd(width, height);
+ var (w, h) = (width / gcd, height / gcd);
+ return w > 64 || h > 64 ? (width / (double)height).ToString("0.00", Loc.Culture) + ":1" : $"{w}:{h}";
+ }
+
+ private static long Gcd(long a, long b)
+ {
+ while (b != 0) (a, b) = (b, a % b);
+ return a;
+ }
+}
diff --git a/src/Titano.App/Editor/ExposureTab.cs b/src/Titano.App/Editor/ExposureTab.cs
new file mode 100644
index 00000000..54fce348
--- /dev/null
+++ b/src/Titano.App/Editor/ExposureTab.cs
@@ -0,0 +1,112 @@
+using Titano.Core.Advice;
+using Titano.Core.Localization;
+using Titano.Core.Project;
+using Titano.Ui.Visuals;
+
+namespace Titano.App.Editor;
+
+///
+/// Exposure (BRIEF §12.3): deflicker, regions, holy-grail transitions and white balance; the chart shows the measured
+/// luminance (Sun) against the target curve the corrections produce (Accent), the sky region (dashed) and the exposure
+/// steps as received.
+///
+public sealed class ExposureTab : EditorTab
+{
+ private IReadOnlyList _series = [];
+ private IReadOnlyList _legend = [];
+ private IReadOnlyList _markers = [];
+ private string? _summary;
+
+ public ExposureTab(EditorViewModel editor)
+ : base(editor, "Exposure", AdvisorSection.Exposure)
+ {
+ var s = editor.Session;
+ string? NoDeflicker(ProjectSettings p) => EditorSettings.Deflicker.Effective(p, s.Content.Deep) ? null : Loc.L("Tooltips.Editor.NotApplicable.DeflickerOff");
+ string? NoHolyGrail(ProjectSettings p) => EditorSettings.HolyGrail.Effective(p, s.Content.Deep) ? null : Loc.L("Tooltips.Editor.NotApplicable.HolyGrailOff");
+ Rows =
+ [
+ new AutoSwitchRow(s, EditorSettings.Deflicker, "Editor.Exposure.Deflicker", "Tooltips.Editor.Exposure.Deflicker"),
+ new AutoNumberRow(s, EditorSettings.DeflickerWindow, "Editor.Exposure.Window", "Tooltips.Editor.Exposure.Window", 5, 151, 2, "0", NoDeflicker),
+ new AutoNumberRow(s, EditorSettings.DeflickerStrength, "Editor.Exposure.Strength", "Tooltips.Editor.Exposure.Strength", 0, 1, 0.05, "0.00", NoDeflicker),
+ new AutoChoiceRow(s, EditorSettings.Regions, "Editor.Exposure.Regions", "Tooltips.Editor.Exposure.Regions",
+ [
+ new Choice(RegionMode.Off, "Editor.Value.Off"), new Choice(RegionMode.Auto, "Editor.Regions.Auto"),
+ new Choice(RegionMode.Horizon, "Editor.Regions.Horizon"), new Choice(RegionMode.Luminance, "Editor.Regions.Luminance"),
+ ], NoDeflicker),
+ new AutoSwitchRow(s, EditorSettings.HolyGrail, "Editor.Exposure.HolyGrail", "Tooltips.Editor.Exposure.HolyGrail"),
+ new AutoNumberRow(s, EditorSettings.TransitionLength, "Editor.Exposure.Transitions", "Tooltips.Editor.Exposure.Transitions", 0, 120, 1, "0", NoHolyGrail),
+ new AutoSwitchRow(s, EditorSettings.WhiteBalance, "Editor.Exposure.WhiteBalance", "Tooltips.Editor.Exposure.WhiteBalance"),
+ new InfoRow("Editor.Exposure.Temperature", "Tooltips.Editor.Exposure.Temperature", Temperature),
+ new NumberRow(s, "Editor.Exposure.Offset", "Tooltips.Editor.Exposure.Offset", -3, 3, 0.1, p => p.Exposure.ExposureOffsetEv,
+ (p, v) => p with { Exposure = p.Exposure with { ExposureOffsetEv = v } }, v => Loc.L("Editor.Value.Ev", v.ToString("+0.0;−0.0;0.0", Loc.Culture))),
+ ];
+ Refresh();
+ BuildChart();
+ }
+
+ public IReadOnlyList Series { get => _series; private set => Set(ref _series, value); }
+
+ public IReadOnlyList Legend { get => _legend; private set => Set(ref _legend, value); }
+
+ public IReadOnlyList Markers { get => _markers; private set => Set(ref _markers, value); }
+
+ /// "flicker −67 % · max step 0.21 EV".
+ public string? Summary { get => _summary; private set => Set(ref _summary, value); }
+
+ public Func YFormatter { get; } = v => v.ToString("0.0", Loc.Culture);
+
+ public override void OnContentChanged()
+ {
+ base.OnContentChanged();
+ BuildChart();
+ }
+
+ public override void OnCorrectionsChanged() => BuildChart();
+
+ private (string?, string?) Temperature()
+ {
+ if (Editor.Session.Content.Deep is not { } deep) return (null, Loc.L("Tooltips.Editor.NotApplicable.NeedsAnalysis"));
+ if (deep.WhiteBalance is { KelvinLow: { } low, KelvinHigh: { } high })
+ return (Loc.L("Editor.Value.Kelvin", double.Round(low, -1).ToString("N0", Loc.Culture), double.Round(high, -1).ToString("N0", Loc.Culture)), null);
+ return (null, Loc.L("Tooltips.Editor.NotApplicable.Kelvin"));
+ }
+
+ private void BuildChart()
+ {
+ var content = Editor.Session.Content;
+ var n = content.Count;
+ var corrections = Editor.Corrections is { } c && c.FrameCount == n ? c : null;
+ double[] measured = corrections?.MeasuredLogLuminance is { } m && m.Any(double.IsFinite)
+ ? m
+ : content.Deep is { } deep ? [.. deep.Frames.LogLuminance.Select(v => v ?? double.NaN)] : [.. content.Frames.Select(f => f.MeanLogLuminance ?? double.NaN)];
+ var series = new List { new(Loc.L("Editor.Chart.Measured"), measured, "Brush.Sun") };
+ var legend = new List { new(Loc.L("Editor.Chart.Measured"), "Brush.Sun") };
+ if (corrections is not null && measured.Any(double.IsFinite))
+ {
+ series.Add(new ChartSeries(Loc.L("Editor.Chart.Target"), corrections.TargetLogLuminance(), "Brush.Accent") { Thickness = 2 });
+ legend.Add(new ChartLegendItem(Loc.L("Editor.Chart.Target"), "Brush.Accent"));
+ }
+ if (content.Deep is { Regions: not null } withSky && withSky.Frames.SkyLogLuminance.Any(v => v is not null))
+ {
+ series.Add(new ChartSeries(Loc.L("Editor.Chart.Sky"), withSky.Frames.SkyLogLuminance.Select(v => v ?? double.NaN).ToArray(), "Brush.Region")
+ { Dash = LineDash.Dashed });
+ legend.Add(new ChartLegendItem(Loc.L("Editor.Chart.Sky"), "Brush.Region", LegendSwatch.DashedLine));
+ }
+ var markers = EditorViewModel.StepMarkers(content);
+ if (markers.Count > 0) legend.Add(new ChartLegendItem(Loc.L("Editor.Chart.Steps"), "Brush.Sun", LegendSwatch.Triangle));
+ Series = series;
+ Legend = legend;
+ Markers = markers;
+ Summary = SummaryOf(corrections);
+ }
+
+ private static string? SummaryOf(Core.Render.RenderCorrections? corrections)
+ {
+ if (corrections is null) return null;
+ var parts = new List();
+ if (corrections.Report.Deflicker is { FlickerBefore: > 0 } d)
+ parts.Add(Loc.L("Editor.Exposure.FlickerChange", double.Round((d.FlickerAfter / d.FlickerBefore - 1) * 100).ToString("+0;−0;0", Loc.Culture)));
+ if (corrections.Report.MaxTargetStepEv is { } step) parts.Add(Loc.L("Editor.Exposure.MaxStep", step.ToString("0.00", Loc.Culture)));
+ return parts.Count == 0 ? null : string.Join(" · ", parts);
+ }
+}
diff --git a/src/Titano.App/Editor/FramesTab.cs b/src/Titano.App/Editor/FramesTab.cs
new file mode 100644
index 00000000..6bc8bb6d
--- /dev/null
+++ b/src/Titano.App/Editor/FramesTab.cs
@@ -0,0 +1,199 @@
+using System.Windows.Input;
+using Titano.Core.Advice;
+using Titano.Core.Analysis;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Ui.Controls;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Editor;
+
+/// One frame of the Frames table; texts are formatted when shown (the table is virtualised).
+public sealed class FrameRow(FramesTab owner, Frame frame, int index) : ObservableObject
+{
+ /// Archive flags named in the table (the others are internal or shown elsewhere).
+ private static readonly FrameFlags[] ShownFlags =
+ [FrameFlags.Missing, FrameFlags.Corrupt, FrameFlags.Duplicate, FrameFlags.Undecodable, FrameFlags.Black, FrameFlags.White];
+
+ public int Index { get; } = index;
+
+ public string Number => (Index + 1).ToString("D4", Loc.Culture);
+
+ public string Time => frame.CapturedAt?.ToString("T", Loc.Culture) ?? string.Empty;
+
+ public string Exposure => frame.ExposureTime is > 0 and var t ? EditorText.Shutter(t) : string.Empty;
+
+ public string Iso => frame.Iso?.ToString(Loc.Culture) ?? string.Empty;
+
+ public string Aperture => frame.FNumber is > 0 and var f ? Loc.L("Editor.Shot.Aperture", f.ToString("0.#", Loc.Culture)) : string.Empty;
+
+ public string Size => frame.Width > 0 ? EditorText.Size(frame.Width, frame.Height) : string.Empty;
+
+ /// Decode tier: the format, and "preview" when only the embedded preview decodes.
+ public string Tier => (frame.Flags & FrameFlags.PreviewOnly) != 0 ? Loc.L("Editor.Frames.PreviewOnly", frame.Format) : frame.Format.ToString();
+
+ /// "Excluded · black", the project's exclusion first, then the archive's flags.
+ public string Flags
+ {
+ get
+ {
+ var parts = new List();
+ if (IsExcluded) parts.Add(Loc.L("Editor.Frames.Excluded"));
+ if (IsHero) parts.Add(Loc.L("Editor.Frames.Hero"));
+ foreach (var flag in ShownFlags)
+ {
+ if ((frame.Flags & flag) != 0) parts.Add(Loc.L("Editor.Frames.Flag." + flag));
+ }
+ return string.Join(" · ", parts);
+ }
+ }
+
+ public bool IsExcluded => owner.IsExcluded(Index);
+
+ public bool IsHero => owner.HeroIndex == Index;
+
+ public string ExcludeText => Loc.L(IsExcluded ? "Editor.Frames.Include" : "Editor.Frames.Exclude");
+
+ public string ExcludeToolTip => Loc.L(IsExcluded ? "Tooltips.Editor.Frames.Include" : "Tooltips.Editor.Frames.Exclude");
+
+ /// The project's exclusions or hero changed.
+ public void Refresh()
+ {
+ OnPropertyChanged(nameof(IsExcluded));
+ OnPropertyChanged(nameof(IsHero));
+ OnPropertyChanged(nameof(Flags));
+ OnPropertyChanged(nameof(ExcludeText));
+ OnPropertyChanged(nameof(ExcludeToolTip));
+ }
+
+}
+
+/// A finding of the analyses with the frame to jump to.
+public sealed record FindingItem(StatusKind Kind, string Text, int? Frame);
+
+///
+/// Frames (BRIEF §12.3): the virtualised frame table (index, time, exposure, ISO, aperture, size, tier, flags) with
+/// exclude/include and hero, and the warnings of the analyses; Optimise adds the advised exclusions and hero.
+///
+public sealed class FramesTab : EditorTab
+{
+ private HashSet _excluded = [];
+ private int? _hero;
+ private IReadOnlyList _frames = [];
+ private IReadOnlyList _findings = [];
+ private FrameRow? _selected;
+
+ public FramesTab(EditorViewModel editor)
+ : base(editor, "Frames", AdvisorSection.Frames)
+ {
+ ToggleExcludeCommand = new RelayCommand(p => ToggleExcluded(p is FrameRow row ? row.Index : Editor.CurrentIndex), _ => !Editor.IsBusy);
+ SetHeroCommand = new RelayCommand(p => Editor.Session.SetHero(p is FrameRow row ? row.Index : Editor.CurrentIndex), _ => !Editor.IsBusy);
+ SeekCommand = new RelayCommand(p =>
+ {
+ if (p is FindingItem { Frame: { } frame }) Editor.CurrentIndex = frame;
+ });
+ Load();
+ }
+
+ public IReadOnlyList Frames { get => _frames; private set => Set(ref _frames, value); }
+
+ public IReadOnlyList Findings { get => _findings; private set => Set(ref _findings, value); }
+
+ /// The row of the current frame (selecting a row seeks the preview).
+ public FrameRow? Selected
+ {
+ get => _selected;
+ set
+ {
+ if (!Set(ref _selected, value) || value is null) return;
+ Editor.CurrentIndex = value.Index;
+ }
+ }
+
+ public int? HeroIndex => _hero;
+
+ /// "Frame 0413", or "Not set".
+ public string HeroText => _hero is { } h ? Loc.L("Editor.Frames.HeroValue", (h + 1).ToString("D4", Loc.Culture)) : Loc.L("Editor.Frames.HeroNone");
+
+ /// "12 frames", "None".
+ public string ExcludedText => _excluded.Count > 0 ? Loc.Plural("Editor.Value.Frames", _excluded.Count) : Loc.L("Editor.Frames.ExcludedNone");
+
+ public bool IsCurrentExcluded => IsExcluded(Editor.CurrentIndex);
+
+ public string CurrentExcludeText => Loc.L(IsCurrentExcluded ? "Editor.Frames.IncludeFrame" : "Editor.Frames.ExcludeFrame");
+
+ public string CurrentExcludeToolTip => Loc.L(IsCurrentExcluded ? "Tooltips.Editor.Frames.Include" : "Tooltips.Editor.Frames.Exclude");
+
+ public override bool CanReset => false;
+
+ public ICommand ToggleExcludeCommand { get; }
+
+ public ICommand SetHeroCommand { get; }
+
+ public ICommand SeekCommand { get; }
+
+ public bool IsExcluded(int index) => _excluded.Contains(index);
+
+ public override void Refresh()
+ {
+ base.Refresh();
+ var project = Editor.Session.Project;
+ var excluded = project.ExcludedFrames.ToHashSet();
+ if (excluded.SetEquals(_excluded) && project.HeroFrame == _hero) return;
+ var changed = new HashSet(excluded);
+ changed.SymmetricExceptWith(_excluded);
+ if (_hero is { } oldHero) changed.Add(oldHero);
+ if (project.HeroFrame is { } newHero) changed.Add(newHero);
+ _excluded = excluded;
+ _hero = project.HeroFrame;
+ foreach (var index in changed)
+ {
+ if ((uint)index < (uint)Frames.Count) Frames[index].Refresh();
+ }
+ OnPropertyChanged(nameof(HeroText));
+ OnPropertyChanged(nameof(ExcludedText));
+ OnCurrentFrameChanged();
+ }
+
+ public override void OnContentChanged()
+ {
+ Load();
+ base.OnContentChanged();
+ }
+
+ public void OnCurrentFrameChanged()
+ {
+ var index = Editor.CurrentIndex;
+ if ((uint)index < (uint)Frames.Count && !ReferenceEquals(_selected, Frames[index]))
+ {
+ _selected = Frames[index];
+ OnPropertyChanged(nameof(Selected));
+ }
+ OnPropertyChanged(nameof(IsCurrentExcluded));
+ OnPropertyChanged(nameof(CurrentExcludeText));
+ OnPropertyChanged(nameof(CurrentExcludeToolTip));
+ }
+
+ private void Load()
+ {
+ var content = Editor.Session.Content;
+ _excluded = Editor.Session.Project.ExcludedFrames.ToHashSet();
+ _hero = Editor.Session.Project.HeroFrame;
+ Frames = [.. content.Frames.Select((f, i) => new FrameRow(this, f, i))];
+ Findings = [.. Editor.Session.Advice.Findings.OrderByDescending(f => f.Severity).Select(ToItem)];
+ _selected = null;
+ OnCurrentFrameChanged();
+ }
+
+ private static FindingItem ToItem(Finding finding) => new(
+ finding.Severity switch
+ {
+ FindingSeverity.Error => StatusKind.Error,
+ FindingSeverity.Warning => StatusKind.Warning,
+ _ => StatusKind.NotAnalysed,
+ },
+ Loc.L(finding.Key, finding.Arguments),
+ finding.Frames.Count > 0 ? finding.Frames[0] : null);
+
+ private void ToggleExcluded(int index) => Editor.Session.SetExcluded([index], !IsExcluded(index));
+}
diff --git a/src/Titano.App/Editor/LocalSequenceSource.cs b/src/Titano.App/Editor/LocalSequenceSource.cs
index ddbedea3..d9065b5e 100644
--- a/src/Titano.App/Editor/LocalSequenceSource.cs
+++ b/src/Titano.App/Editor/LocalSequenceSource.cs
@@ -70,7 +70,9 @@ public sealed class LocalSequenceSource(TitanoDatabase db, Guid sequenceId, Imag
{
try
{
- return decoder.Decode(new DecodeRequest(file, maxLongEdge, purpose), cancellationToken)?.Pixels;
+ // Thumbnails take an embedded preview when it is large enough (no RAW development for a filmstrip cell).
+ var request = new DecodeRequest(file, maxLongEdge, purpose, ForcePreview: purpose == DecodePurpose.Thumbnail);
+ return decoder.Decode(request, cancellationToken)?.Pixels;
}
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
{
diff --git a/src/Titano.App/Editor/MotionTab.cs b/src/Titano.App/Editor/MotionTab.cs
new file mode 100644
index 00000000..57f697e2
--- /dev/null
+++ b/src/Titano.App/Editor/MotionTab.cs
@@ -0,0 +1,159 @@
+using Titano.Core.Advice;
+using Titano.Core.Localization;
+using Titano.Core.Project;
+using Titano.Ui.Visuals;
+
+namespace Titano.App.Editor;
+
+/// Motion (BRIEF §12.3): motion blur, flow quality and stabilisation, with the measured camera path (shake) chart.
+public sealed class MotionTab : EditorTab
+{
+ private IReadOnlyList _series = [];
+ private IReadOnlyList _legend = [];
+ private string? _summary;
+
+ public MotionTab(EditorViewModel editor)
+ : base(editor, "Motion", AdvisorSection.Motion)
+ {
+ var s = editor.Session;
+ string? NoBlur(ProjectSettings p) => EditorSettings.MotionBlur.Effective(p, null) ? null : Loc.L("Tooltips.Editor.NotApplicable.BlurOff");
+ string? NoFlow(ProjectSettings p) =>
+ EditorSettings.MotionBlur.Effective(p, null) || EditorSettings.TimingMode.Effective(p, null) == TimingMode.Interpolated
+ ? null
+ : Loc.L("Tooltips.Editor.NotApplicable.NoFlow");
+ string? NoStabilize(ProjectSettings p) => EditorSettings.Stabilize.Effective(p, null) ? null : Loc.L("Tooltips.Editor.NotApplicable.StabilizeOff");
+ Rows =
+ [
+ new AutoSwitchRow(s, EditorSettings.MotionBlur, "Editor.Motion.Blur", "Tooltips.Editor.Motion.Blur"),
+ new AutoNumberRow(s, EditorSettings.ShutterAngle, "Editor.Motion.Shutter", "Tooltips.Editor.Motion.Shutter", 0, 360, 15, "0", NoBlur),
+ new AutoChoiceRow(s, EditorSettings.FlowQuality, "Editor.Motion.Flow", "Tooltips.Editor.Motion.Flow",
+ [
+ new Choice(FlowQualitySetting.Draft, "Editor.Flow.Draft"), new Choice(FlowQualitySetting.Balanced, "Editor.Flow.Balanced"),
+ new Choice(FlowQualitySetting.Best, "Editor.Flow.Best"),
+ ], NoFlow),
+ new AutoSwitchRow(s, EditorSettings.Stabilize, "Editor.Motion.Stabilize", "Tooltips.Editor.Motion.Stabilize"),
+ new AutoNumberRow(s, EditorSettings.StabilizeSmoothing, "Editor.Motion.Smoothing", "Tooltips.Editor.Motion.Smoothing", 2, 60, 1, "0", NoStabilize),
+ ];
+ Refresh();
+ BuildChart();
+ }
+
+ public IReadOnlyList Series { get => _series; private set => Set(ref _series, value); }
+
+ public IReadOnlyList Legend { get => _legend; private set => Set(ref _legend, value); }
+
+ /// "shake 0.42 px · crop 1.8 %".
+ public string? Summary { get => _summary; private set => Set(ref _summary, value); }
+
+ public Func YFormatter { get; } = v => Loc.L("Editor.Value.Pixels", v.ToString("0.#", Loc.Culture));
+
+ public override void OnContentChanged()
+ {
+ base.OnContentChanged();
+ BuildChart();
+ }
+
+ /// The camera path: per-frame content shifts accumulated from the first frame (gaps hold the last position).
+ private void BuildChart()
+ {
+ if (Editor.Session.Content.Deep is not { } deep)
+ {
+ Series = [];
+ Legend = [];
+ Summary = Loc.L("Editor.Chart.NotAnalysed");
+ return;
+ }
+ var x = Accumulate(deep.Frames.ShiftX);
+ var y = Accumulate(deep.Frames.ShiftY);
+ Series =
+ [
+ new ChartSeries(Loc.L("Editor.Chart.PathX"), x, "Brush.Accent"),
+ new ChartSeries(Loc.L("Editor.Chart.PathY"), y, "Brush.TextMuted") { Dash = LineDash.Dashed },
+ ];
+ Legend = [new ChartLegendItem(Loc.L("Editor.Chart.PathX"), "Brush.Accent"), new ChartLegendItem(Loc.L("Editor.Chart.PathY"), "Brush.TextMuted", LegendSwatch.DashedLine)];
+ var shake = deep.Shake;
+ var parts = new List
+ {
+ Loc.L("Editor.Motion.ShakeValue", shake.RmsPx.ToString("0.00", Loc.Culture)),
+ Loc.L("Editor.Motion.CropValue", (shake.CropCost * 100).ToString("0.0", Loc.Culture)),
+ };
+ if (shake.PanDetected) parts.Add(Loc.L("Editor.Motion.PanValue", shake.PanPxPerFrame.ToString("0.0", Loc.Culture)));
+ Summary = string.Join(" · ", parts);
+ }
+
+ private static double[] Accumulate(double?[] shifts)
+ {
+ var path = new double[shifts.Length];
+ double position = 0;
+ for (var i = 0; i < shifts.Length; i++)
+ {
+ position += shifts[i] ?? 0;
+ path[i] = position;
+ }
+ return path;
+ }
+}
+
+/// Stack (BRIEF §12.3): median, mean or star-trail stacking; the chart shows the star field and cloud measurements.
+public sealed class StackTab : EditorTab
+{
+ private IReadOnlyList _series = [];
+ private IReadOnlyList _legend = [];
+ private string? _summary;
+
+ public StackTab(EditorViewModel editor)
+ : base(editor, "Stack", AdvisorSection.Stack)
+ {
+ var s = editor.Session;
+ Rows =
+ [
+ new ChoiceRow(s, "Editor.Stack.Mode", "Tooltips.Editor.Stack.Mode",
+ [
+ new Choice(StackSetting.None, "Editor.Value.Off"), new Choice(StackSetting.Median, "Editor.Stack.Median"),
+ new Choice(StackSetting.Mean, "Editor.Stack.Mean"), new Choice(StackSetting.StarTrails, "Editor.Stack.StarTrails"),
+ ],
+ p => p.Stack.Mode, (p, v) => p with { Stack = p.Stack with { Mode = (StackSetting)v } }),
+ new NumberRow(s, "Editor.Stack.Length", "Tooltips.Editor.Stack.Length", 3, 199, 2, p => p.Stack.Length,
+ (p, v) => p with { Stack = p.Stack with { Length = (int)v } }, v => Loc.Plural("Editor.Value.Frames", (long)v),
+ p => p.Stack.Mode == StackSetting.None ? Loc.L("Tooltips.Editor.NotApplicable.StackOff") : null),
+ ];
+ Refresh();
+ BuildChart();
+ }
+
+ /// The advisor never stacks on its own (a temporal median erases moving stars).
+ public override bool CanOptimise => false;
+
+ public IReadOnlyList Series { get => _series; private set => Set(ref _series, value); }
+
+ public IReadOnlyList Legend { get => _legend; private set => Set(ref _legend, value); }
+
+ public string? Summary { get => _summary; private set => Set(ref _summary, value); }
+
+ public Func YFormatter { get; } = v => v.ToString("0.#", Loc.Culture);
+
+ public override void OnContentChanged()
+ {
+ base.OnContentChanged();
+ BuildChart();
+ }
+
+ private void BuildChart()
+ {
+ if (Editor.Session.Content.Deep is not { } deep)
+ {
+ Series = [];
+ Legend = [];
+ Summary = Loc.L("Editor.Chart.NotAnalysed");
+ return;
+ }
+ Series =
+ [
+ new ChartSeries(Loc.L("Editor.Chart.Stars"), deep.Frames.StarDensity.Select(v => v ?? double.NaN).ToArray(), "Brush.Accent"),
+ new ChartSeries(Loc.L("Editor.Chart.Clouds"), deep.Frames.CloudCoverage.Select(v => v is { } c ? c * 100 : double.NaN).ToArray(), "Brush.TextMuted")
+ { Dash = LineDash.Dashed },
+ ];
+ Legend = [new ChartLegendItem(Loc.L("Editor.Chart.Stars"), "Brush.Accent"), new ChartLegendItem(Loc.L("Editor.Chart.Clouds"), "Brush.TextMuted", LegendSwatch.DashedLine)];
+ Summary = Loc.L(deep.Sky.StarField ? "Editor.Stack.StarField" : "Editor.Stack.NoStarField");
+ }
+}
diff --git a/src/Titano.App/Editor/SettingRows.cs b/src/Titano.App/Editor/SettingRows.cs
new file mode 100644
index 00000000..fb3d1a2e
--- /dev/null
+++ b/src/Titano.App/Editor/SettingRows.cs
@@ -0,0 +1,393 @@
+using System.Numerics;
+using System.Windows.Input;
+using Titano.Core.Advice;
+using Titano.Core.Localization;
+using Titano.Core.Project;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Editor;
+
+/// One row of a section's settings column; re-reads the project after any change.
+public abstract class SettingRow(string headerKey, string toolTipKey) : LocalizedViewModel
+{
+ private bool _refreshing;
+
+ public string Header => Loc.L(headerKey);
+
+ /// What the control does and what moving it the wrong way costs (BRIEF §12.3).
+ public string ToolTip => Loc.L(toolTipKey);
+
+ public void Refresh()
+ {
+ _refreshing = true;
+ try
+ {
+ Read();
+ }
+ finally
+ {
+ _refreshing = false;
+ }
+ }
+
+ /// True while pushes values into the bindings (they must not edit the project back).
+ protected bool IsRefreshing => _refreshing;
+
+ protected abstract void Read();
+
+ /// The tooltip of an Auto pill: the stored reason, else the advisor's current one, else why there is none.
+ protected static string Reason(EditorSession session, AutoSetting setting)
+ where T : notnull
+ {
+ var auto = setting.Get(session.Project);
+ if (auto.ReasonKey is { } key) return Advisor.Explain(key, auto.ReasonArgs);
+ return session.Advice.Find(setting.Id) is { } recommendation ? Advisor.Explain(recommendation) : Loc.L("Tooltips.Editor.Auto.Default");
+ }
+}
+
+///
+/// An Auto/manual slider (). Non-generic so the view can template it; the setting's
+/// value type lives in .
+///
+public abstract class AutoNumberRow(string headerKey, string toolTipKey, double minimum, double maximum, double step, string format)
+ : SettingRow(headerKey, toolTipKey)
+{
+ private double _value;
+ private bool _isAuto = true;
+ private double _autoValue;
+ private string? _autoReason;
+ private string? _notApplicableReason;
+
+ public double Minimum { get; } = minimum;
+ public double Maximum { get; } = maximum;
+ public double Step { get; } = step;
+ public string Format { get; } = format;
+
+ /// The slider value; the user moving it stores a manual value (one undo step per drag).
+ public double Value
+ {
+ get => _value;
+ set
+ {
+ if (!Set(ref _value, value) || IsRefreshing || _isAuto) return;
+ StoreManual(value);
+ }
+ }
+
+ /// Touching the slider clears it (manual at the current value); the reset button sets it.
+ public bool IsAuto
+ {
+ get => _isAuto;
+ set
+ {
+ if (!Set(ref _isAuto, value) || IsRefreshing) return;
+ StoreAuto(value);
+ }
+ }
+
+ public double AutoValue { get => _autoValue; protected set => Set(ref _autoValue, value); }
+
+ public string? AutoReason { get => _autoReason; protected set => Set(ref _autoReason, value); }
+
+ public bool IsApplicable => _notApplicableReason is null;
+
+ public string? NotApplicableReason
+ {
+ get => _notApplicableReason;
+ protected set
+ {
+ if (Set(ref _notApplicableReason, value)) OnPropertyChanged(nameof(IsApplicable));
+ }
+ }
+
+ protected abstract void StoreManual(double value);
+
+ /// True: back to the advice; false: the value in force becomes manual.
+ protected abstract void StoreAuto(bool auto);
+}
+
+/// over an of .
+public sealed class AutoNumberRow : AutoNumberRow
+ where T : struct, INumber
+{
+ private readonly EditorSession _session;
+ private readonly AutoSetting _setting;
+ private readonly Func? _notApplicable;
+
+ /// Why the setting does nothing with the current project (shown as "n/a"); null when it applies.
+ public AutoNumberRow(EditorSession session, AutoSetting setting, string headerKey, string toolTipKey, double minimum, double maximum, double step,
+ string format, Func? notApplicable = null)
+ : base(headerKey, toolTipKey, minimum, maximum, step, format)
+ {
+ (_session, _setting, _notApplicable) = (session, setting, notApplicable);
+ Refresh();
+ }
+
+ protected override void StoreManual(double value) => _session.Edit(p => _setting.WithManual(p, Convert(value)), _setting.Id);
+
+ protected override void StoreAuto(bool auto) =>
+ _session.Edit(p => auto ? _setting.Reset(p) : _setting.WithManual(p, _setting.Effective(p, _session.Content.Deep)), _setting.Id);
+
+ protected override void Read()
+ {
+ var project = _session.Project;
+ AutoValue = double.CreateChecked(_setting.AutoValue(project, _session.Content.Deep));
+ IsAuto = _setting.IsAuto(project);
+ Value = double.CreateChecked(_setting.Effective(project, _session.Content.Deep));
+ AutoReason = Reason(_session, _setting);
+ NotApplicableReason = _notApplicable?.Invoke(project);
+ }
+
+ private static T Convert(double value) => typeof(T) == typeof(int) ? T.CreateChecked(double.Round(value)) : T.CreateChecked(value);
+}
+
+/// An Auto/manual switch (module on/off): the pill shows the advisor's choice, the switch takes it over.
+public sealed class AutoSwitchRow : SettingRow
+{
+ private readonly EditorSession _session;
+ private readonly AutoSetting _setting;
+ private bool _isOn;
+ private bool _isAuto;
+ private string _autoText = string.Empty;
+ private string? _autoReason;
+
+ public AutoSwitchRow(EditorSession session, AutoSetting setting, string headerKey, string toolTipKey)
+ : base(headerKey, toolTipKey)
+ {
+ (_session, _setting) = (session, setting);
+ ResetCommand = new RelayCommand(() => _session.Edit(_setting.Reset));
+ Refresh();
+ }
+
+ public bool IsOn
+ {
+ get => _isOn;
+ set
+ {
+ if (!Set(ref _isOn, value) || IsRefreshing) return;
+ _session.Edit(p => _setting.WithManual(p, value));
+ }
+ }
+
+ public bool IsAuto { get => _isAuto; private set => Set(ref _isAuto, value); }
+
+ /// "Auto · On".
+ public string AutoText { get => _autoText; private set => Set(ref _autoText, value); }
+
+ public string? AutoReason { get => _autoReason; private set => Set(ref _autoReason, value); }
+
+ public ICommand ResetCommand { get; }
+
+ protected override void Read()
+ {
+ var project = _session.Project;
+ IsOn = _setting.Effective(project, _session.Content.Deep);
+ IsAuto = _setting.IsAuto(project);
+ AutoText = Loc.L("Common.Auto") + " · " + Loc.L(IsOn ? "Editor.Value.On" : "Editor.Value.Off");
+ AutoReason = Reason(_session, _setting);
+ }
+}
+
+/// A labelled value of a choice list.
+public sealed record Choice(object Value, string LabelKey, params object[] Args)
+{
+ public string Label => Loc.L(LabelKey, Args);
+}
+
+/// An Auto/manual drop-down (regions, flow quality, timing mode, aspect, playback rate); non-generic for the view.
+public abstract class AutoChoiceRow(string headerKey, string toolTipKey, IReadOnlyList options) : SettingRow(headerKey, toolTipKey)
+{
+ private Choice? _selected;
+ private bool _isAuto;
+ private string _autoText = string.Empty;
+ private string? _autoReason;
+ private string? _notApplicableReason;
+
+ public IReadOnlyList Options { get; } = options;
+
+ public Choice? Selected
+ {
+ get => _selected;
+ set
+ {
+ if (!Set(ref _selected, value) || IsRefreshing || value is null) return;
+ StoreManual(value.Value);
+ }
+ }
+
+ public bool IsAuto { get => _isAuto; protected set => Set(ref _isAuto, value); }
+
+ /// "Auto · horizon".
+ public string AutoText { get => _autoText; protected set => Set(ref _autoText, value); }
+
+ public string? AutoReason { get => _autoReason; protected set => Set(ref _autoReason, value); }
+
+ public bool IsApplicable => _notApplicableReason is null;
+
+ public string? NotApplicableReason
+ {
+ get => _notApplicableReason;
+ protected set
+ {
+ if (Set(ref _notApplicableReason, value)) OnPropertyChanged(nameof(IsApplicable));
+ }
+ }
+
+ public abstract ICommand ResetCommand { get; }
+
+ protected abstract void StoreManual(object value);
+}
+
+/// over an of .
+public sealed class AutoChoiceRow : AutoChoiceRow
+ where T : notnull
+{
+ private readonly EditorSession _session;
+ private readonly AutoSetting _setting;
+ private readonly Func? _notApplicable;
+
+ public AutoChoiceRow(EditorSession session, AutoSetting setting, string headerKey, string toolTipKey, IReadOnlyList options,
+ Func? notApplicable = null)
+ : base(headerKey, toolTipKey, options)
+ {
+ (_session, _setting, _notApplicable) = (session, setting, notApplicable);
+ ResetCommand = new RelayCommand(() => _session.Edit(_setting.Reset));
+ Refresh();
+ }
+
+ public override ICommand ResetCommand { get; }
+
+ protected override void StoreManual(object value)
+ {
+ if (value is T chosen) _session.Edit(p => _setting.WithManual(p, chosen));
+ }
+
+ protected override void Read()
+ {
+ var project = _session.Project;
+ var value = _setting.Effective(project, _session.Content.Deep);
+ Selected = Options.FirstOrDefault(o => Equals(o.Value, value));
+ IsAuto = _setting.IsAuto(project);
+ var auto = _setting.AutoValue(project, _session.Content.Deep);
+ AutoText = Loc.L("Common.Auto") + " · " + (Options.FirstOrDefault(o => Equals(o.Value, auto))?.Label ?? auto.ToString());
+ AutoReason = Reason(_session, _setting);
+ NotApplicableReason = _notApplicable?.Invoke(project);
+ }
+}
+
+/// A plain slider (no advice): exposure offset, placement, stack length, fit-to duration.
+public sealed class NumberRow : SettingRow
+{
+ private readonly EditorSession _session;
+ private readonly Func _get;
+ private readonly Func _set;
+ private readonly Func _display;
+ private readonly Func? _notApplicable;
+ private readonly string _mergeKey;
+ private double _value;
+ private string _displayValue = string.Empty;
+ private string? _notApplicableReason;
+
+ public NumberRow(EditorSession session, string headerKey, string toolTipKey, double minimum, double maximum, double step,
+ Func get, Func set, Func display,
+ Func? notApplicable = null)
+ : base(headerKey, toolTipKey)
+ {
+ (_session, _get, _set, _display, _notApplicable, _mergeKey) = (session, get, set, display, notApplicable, headerKey);
+ (Minimum, Maximum, Step) = (minimum, maximum, step);
+ Refresh();
+ }
+
+ public double Minimum { get; }
+ public double Maximum { get; }
+ public double Step { get; }
+
+ public double Value
+ {
+ get => _value;
+ set
+ {
+ var snapped = Step > 0 ? double.Round(value / Step) * Step : value;
+ if (!Set(ref _value, snapped)) return;
+ DisplayValue = _display(snapped);
+ if (!IsRefreshing) _session.Edit(p => _set(p, snapped), _mergeKey);
+ }
+ }
+
+ public string DisplayValue { get => _displayValue; private set => Set(ref _displayValue, value); }
+
+ public bool IsApplicable => _notApplicableReason is null;
+
+ public string? NotApplicableReason
+ {
+ get => _notApplicableReason;
+ private set
+ {
+ if (Set(ref _notApplicableReason, value)) OnPropertyChanged(nameof(IsApplicable));
+ }
+ }
+
+ protected override void Read()
+ {
+ Value = _get(_session.Project);
+ DisplayValue = _display(_value);
+ NotApplicableReason = _notApplicable?.Invoke(_session.Project);
+ }
+}
+
+/// A plain drop-down (stacking mode).
+public sealed class ChoiceRow : SettingRow
+{
+ private readonly EditorSession _session;
+ private readonly Func _get;
+ private readonly Func _set;
+ private Choice? _selected;
+
+ public ChoiceRow(EditorSession session, string headerKey, string toolTipKey, IReadOnlyList options, Func get,
+ Func set)
+ : base(headerKey, toolTipKey)
+ {
+ (_session, _get, _set, Options) = (session, get, set, options);
+ Refresh();
+ }
+
+ public IReadOnlyList Options { get; }
+
+ public Choice? Selected
+ {
+ get => _selected;
+ set
+ {
+ if (!Set(ref _selected, value) || IsRefreshing || value is null) return;
+ _session.Edit(p => _set(p, value.Value));
+ }
+ }
+
+ protected override void Read()
+ {
+ var current = _get(_session.Project);
+ Selected = Options.FirstOrDefault(o => Equals(o.Value, current));
+ }
+}
+
+/// A measured value shown read-only, "n/a" with the reason when there is none (colour temperature).
+public sealed class InfoRow(string headerKey, string toolTipKey, Func<(string? Value, string? NotApplicableReason)> read) : SettingRow(headerKey, toolTipKey)
+{
+ private string? _value;
+ private string? _notApplicableReason;
+
+ public string? Value { get => _value; private set => Set(ref _value, value); }
+
+ public bool IsApplicable => _notApplicableReason is null;
+
+ public string? NotApplicableReason
+ {
+ get => _notApplicableReason;
+ private set
+ {
+ if (Set(ref _notApplicableReason, value)) OnPropertyChanged(nameof(IsApplicable));
+ }
+ }
+
+ protected override void Read() => (Value, NotApplicableReason) = read();
+}
diff --git a/src/Titano.App/Sections/SequenceViewModel.cs b/src/Titano.App/Sections/SequenceViewModel.cs
index 7dcd5229..a6624b1a 100644
--- a/src/Titano.App/Sections/SequenceViewModel.cs
+++ b/src/Titano.App/Sections/SequenceViewModel.cs
@@ -1,12 +1,129 @@
+using System.ComponentModel;
+using System.IO;
using System.Windows.Input;
+using Titano.App.Editor;
using Titano.App.Shell;
+using Titano.Core.Diagnostics;
+using Titano.Core.Export;
+using Titano.Core.Imaging.Decoders;
+using Titano.Core.Localization;
+using Titano.Data.Archiving;
using Titano.Ui.Mvvm;
namespace Titano.App.Sections;
-/// Sequence editor (BRIEF §12.3).
-public sealed class SequenceViewModel(ShellViewModel shell) : SectionViewModel(SectionKey.Sequence, "Icon.Sequence")
+///
+/// The Sequence section (BRIEF §12.3): opens the sequence the Library (or Jobs) chose into an
+/// and closes the previous one after saving it; without a sequence it shows the empty state.
+///
+public sealed class SequenceViewModel : SectionViewModel
{
- public ShellViewModel Shell { get; } = shell;
- public ICommand OpenLibraryCommand => new RelayCommand(() => Shell.Navigate(SectionKey.Library));
+ private EditorViewModel? _editor;
+ private Guid? _openId;
+ private bool _isLoading;
+ private Task _switch = Task.CompletedTask;
+
+ public SequenceViewModel(ShellViewModel shell)
+ : base(SectionKey.Sequence, "Icon.Sequence")
+ {
+ Shell = shell;
+ OpenLibraryCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Library));
+ shell.PropertyChanged += OnShellChanged;
+ }
+
+ public ShellViewModel Shell { get; }
+
+ public ICommand OpenLibraryCommand { get; }
+
+ /// The open sequence; null shows the empty state.
+ public EditorViewModel? Editor
+ {
+ get => _editor;
+ private set
+ {
+ if (!Set(ref _editor, value)) return;
+ OnPropertyChanged(nameof(IsEmpty));
+ OnPropertyChanged(nameof(Title));
+ }
+ }
+
+ public bool IsLoading { get => _isLoading; private set => Set(ref _isLoading, value); }
+
+ public bool IsEmpty => _editor is null && !_isLoading;
+
+ /// "Titano — Harbour sunset" while a sequence is open.
+ public override string Title => _editor?.Title ?? Label;
+
+ /// Opens (the editor of another sequence is saved and closed first).
+ public Task OpenAsync(Guid sequenceId)
+ {
+ _switch = SwitchAsync(_switch, sequenceId);
+ return _switch;
+ }
+
+ /// Saves and closes the open sequence.
+ public async Task CloseAsync()
+ {
+ await _switch;
+ if (Editor is not { } editor) return;
+ Editor = null;
+ _openId = null;
+ await editor.DisposeAsync();
+ }
+
+ public override void Dispose()
+ {
+ Shell.PropertyChanged -= OnShellChanged;
+ Editor?.Dispose();
+ base.Dispose();
+ }
+
+ protected override void OnActivated()
+ {
+ if (Shell.CurrentSequenceId is { } id && id != _openId) _ = OpenAsync(id);
+ }
+
+ private void OnShellChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName == nameof(ShellViewModel.CurrentSequenceId) && IsSelected) OnActivated();
+ }
+
+ private async Task SwitchAsync(Task previous, Guid sequenceId)
+ {
+ await previous;
+ if (sequenceId == _openId) return;
+ var services = Shell.Services;
+ IsLoading = true;
+ OnPropertyChanged(nameof(IsEmpty));
+ try
+ {
+ if (Editor is { } old)
+ {
+ Editor = null;
+ await old.DisposeAsync();
+ }
+ _openId = sequenceId;
+ if (services.Database is not { } db) throw new InvalidOperationException(Loc.L("Editor.Error.NoEngine"));
+ var processing = services.Processing?.Options;
+ var source = new LocalSequenceSource(db, sequenceId, processing?.Archive.Decoder ?? DecoderFactory.CreateClient(null), services.Engine,
+ processing?.Archive);
+ var content = await source.LoadAsync(CancellationToken.None);
+ var encoders = processing?.Encoders ?? [];
+ var session = new EditorSession(source, content, [.. encoders.SelectMany(e => e.Capabilities)]);
+ var editor = new EditorViewModel(Shell, session, encoders, processing?.Host ?? EncoderHost.Client);
+ Editor = editor;
+ await editor.AttachJobsAsync();
+ }
+ catch (Exception ex) when (ex is InvalidDataException or InvalidOperationException or IOException or UnauthorizedAccessException)
+ {
+ _openId = null;
+ Log.Warning("editor", $"Sequence {sequenceId} could not be opened", ex);
+ Shell.ReportError(ex);
+ }
+ finally
+ {
+ IsLoading = false;
+ OnPropertyChanged(nameof(IsEmpty));
+ }
+ }
}
diff --git a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs
index 055251d4..af26f11a 100644
--- a/tests/Titano.App.Tests/Editor/EditorSessionTests.cs
+++ b/tests/Titano.App.Tests/Editor/EditorSessionTests.cs
@@ -184,6 +184,28 @@ public sealed class EditorSessionTests
}
}
+ [Test]
+ public async Task ASequencePresetKeepsTheUsersFramesAndNaming()
+ {
+ var (session, _) = Open();
+ await using (session)
+ {
+ session.SetExcluded([1, 2], excluded: true);
+ session.SetHero(9);
+ session.Edit(p => p with { Export = p.Export with { NameTemplate = "{title}", Overrides = new ExportOverrides { Width = 640 } } });
+ var preset = session.Presets.First(p => p.Id == "social-vertical");
+ Assert.True(session.ApplyPreset(preset));
+ Assert.Equal("9:16", session.Project.Camera.Aspect.Manual);
+ Assert.Equal("vertical-1080x1920", session.Project.Export.Preset.Manual);
+ Assert.Null(session.Project.Export.Overrides.Width, "the preset's own values");
+ Assert.SequenceEqual([1, 2], session.Project.ExcludedFrames);
+ Assert.Equal(9, session.Project.HeroFrame);
+ Assert.Equal("{title}", session.Project.Export.NameTemplate);
+ Assert.True(session.Undo());
+ Assert.Equal(640, session.Project.Export.Overrides.Width);
+ }
+ }
+
[Test]
public async Task ReloadBringsNewAnalysisAndKeepsUserValues()
{