Files
Chronos/src/Titano.App/Editor/ExportTab.cs
T
Claude b2b36d5c57 test(app): editor sample for --capture and a Windows smoke test of every section
SampleData.FillEditorAsync writes a synthetic harbour sunset of real JPEG
frames with Exif (flicker, two exposure steps, white-balance drift, a
horizon), scans, deep-analyses and advises it, so --capture writes
sequence-<tab>-<theme>.png for every editor section. EditorViewModel
.WhenIdleAsync lets capture and tests wait for the preview, corrections,
plan, estimates and thumbnails in flight.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 17:35:53 +00:00

470 lines
21 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.Globalization;
using System.IO;
using System.Windows.Input;
using Titano.App.Infrastructure;
using Titano.App.Settings;
using Titano.Core.Advice;
using Titano.Core.Export;
using Titano.Core.Localization;
using Titano.Core.Model;
using Titano.Core.Project;
using Titano.Core.Video;
using Titano.Data.Processing;
using Titano.Ui.Mvvm;
namespace Titano.App.Editor;
/// <summary>A preset card of the Export tab (Export.html): what it renders and what it will cost on this machine.</summary>
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;
/// <summary>Sequence presets apply full settings; export presets only choose the output.</summary>
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);
/// <summary>"MP4 · HEVC Main10 · 3840×2160 · 24 fps".</summary>
public string? Format { get => _format; private set => Set(ref _format, value); }
/// <summary>"120 Mb/s · 0.07 bpp · NVENC".</summary>
public string? Encoding { get => _encoding; private set => Set(ref _encoding, value); }
/// <summary>"2.2 GB · about 5 min".</summary>
public string? Estimate { get => _estimate; private set => Set(ref _estimate, value); }
public bool IsSelected { get => _isSelected; set => Set(ref _isSelected, value); }
/// <summary>Ticked for "Batch…" (export presets only).</summary>
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));
}
/// <summary>A codec choice of the Output panel with the profile and depth it implies.</summary>
public sealed record CodecChoice(VideoCodec Codec, CodecProfile Profile, int BitDepth)
{
public ContainerFormat Container => VideoCodecInfo.DefaultContainer(Codec);
public string Label => EditorText.CodecName(Codec, Profile, BitDepth);
}
/// <summary>Where renders go: the sequence's exports folder or a folder the user picked.</summary>
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('\\', '/'));
}
/// <summary>
/// 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).
/// </summary>
public sealed class ExportTab : EditorTab
{
public static IReadOnlyList<CodecChoice> 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<PresetCard> _cards = [];
private IReadOnlyList<CodecChoice> _codecChoices = [];
private IReadOnlyList<Choice> _encoders = [];
private IReadOnlyList<SaveChoice> _saveChoices = [];
private IReadOnlyList<Choice> _depths = [];
private IReadOnlyList<string> _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<PresetCard> 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; }
/// <summary>"Output · 4K archive".</summary>
public string Title => Loc.L("Editor.Export.Output", Editor.Plan?.PresetName ?? ProcessingJobs.PresetName(ExportResolver.Resolve(Export)));
public IReadOnlyList<Choice> 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<CodecChoice> 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; }
/// <summary>"16:9".</summary>
public string AspectText => Editor.Plan is { } plan ? Aspect(plan.Setup.Encoder.Settings.Width, plan.Setup.Encoder.Settings.Height) : string.Empty;
public IReadOnlyList<Choice> 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 });
}
}
/// <summary>The preset's own frame rate is in force (no override).</summary>
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));
/// <summary>Bit rate in Mb/s (video) or quality 1–100 (JPEG, MJPEG, GIF).</summary>
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<Choice> 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 });
}
}
/// <summary>"hardware", "software" (the word, not a colour, carries the state).</summary>
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<Choice> 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<SaveChoice> 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;
/// <summary>What the encoder changed or cannot do (localised notices and render remarks).</summary>
public IReadOnlyList<string> Notices { get => _notices; private set => Set(ref _notices, value); }
/// <summary>"Previous renders of this sequence: 2 · last 2026-09-21".</summary>
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<string> Batch => Export.Batch;
/// <summary>Completes when the card estimates in flight are done.</summary>
public Task EstimatesIdle => _estimates.Idle;
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();
}
/// <summary>The choices that depend on the resolved codec (new lists only when they change, so selections stay bound).</summary>
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))];
/// <summary>Estimates every card off the UI thread for the project as it is now (latest request wins).</summary>
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<Choice> 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<ExportSettings, ExportSettings> change, string? mergeKey = null) =>
Editor.Session.Edit(p => p with { Export = change(p.Export) }, mergeKey);
private void EditOverrides(Func<ExportOverrides, ExportOverrides> 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;
}
}