Files
Chronos/src/Titano.Core/Advice/SequencePresets.cs
T
Claude 52cde1419b refactor(core): name the advisor namespace Advice; record advisor decisions
The Advisor class shared its namespace's name, forcing an alias in every
Titano.Core caller.

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

218 lines
10 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.Text.Json;
using System.Text.Json.Serialization;
using Titano.Core.Analysis;
using Titano.Core.Analysis.Deep;
using Titano.Core.Export;
using Titano.Core.Localization;
using Titano.Core.Project;
using Titano.Core.Video;
namespace Titano.Core.Advice;
/// <summary>
/// A one-click bundle (BRIEF §10.3): full project settings plus an export preset, named by a resource key and
/// arguments (culture-neutral numbers or tokens) or, for user presets, by the user's own <see cref="Name"/>.
/// </summary>
public sealed record SequencePreset
{
/// <summary>"night-sky", "holy-grail", "construction", "social-vertical", "standard", or a user id.</summary>
public required string Id { get; init; }
public required string NameKey { get; init; }
public IReadOnlyList<string> NameArgs { get; init; } = [];
/// <summary>The user's name for a saved preset; overrides <see cref="NameKey"/>.</summary>
public string? Name { get; init; }
public string? ReasonKey { get; init; }
public IReadOnlyList<string> ReasonArgs { get; init; } = [];
public required ProjectSettings Settings { get; init; }
public required string ExportPresetId { get; init; }
/// <summary>0..1: how well the measured content matches the preset.</summary>
public double Confidence { get; init; }
public bool IsUser { get; init; }
public string DisplayName() => Name ?? Advisor.Explain(NameKey, NameArgs);
/// <summary>A copy saved under the user's name.</summary>
public SequencePreset AsUserPreset(string name)
{
ArgumentException.ThrowIfNullOrWhiteSpace(name);
return this with { Id = Guid.CreateVersion7().ToString("N"), Name = name.Trim(), IsUser = true };
}
public string ToJson() => JsonSerializer.Serialize(this, AdvisorJson.Default.SequencePreset);
public static SequencePreset FromJson(string json) =>
JsonSerializer.Deserialize(json, AdvisorJson.Default.SequencePreset) ?? throw new InvalidDataException("Preset JSON is empty.");
}
/// <summary>
/// Generates the sequence presets that fit the measured content, best match first: Night sky (star field or night,
/// 4K 10-bit HEVC 24 fps, deflicker, stabilise when shaky), Holy grail sunset (received exposure steps across a
/// day/night change, 4K HEVC 30 fps, transitions), Construction cam (several sessions over at least a day, 1080p
/// H.264 30 fps, adaptive timing), Standard when none of these match, and Social vertical (1080×1920) always last.
/// A preset's export choice gives way to the advised one when the source, previews or encoders cannot reach it.
/// Content values stay Auto with the advisor's reasons; the preset's own choices are stored as manual values.
/// </summary>
public static class SequencePresets
{
public static IReadOnlyList<SequencePreset> Generate(LightAnalysisReport light, DeepAnalysisReport? deep, SequenceContext context)
{
ArgumentNullException.ThrowIfNull(light);
ArgumentNullException.ThrowIfNull(context);
var advice = Advisor.Recommend(light, deep, context);
var advised = Advisor.Apply(new ProjectSettings(), advice);
var exportId = advice.Find(AdvisorParameters.ExportPreset)?.Value as string ?? "1080p-h264";
var presets = new List<SequencePreset>();
if (deep is { } d && (d.Sky.StarField || d.Sky.Light == DayNight.Night))
{
var id = Pick(exportId, "4k-hevc10-archive", context);
var window = advised.Exposure.DeflickerWindow.AutoValue;
var shaky = advice.Find(AdvisorParameters.Stabilize)?.Value is true;
var settings = Manual(advised, id, "24") with { Exposure = advised.Exposure with { Deflicker = advised.Exposure.Deflicker.WithManual(true) } };
if (shaky) settings = settings with { Motion = settings.Motion with { Stabilize = settings.Motion.Stabilize.WithManual(true) } };
var stars = d.Sky.StarField ? 100.0 * d.Sky.StarFrames / int.Max(1, d.FrameCount) : 0;
presets.Add(new SequencePreset
{
Id = "night-sky",
NameKey = shaky ? AdvisorKeys.PresetNightSkyStabilised : AdvisorKeys.PresetNightSky,
NameArgs = [Label(id), CodecLabel(id), "24", Text(window)],
ReasonKey = AdvisorKeys.PresetReasonNightSky,
ReasonArgs = [Text(double.Round(stars))],
Settings = settings,
ExportPresetId = id,
Confidence = d.Sky.StarField ? 0.9 : 0.7,
});
}
var received = deep?.Exposure.ReceivedSteps ?? (light.ExposureValues.Any(v => v is not null) ? light.ExposureSteps.Count : 0);
var lightChange = deep is not null
? deep.Sky.Light is DayNight.DayToNight or DayNight.NightToDay || deep.Exposure.SceneRangeEv >= 3
: light.Findings.Any(f => f.Key == FindingKeys.DayNightTransition);
if (received > 0 && lightChange)
{
var id = Pick(exportId, "4k-hevc", context);
var transitions = advised.Exposure.TransitionLength.AutoValue;
var range = deep?.Exposure.SceneRangeEv ?? 0;
var settings = Manual(advised, id, "30") with
{
Exposure = advised.Exposure with
{
HolyGrail = advised.Exposure.HolyGrail.WithManual(true),
Deflicker = advised.Exposure.Deflicker.WithManual(true),
},
};
presets.Add(new SequencePreset
{
Id = "holy-grail",
NameKey = AdvisorKeys.PresetHolyGrail,
NameArgs = [Label(id), CodecLabel(id), "30", Text(transitions)],
ReasonKey = AdvisorKeys.PresetReasonHolyGrail,
ReasonArgs = [Text(received), Text(double.Round(range, 1))],
Settings = settings,
ExportPresetId = id,
Confidence = 0.85,
});
}
if (light.Sessions.Count >= 2 && light.CaptureSpan >= TimeSpan.FromDays(1))
{
var id = Pick(exportId, "1080p-h264", context);
var settings = Manual(advised, id, "30");
settings = settings with { Timing = settings.Timing with { Mode = settings.Timing.Mode.WithManual(TimingMode.Adaptive) } };
presets.Add(new SequencePreset
{
Id = "construction",
NameKey = AdvisorKeys.PresetConstruction,
NameArgs = [Label(id), CodecLabel(id), "30"],
ReasonKey = AdvisorKeys.PresetReasonConstruction,
ReasonArgs = [Text(light.Sessions.Count), Text(double.Round(light.CaptureSpan.TotalDays, 1))],
Settings = settings,
ExportPresetId = id,
Confidence = 0.8,
});
}
if (presets.Count == 0)
{
var fps = advised.Timing.FrameRate.AutoValue ?? ExportPresets.Find(exportId)?.FrameRate.ToString() ?? "30";
presets.Add(new SequencePreset
{
Id = "standard",
NameKey = AdvisorKeys.PresetStandard,
NameArgs = [Label(exportId), CodecLabel(exportId), fps],
ReasonKey = AdvisorKeys.PresetReasonStandard,
Settings = Manual(advised, exportId, null),
ExportPresetId = exportId,
Confidence = 0.6,
});
}
const string vertical = "vertical-1080x1920";
var social = Manual(advised, vertical, "30") with { Camera = advised.Camera with { Aspect = advised.Camera.Aspect.WithManual("9:16"), OffsetY = 0 } };
presets.Add(new SequencePreset
{
Id = "social-vertical",
NameKey = AdvisorKeys.PresetSocialVertical,
NameArgs = ["1080", "1920"],
ReasonKey = AdvisorKeys.PresetReasonSocialVertical,
Settings = social,
ExportPresetId = vertical,
Confidence = 0.4,
});
return [.. presets.OrderByDescending(p => p.Confidence)];
}
/// <summary>The preset's own export choice when the advised size reaches 4K, else the advised (capped) preset.</summary>
private static string Pick(string advised, string wanted, SequenceContext context)
{
var cap = ExportPresets.Find(advised);
var target = ExportPresets.Find(wanted)!;
var codecOk = context.Codecs.Count == 0 || context.Codecs.Any(c => c.Codec == target.Codec && (target.BitDepth <= 8 || c.SupportsTenBit));
return cap is not null && cap.Width >= target.Width && cap.Height >= target.Height && codecOk ? wanted : advised;
}
/// <summary>Export preset and (optionally) frame rate as the preset's manual choices.</summary>
private static ProjectSettings Manual(ProjectSettings settings, string exportId, string? frameRate)
{
settings = settings with { Export = settings.Export with { Preset = settings.Export.Preset.WithManual(exportId) } };
return frameRate is null ? settings : settings with { Timing = settings.Timing with { FrameRate = settings.Timing.FrameRate.WithManual(frameRate) } };
}
/// <summary>Resolution label of an export preset ("4K", "1440p", "1080p", …).</summary>
private static string Label(string exportId) => ExportPresets.Find(exportId) switch
{
{ Width: >= 3840 } => "4K",
{ Width: > 0 } p => string.Create(CultureInfo.InvariantCulture, $"{int.Min(p.Width, p.Height)}p"),
_ => exportId,
};
/// <summary>Codec label of an export preset ("HEVC Main10", "HEVC", "H.264", "AV1"): technical names, not translated.</summary>
private static string CodecLabel(string exportId) => ExportPresets.Find(exportId) switch
{
{ Codec: VideoCodec.Hevc, BitDepth: >= 10 } => "HEVC Main10",
{ Codec: VideoCodec.Hevc } => "HEVC",
{ Codec: VideoCodec.Av1 } => "AV1",
{ Codec: VideoCodec.H264 } => "H.264",
{ } p => p.Codec.ToString(),
_ => exportId,
};
private static string Text<T>(T value) => Convert.ToString(value, CultureInfo.InvariantCulture) ?? string.Empty;
}
/// <summary>Source-generated JSON for saved sequence presets.</summary>
[JsonSourceGenerationOptions(
WriteIndented = true,
PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
UseStringEnumConverter = true,
PropertyNameCaseInsensitive = true)]
[JsonSerializable(typeof(SequencePreset))]
internal sealed partial class AdvisorJson : JsonSerializerContext;