feat(export): preset resolution with the Custom rule, output naming and estimates
ExportResolver applies overrides and names the result after the preset it equals (or custom); ExportNaming expands the name template with collision suffixes; ExportEstimator predicts size and time from a calibratable throughput model. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
6 files changed
+779
No files matched your search
@@ -0,0 +1,145 @@
|
||||
using Titano.Core.Video;
|
||||
|
||||
namespace Titano.Core.Export;
|
||||
|
||||
/// <summary>What a render will do, in the units the estimates need.</summary>
|
||||
/// <param name="OutputFrames">Distinct output pictures (planned frames).</param>
|
||||
/// <param name="OutputPeriods">Output frame periods (pictures repeated on constant-rate outputs).</param>
|
||||
/// <param name="DurationSeconds">Video duration.</param>
|
||||
/// <param name="Width">Output width.</param>
|
||||
/// <param name="Height">Output height.</param>
|
||||
/// <param name="WorkingPixels">Pixels of each decoded source frame.</param>
|
||||
/// <param name="FlowFrames">Output frames that need optical flow (synthesised or motion-blurred).</param>
|
||||
/// <param name="AnalysisFrames">Frames read by the preparation pass (0 when cached analysis covers everything).</param>
|
||||
/// <param name="HardwareEncoder">True when a hardware encoder is expected.</param>
|
||||
public sealed record ExportWorkload(
|
||||
int OutputFrames,
|
||||
int OutputPeriods,
|
||||
double DurationSeconds,
|
||||
int Width,
|
||||
int Height,
|
||||
long WorkingPixels,
|
||||
int FlowFrames,
|
||||
int AnalysisFrames,
|
||||
bool HardwareEncoder);
|
||||
|
||||
/// <summary>Estimated output size and render time.</summary>
|
||||
public sealed record ExportEstimate(long Bytes, TimeSpan Time);
|
||||
|
||||
/// <summary>
|
||||
/// Throughput of the stages on this machine, in megapixels (or frames) per second. Defaults are conservative figures
|
||||
/// for a 4-core desktop; <see cref="Calibrate"/> folds the measured time of a finished render into <see cref="Scale"/>.
|
||||
/// </summary>
|
||||
public sealed record ThroughputModel
|
||||
{
|
||||
public static ThroughputModel Default { get; } = new();
|
||||
|
||||
public double DecodeMegapixelsPerSecond { get; init; } = 80;
|
||||
|
||||
/// <summary>Exposure, geometry and stacking per working-size pixel.</summary>
|
||||
public double ProcessMegapixelsPerSecond { get; init; } = 60;
|
||||
|
||||
/// <summary>Optical flow plus synthesis or blur per output pixel.</summary>
|
||||
public double FlowMegapixelsPerSecond { get; init; } = 5;
|
||||
|
||||
public double AnalysisFramesPerSecond { get; init; } = 40;
|
||||
|
||||
public double HardwareEncodeMegapixelsPerSecond { get; init; } = 400;
|
||||
|
||||
public double SoftwareVideoEncodeMegapixelsPerSecond { get; init; } = 50;
|
||||
|
||||
public double JpegEncodeMegapixelsPerSecond { get; init; } = 60;
|
||||
|
||||
public double PngEncodeMegapixelsPerSecond { get; init; } = 12;
|
||||
|
||||
public double TiffEncodeMegapixelsPerSecond { get; init; } = 25;
|
||||
|
||||
public double GifEncodeMegapixelsPerSecond { get; init; } = 20;
|
||||
|
||||
/// <summary>Machine factor learnt from finished renders (2 = twice as fast as the defaults).</summary>
|
||||
public double Scale { get; init; } = 1;
|
||||
|
||||
/// <summary>Moves <see cref="Scale"/> towards the ratio of a predicted to an actual render time.</summary>
|
||||
/// <param name="weight">0 keeps the old scale, 1 adopts the new measurement entirely.</param>
|
||||
public ThroughputModel Calibrate(TimeSpan predicted, TimeSpan actual, double weight = 0.5)
|
||||
{
|
||||
if (predicted <= TimeSpan.Zero || actual <= TimeSpan.Zero) return this;
|
||||
var ratio = predicted.TotalSeconds / actual.TotalSeconds;
|
||||
return this with { Scale = double.Clamp(Scale * double.Pow(ratio, double.Clamp(weight, 0, 1)), 0.02, 50) };
|
||||
}
|
||||
|
||||
internal double EncodeMegapixelsPerSecond(VideoCodec codec, bool hardware) => codec switch
|
||||
{
|
||||
VideoCodec.H264 or VideoCodec.Hevc or VideoCodec.Av1 => hardware ? HardwareEncodeMegapixelsPerSecond : SoftwareVideoEncodeMegapixelsPerSecond,
|
||||
VideoCodec.Mjpeg or VideoCodec.JpegSequence => JpegEncodeMegapixelsPerSecond,
|
||||
VideoCodec.PngSequence or VideoCodec.Apng => PngEncodeMegapixelsPerSecond,
|
||||
VideoCodec.Gif => GifEncodeMegapixelsPerSecond,
|
||||
_ => TiffEncodeMegapixelsPerSecond,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Output size and render time estimates for the Export tab. Video codecs: bit rate × duration plus 1 % container
|
||||
/// overhead. Frame-based outputs: bits per pixel typical of photographic time-lapse content — JPEG by quality
|
||||
/// (≈1 bpp at 50 to ≈9 bpp at 100), PNG 12/30 bpp (8/16-bit), TIFF-16 30 bpp, DNG 26 bpp, GIF 2.5 bpp for the first
|
||||
/// frame and 1.2 bpp per difference frame, APNG 10 and 6 bpp — times the pictures written (constant-rate outputs repeat
|
||||
/// held pictures).
|
||||
/// </summary>
|
||||
public static class ExportEstimator
|
||||
{
|
||||
private static readonly (int Quality, double Bpp)[] JpegBits = [(1, 0.3), (50, 1.0), (75, 1.6), (85, 2.2), (90, 2.8), (95, 4.0), (100, 9.0)];
|
||||
|
||||
public static ExportEstimate Estimate(ResolvedExport export, ExportWorkload workload, ThroughputModel? model = null)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(export);
|
||||
ArgumentNullException.ThrowIfNull(workload);
|
||||
return new ExportEstimate(EstimateBytes(export, workload), EstimateTime(export.Codec, workload, model ?? ThroughputModel.Default));
|
||||
}
|
||||
|
||||
public static long EstimateBytes(ResolvedExport export, ExportWorkload w)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(export);
|
||||
ArgumentNullException.ThrowIfNull(w);
|
||||
double pixels = (double)w.Width * w.Height;
|
||||
var bits = export.Codec switch
|
||||
{
|
||||
VideoCodec.H264 or VideoCodec.Hevc or VideoCodec.Av1 => export.EffectiveBitRate(w.Width, w.Height) * w.DurationSeconds * 1.01,
|
||||
VideoCodec.Mjpeg => (JpegBitsPerPixel(export.Quality) * pixels + 24 * 8) * w.OutputPeriods,
|
||||
VideoCodec.JpegSequence => JpegBitsPerPixel(export.Quality) * pixels * w.OutputPeriods,
|
||||
VideoCodec.PngSequence => (export.BitDepth > 8 ? 30 : 12) * pixels * w.OutputPeriods,
|
||||
VideoCodec.Tiff16Sequence => (export.BitDepth > 8 ? 30 : 12) * pixels * w.OutputPeriods,
|
||||
VideoCodec.LinearDngSequence => 26 * pixels * w.OutputPeriods,
|
||||
VideoCodec.Gif => w.OutputFrames > 0 ? (2.5 + 1.2 * (w.OutputFrames - 1)) * pixels : 0,
|
||||
VideoCodec.Apng => w.OutputFrames > 0 ? (10 + 6.0 * (w.OutputFrames - 1)) * pixels : 0,
|
||||
_ => 0,
|
||||
};
|
||||
return (long)double.Ceiling(bits / 8);
|
||||
}
|
||||
|
||||
public static TimeSpan EstimateTime(VideoCodec codec, ExportWorkload w, ThroughputModel model)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(w);
|
||||
ArgumentNullException.ThrowIfNull(model);
|
||||
var outputMp = (double)w.Width * w.Height / 1e6;
|
||||
var workingMp = w.WorkingPixels / 1e6;
|
||||
var seconds = w.AnalysisFrames / model.AnalysisFramesPerSecond
|
||||
+ w.OutputFrames * (workingMp / model.DecodeMegapixelsPerSecond + workingMp / model.ProcessMegapixelsPerSecond
|
||||
+ outputMp / model.EncodeMegapixelsPerSecond(codec, w.HardwareEncoder))
|
||||
+ w.FlowFrames * outputMp / model.FlowMegapixelsPerSecond;
|
||||
return TimeSpan.FromSeconds(seconds / model.Scale);
|
||||
}
|
||||
|
||||
/// <summary>Typical JPEG bits per pixel at an IJG quality, piecewise linear between measured points.</summary>
|
||||
public static double JpegBitsPerPixel(int quality)
|
||||
{
|
||||
quality = int.Clamp(quality, 1, 100);
|
||||
for (var i = 1; i < JpegBits.Length; i++)
|
||||
{
|
||||
var (q1, b1) = JpegBits[i];
|
||||
if (quality > q1) continue;
|
||||
var (q0, b0) = JpegBits[i - 1];
|
||||
return b0 + (b1 - b0) * (quality - q0) / (q1 - q0);
|
||||
}
|
||||
return JpegBits[^1].Bpp;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
using System.Globalization;
|
||||
using System.Text;
|
||||
using Titano.Core.Naming;
|
||||
using Titano.Core.Video;
|
||||
|
||||
namespace Titano.Core.Export;
|
||||
|
||||
/// <summary>Values of the export name tokens.</summary>
|
||||
public sealed record ExportNameContext
|
||||
{
|
||||
/// <summary>Shoot date of the sequence (first capture), or the render date when unknown.</summary>
|
||||
public required DateTime Date { get; init; }
|
||||
|
||||
public string? Title { get; init; }
|
||||
|
||||
/// <summary>Display name of the preset in the user's language ("Custom" for custom values).</summary>
|
||||
public required string PresetName { get; init; }
|
||||
|
||||
public int Width { get; init; }
|
||||
public int Height { get; init; }
|
||||
public Rational FrameRate { get; init; } = new(30, 1);
|
||||
public required VideoCodec Codec { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>An expanded export name and any template problems.</summary>
|
||||
public sealed record ExportName(string Name, IReadOnlyList<TemplateError> Errors)
|
||||
{
|
||||
public bool IsValid => Errors.Count == 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Output names from <see cref="Project.ExportSettings.NameTemplate"/> (BRIEF §11.5). Tokens: <c>{date}</c> (optionally
|
||||
/// <c>{date:yyyyMMdd}</c>), <c>{title}</c>, <c>{preset}</c>, <c>{width}</c>, <c>{height}</c>, <c>{fps}</c>, <c>{codec}</c>;
|
||||
/// <c>{{</c>/<c>}}</c> are literal braces. The result is sanitised like <see cref="PathTemplate"/>; an existing file or
|
||||
/// folder gets a " (2)", " (3)"… suffix.
|
||||
/// </summary>
|
||||
public static class ExportNaming
|
||||
{
|
||||
public static IReadOnlyList<string> Tokens { get; } = ["date", "title", "preset", "width", "height", "fps", "codec"];
|
||||
|
||||
/// <summary>Name used when a template expands to nothing.</summary>
|
||||
public const string FallbackName = "Render";
|
||||
|
||||
/// <summary>Short, file-name safe codec label ("H.264", "HEVC", "PNG"…).</summary>
|
||||
public static string CodecLabel(VideoCodec codec) => codec switch
|
||||
{
|
||||
VideoCodec.H264 => "H.264",
|
||||
VideoCodec.Hevc => "HEVC",
|
||||
VideoCodec.Av1 => "AV1",
|
||||
VideoCodec.Mjpeg => "MJPEG",
|
||||
VideoCodec.JpegSequence => "JPEG",
|
||||
VideoCodec.PngSequence => "PNG",
|
||||
VideoCodec.Tiff16Sequence => "TIFF",
|
||||
VideoCodec.LinearDngSequence => "DNG",
|
||||
VideoCodec.Gif => "GIF",
|
||||
VideoCodec.Apng => "APNG",
|
||||
_ => codec.ToString(),
|
||||
};
|
||||
|
||||
/// <summary>Expands <paramref name="template"/> into a sanitised name without extension.</summary>
|
||||
public static ExportName Expand(string template, ExportNameContext context)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(template);
|
||||
ArgumentNullException.ThrowIfNull(context);
|
||||
var errors = new List<TemplateError>();
|
||||
var sb = new StringBuilder();
|
||||
for (var i = 0; i < template.Length; i++)
|
||||
{
|
||||
var c = template[i];
|
||||
if ((c == '{' || c == '}') && i + 1 < template.Length && template[i + 1] == c)
|
||||
{
|
||||
sb.Append(c);
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (c == '}')
|
||||
{
|
||||
errors.Add(new TemplateError(i, "UnopenedBrace", null));
|
||||
continue;
|
||||
}
|
||||
if (c != '{')
|
||||
{
|
||||
sb.Append(c);
|
||||
continue;
|
||||
}
|
||||
var close = template.IndexOf('}', i + 1);
|
||||
if (close < 0)
|
||||
{
|
||||
errors.Add(new TemplateError(i, "UnclosedBrace", null));
|
||||
sb.Append(template, i, template.Length - i);
|
||||
break;
|
||||
}
|
||||
var body = template[(i + 1)..close];
|
||||
var colon = body.IndexOf(':', StringComparison.Ordinal);
|
||||
var name = (colon < 0 ? body : body[..colon]).Trim().ToLowerInvariant();
|
||||
var format = colon < 0 ? null : body[(colon + 1)..];
|
||||
if (Value(name, format, context) is { } value) sb.Append(value.Replace('/', '-').Replace('\\', '-'));
|
||||
else errors.Add(new TemplateError(i, name.Length == 0 ? "EmptyToken" : "UnknownToken", name));
|
||||
i = close;
|
||||
}
|
||||
var result = PathTemplate.SanitizeSegment(sb.ToString());
|
||||
return new ExportName(result.Length == 0 ? FallbackName : result, errors);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Full output path inside <paramref name="folder"/>: the expanded name plus the codec's extension, or the bare name
|
||||
/// for image sequences (a folder), made unique against existing files and folders.
|
||||
/// </summary>
|
||||
public static string OutputPath(string folder, string template, ExportNameContext context)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(folder);
|
||||
var name = Expand(template, context).Name;
|
||||
var extension = VideoCodecInfo.DefaultContainer(context.Codec) == ContainerFormat.ImageSequence ? string.Empty : VideoCodecInfo.FileExtension(context.Codec);
|
||||
return Unique(folder, name, extension);
|
||||
}
|
||||
|
||||
/// <summary>"name.ext", or "name (2).ext", "name (3).ext"… when a file or folder of that name exists.</summary>
|
||||
public static string Unique(string folder, string name, string extension)
|
||||
{
|
||||
for (var n = 1; ; n++)
|
||||
{
|
||||
var candidate = Path.Combine(folder, (n == 1 ? name : string.Create(CultureInfo.InvariantCulture, $"{name} ({n})")) + extension);
|
||||
if (!File.Exists(candidate) && !Directory.Exists(candidate)) return candidate;
|
||||
}
|
||||
}
|
||||
|
||||
private static string? Value(string token, string? format, ExportNameContext c)
|
||||
{
|
||||
var inv = CultureInfo.InvariantCulture;
|
||||
return token switch
|
||||
{
|
||||
"date" => c.Date.ToString(format ?? "yyyy-MM-dd", inv),
|
||||
"title" => c.Title ?? string.Empty,
|
||||
"preset" => c.PresetName,
|
||||
"width" => c.Width.ToString(format, inv),
|
||||
"height" => c.Height.ToString(format, inv),
|
||||
"fps" => c.FrameRate.ToString(),
|
||||
"codec" => CodecLabel(c.Codec),
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
using Titano.Core.Project;
|
||||
using Titano.Core.Video;
|
||||
|
||||
namespace Titano.Core.Export;
|
||||
|
||||
/// <summary>Export values after applying a project's overrides to its preset (BRIEF §11.4).</summary>
|
||||
public sealed record ResolvedExport
|
||||
{
|
||||
/// <summary>Id of the preset whose values these are, or <see cref="ExportResolver.CustomId"/>.</summary>
|
||||
public required string PresetId { get; init; }
|
||||
|
||||
/// <summary>Id of the preset the overrides were applied to.</summary>
|
||||
public required string BasePresetId { get; init; }
|
||||
|
||||
/// <summary>Localisation key of the effective preset's name; null when custom.</summary>
|
||||
public string? NameKey { get; init; }
|
||||
|
||||
public bool IsCustom => PresetId == ExportResolver.CustomId;
|
||||
|
||||
public required VideoCodec Codec { get; init; }
|
||||
|
||||
public ContainerFormat Container => VideoCodecInfo.DefaultContainer(Codec);
|
||||
|
||||
public CodecProfile Profile { get; init; }
|
||||
|
||||
public int BitDepth { get; init; } = 8;
|
||||
|
||||
/// <summary>Output width; 0 derives it from the height and the aspect, or from the source.</summary>
|
||||
public int Width { get; init; }
|
||||
|
||||
/// <summary>Output height; 0 derives it from the width and the aspect, or from the source.</summary>
|
||||
public int Height { get; init; }
|
||||
|
||||
public Rational FrameRate { get; init; } = new(30, 1);
|
||||
|
||||
/// <summary>Fixed bit rate in bit/s; 0 = <see cref="BitsPerPixel"/> at the render size.</summary>
|
||||
public long BitRate { get; init; }
|
||||
|
||||
public double BitsPerPixel { get; init; }
|
||||
|
||||
/// <summary>Key-frame distance in frames.</summary>
|
||||
public int GopFrames { get; init; }
|
||||
|
||||
public int BFrames { get; init; }
|
||||
|
||||
public int Quality { get; init; } = 92;
|
||||
|
||||
public RateControl RateControl { get; init; } = RateControl.Vbr;
|
||||
|
||||
/// <summary>Specific encoder name requested by the user, or null.</summary>
|
||||
public string? Encoder { get; init; }
|
||||
|
||||
/// <summary>Localisation keys of ignored or invalid override values.</summary>
|
||||
public IReadOnlyList<string> Warnings { get; init; } = [];
|
||||
|
||||
/// <summary>Average bit rate for a render of <paramref name="width"/>×<paramref name="height"/>.</summary>
|
||||
public long EffectiveBitRate(int width, int height)
|
||||
{
|
||||
if (BitRate > 0) return BitRate;
|
||||
var bpp = BitsPerPixel > 0 ? BitsPerPixel : ExportPreset.DefaultBitsPerPixel(Codec);
|
||||
return (long)double.Round(bpp * width * height * FrameRate.Value);
|
||||
}
|
||||
|
||||
public EncodeSettings ToEncodeSettings(string outputPath, int width, int height) => new()
|
||||
{
|
||||
OutputPath = outputPath,
|
||||
Codec = Codec,
|
||||
Width = width,
|
||||
Height = height,
|
||||
FrameRate = FrameRate,
|
||||
Profile = Profile,
|
||||
BitDepth = BitDepth,
|
||||
RateControl = RateControl,
|
||||
BitRate = EffectiveBitRate(width, height),
|
||||
Quality = Quality,
|
||||
GopLength = GopFrames,
|
||||
BFrames = BFrames,
|
||||
EncoderName = Encoder,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Applies <see cref="ExportOverrides"/> to the selected preset and names the result: the preset's id when the values
|
||||
/// equal it (or equal another preset), <see cref="CustomId"/> otherwise. Editing any value therefore flips the name to
|
||||
/// "Custom" and editing it back restores the preset name. Unknown or contradictory override values are ignored with a
|
||||
/// warning key.
|
||||
/// </summary>
|
||||
public static class ExportResolver
|
||||
{
|
||||
public const string CustomId = "custom";
|
||||
|
||||
/// <summary>Preset used when none is selected, the stored id is unknown or the selection is "custom".</summary>
|
||||
public const string DefaultPresetId = "1080p-h264";
|
||||
|
||||
public static ResolvedExport Resolve(ExportSettings settings, IReadOnlyList<ExportPreset>? presets = null)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(settings);
|
||||
presets ??= ExportPresets.BuiltIn;
|
||||
var warnings = new List<string>();
|
||||
var id = settings.Preset.Resolve(DefaultPresetId);
|
||||
var basePreset = Find(presets, id) ?? Find(presets, DefaultPresetId) ?? presets.FirstOrDefault()
|
||||
?? throw new ArgumentException("No presets", nameof(presets));
|
||||
if (!basePreset.Id.Equals(id, StringComparison.OrdinalIgnoreCase) && !id.Equals(CustomId, StringComparison.OrdinalIgnoreCase))
|
||||
warnings.Add("Export.Warning.UnknownPreset");
|
||||
|
||||
var values = Apply(FromPreset(basePreset), settings.Overrides, warnings);
|
||||
var match = Matches(values, FromPreset(basePreset)) ? basePreset : presets.FirstOrDefault(p => Matches(values, FromPreset(p)));
|
||||
return values with
|
||||
{
|
||||
PresetId = match?.Id ?? CustomId,
|
||||
BasePresetId = basePreset.Id,
|
||||
NameKey = match?.NameKey,
|
||||
Warnings = warnings,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>The preset's own values (no overrides).</summary>
|
||||
public static ResolvedExport FromPreset(ExportPreset preset)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(preset);
|
||||
return new ResolvedExport
|
||||
{
|
||||
PresetId = preset.Id,
|
||||
BasePresetId = preset.Id,
|
||||
NameKey = preset.NameKey,
|
||||
Codec = preset.Codec,
|
||||
Profile = preset.Profile,
|
||||
BitDepth = preset.BitDepth,
|
||||
Width = preset.Width,
|
||||
Height = preset.Height,
|
||||
FrameRate = preset.FrameRate,
|
||||
BitRate = preset.BitRate,
|
||||
BitsPerPixel = preset.BitsPerPixel,
|
||||
GopFrames = int.Max(1, (int)double.Round(preset.GopSeconds * preset.FrameRate.Value)),
|
||||
BFrames = preset.BFrames,
|
||||
Quality = preset.Quality,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Parses a codec name or alias ("h264", "H.265", "hevc", "png", "tiff16", "dng"…).</summary>
|
||||
public static bool TryParseCodec(string? text, out VideoCodec codec)
|
||||
{
|
||||
codec = default;
|
||||
if (string.IsNullOrWhiteSpace(text)) return false;
|
||||
var key = text.Trim().ToLowerInvariant().Replace(".", string.Empty, StringComparison.Ordinal).Replace("-", string.Empty, StringComparison.Ordinal).Replace(" ", string.Empty, StringComparison.Ordinal);
|
||||
VideoCodec? parsed = key switch
|
||||
{
|
||||
"h264" or "avc" => VideoCodec.H264,
|
||||
"h265" or "hevc" => VideoCodec.Hevc,
|
||||
"av1" => VideoCodec.Av1,
|
||||
"mjpeg" or "mjpg" => VideoCodec.Mjpeg,
|
||||
"jpeg" or "jpg" or "jpegsequence" => VideoCodec.JpegSequence,
|
||||
"png" or "pngsequence" => VideoCodec.PngSequence,
|
||||
"tiff" or "tif" or "tiff16" or "tiff16sequence" => VideoCodec.Tiff16Sequence,
|
||||
"dng" or "lineardng" or "lineardngsequence" => VideoCodec.LinearDngSequence,
|
||||
"gif" => VideoCodec.Gif,
|
||||
"apng" => VideoCodec.Apng,
|
||||
_ => null,
|
||||
};
|
||||
if (parsed is null) return false;
|
||||
codec = parsed.Value;
|
||||
return true;
|
||||
}
|
||||
|
||||
private static ExportPreset? Find(IReadOnlyList<ExportPreset> presets, string id) =>
|
||||
presets.FirstOrDefault(p => p.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
private static ResolvedExport Apply(ResolvedExport v, ExportOverrides o, List<string> warnings)
|
||||
{
|
||||
if (o.Codec is not null)
|
||||
{
|
||||
if (TryParseCodec(o.Codec, out var codec))
|
||||
{
|
||||
if (codec != v.Codec) v = v with { Codec = codec, Profile = CodecProfile.Auto, BitRate = 0, BitsPerPixel = 0 };
|
||||
}
|
||||
else
|
||||
{
|
||||
warnings.Add("Export.Warning.UnknownCodec");
|
||||
}
|
||||
}
|
||||
if (o.Container is not null && !ContainerMatches(o.Container, v.Container)) warnings.Add("Export.Warning.ContainerIgnored");
|
||||
if (o.Profile is not null)
|
||||
{
|
||||
if (Enum.TryParse<CodecProfile>(o.Profile, ignoreCase: true, out var profile) && Enum.IsDefined(profile)) v = v with { Profile = profile };
|
||||
else warnings.Add("Export.Warning.UnknownProfile");
|
||||
}
|
||||
if (o.BitDepth is { } depth) v = v with { BitDepth = depth };
|
||||
if (o.Width is { } width) v = v with { Width = int.Max(0, width) };
|
||||
if (o.Height is { } height) v = v with { Height = int.Max(0, height) };
|
||||
if (o.FrameRate is not null)
|
||||
{
|
||||
if (FrameRateText.TryParse(o.FrameRate, out var rate))
|
||||
{
|
||||
// A preset's GOP is defined in seconds: keep its duration at the new rate unless the GOP is overridden too.
|
||||
var seconds = v.GopFrames / v.FrameRate.Value;
|
||||
v = v with { FrameRate = rate, GopFrames = int.Max(1, (int)double.Round(seconds * rate.Value)) };
|
||||
}
|
||||
else
|
||||
{
|
||||
warnings.Add("Export.Warning.UnknownFrameRate");
|
||||
}
|
||||
}
|
||||
if (o.BitRate is { } bitRate) v = v with { BitRate = long.Max(0, bitRate) };
|
||||
if (o.GopFrames is { } gop) v = v with { GopFrames = int.Max(1, gop) };
|
||||
if (o.BFrames is { } bFrames) v = v with { BFrames = int.Max(0, bFrames) };
|
||||
if (o.Quality is { } quality) v = v with { Quality = int.Clamp(quality, 1, 100) };
|
||||
if (o.RateControl is not null)
|
||||
{
|
||||
if (Enum.TryParse<RateControl>(o.RateControl, ignoreCase: true, out var rc) && Enum.IsDefined(rc)) v = v with { RateControl = rc };
|
||||
else warnings.Add("Export.Warning.UnknownRateControl");
|
||||
}
|
||||
if (o.Encoder is not null) v = v with { Encoder = string.IsNullOrWhiteSpace(o.Encoder) ? null : o.Encoder };
|
||||
return v;
|
||||
}
|
||||
|
||||
private static bool ContainerMatches(string text, ContainerFormat container) =>
|
||||
Enum.TryParse<ContainerFormat>(text, ignoreCase: true, out var parsed) && parsed == container;
|
||||
|
||||
/// <summary>Equal export values; bit rates compare as effective rates when the size is fixed.</summary>
|
||||
private static bool Matches(ResolvedExport a, ResolvedExport b)
|
||||
{
|
||||
if (a.Codec != b.Codec || a.Profile != b.Profile || a.BitDepth != b.BitDepth || a.Width != b.Width || a.Height != b.Height
|
||||
|| !FrameRateText.AreEqual(a.FrameRate, b.FrameRate) || a.GopFrames != b.GopFrames || a.BFrames != b.BFrames
|
||||
|| a.Quality != b.Quality || a.RateControl != b.RateControl || a.Encoder != b.Encoder) return false;
|
||||
return a.Width > 0 && a.Height > 0
|
||||
? a.EffectiveBitRate(a.Width, a.Height) == b.EffectiveBitRate(b.Width, b.Height)
|
||||
: a.BitRate == b.BitRate && a.BitsPerPixel == b.BitsPerPixel;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
using Titano.Core.Export;
|
||||
using Titano.Core.Video;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.Core.Tests.Export;
|
||||
|
||||
public sealed class ExportEstimateTests
|
||||
{
|
||||
private static ExportWorkload Workload(int frames = 600, int width = 3840, int height = 2160, int flow = 0, int analysis = 0, bool hardware = true) =>
|
||||
new(frames, frames, frames / 24.0, width, height, (long)width * height, flow, analysis, hardware);
|
||||
|
||||
private static ResolvedExport Preset(string id) => ExportResolver.FromPreset(ExportPresets.Find(id)!);
|
||||
|
||||
[Test]
|
||||
public void VideoSizeIsBitRateTimesDuration()
|
||||
{
|
||||
var export = Preset("4k-h264");
|
||||
var bytes = ExportEstimator.EstimateBytes(export, Workload());
|
||||
var expected = 0.10 * 3840 * 2160 * 24 * 25 / 8 * 1.01;
|
||||
Assert.Approximately(expected, bytes, 1);
|
||||
Assert.InRange(bytes / 1e6, 60, 70); // ≈ 63 MB for 25 s of 4K at 19.9 Mb/s
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FrameBasedSizesScaleWithPicturesAndDepth()
|
||||
{
|
||||
var png8 = ExportResolver.FromPreset(ExportPresets.Find("png-sequence")!) with { Width = 1920, Height = 1080 };
|
||||
var png16 = png8 with { BitDepth = 16 };
|
||||
var w = Workload(240, 1920, 1080) with { OutputPeriods = 480 };
|
||||
Assert.Equal(2 * ExportEstimator.EstimateBytes(png8, Workload(240, 1920, 1080)), ExportEstimator.EstimateBytes(png8, w));
|
||||
Assert.Greater(ExportEstimator.EstimateBytes(png16, w), 2 * ExportEstimator.EstimateBytes(png8, w));
|
||||
var gif = Preset("gif-preview");
|
||||
Assert.Less(ExportEstimator.EstimateBytes(gif, Workload(240, 480, 270)), ExportEstimator.EstimateBytes(Preset("apng"), Workload(240, 480, 270)));
|
||||
Assert.Monotonic(Enumerable.Range(1, 100).Select(q => ExportEstimator.JpegBitsPerPixel(q)), strict: true);
|
||||
Assert.Approximately(2.8, ExportEstimator.JpegBitsPerPixel(90), 1e-12);
|
||||
var mjpeg = Preset("mjpeg-avi");
|
||||
Assert.Greater(ExportEstimator.EstimateBytes(mjpeg, Workload()), ExportEstimator.EstimateBytes(Preset("4k-hevc10-archive"), Workload()));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void TimeGrowsWithWorkAndCalibrationRescalesIt()
|
||||
{
|
||||
var export = Preset("4k-hevc");
|
||||
var model = ThroughputModel.Default;
|
||||
var plain = ExportEstimator.EstimateTime(export.Codec, Workload(), model);
|
||||
Assert.Greater(ExportEstimator.EstimateTime(export.Codec, Workload(flow: 600), model).TotalSeconds, 2 * plain.TotalSeconds);
|
||||
Assert.Greater(ExportEstimator.EstimateTime(export.Codec, Workload(analysis: 600), model).TotalSeconds, plain.TotalSeconds);
|
||||
Assert.Greater(ExportEstimator.EstimateTime(export.Codec, Workload(hardware: false), model).TotalSeconds, plain.TotalSeconds);
|
||||
Assert.InRange(plain.TotalSeconds, 30, 600); // ≈ 4 frames per second of 4K on the default model
|
||||
|
||||
var faster = model.Calibrate(plain, plain / 2, weight: 1);
|
||||
Assert.Approximately(2.0, faster.Scale, 1e-9);
|
||||
Assert.Approximately(plain.TotalSeconds / 2, ExportEstimator.EstimateTime(export.Codec, Workload(), faster).TotalSeconds, 1e-6);
|
||||
Assert.Approximately(Math.Sqrt(2), model.Calibrate(plain, plain / 2).Scale, 1e-9);
|
||||
Assert.Same(model, model.Calibrate(TimeSpan.Zero, plain));
|
||||
|
||||
var estimate = ExportEstimator.Estimate(export, Workload());
|
||||
Assert.Equal(ExportEstimator.EstimateBytes(export, Workload()), estimate.Bytes);
|
||||
Assert.Equal(plain, estimate.Time);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using Titano.Core.Export;
|
||||
using Titano.Core.Video;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.Core.Tests.Export;
|
||||
|
||||
public sealed class ExportNamingTests
|
||||
{
|
||||
private readonly TestContext _context;
|
||||
|
||||
public ExportNamingTests(TestContext context) => _context = context;
|
||||
|
||||
private static ExportNameContext Context(VideoCodec codec = VideoCodec.Hevc, string? title = "Harbour sunset") => new()
|
||||
{
|
||||
Date = new DateTime(2024, 6, 21, 19, 30, 0),
|
||||
Title = title,
|
||||
PresetName = "4K UHD HEVC",
|
||||
Width = 3840,
|
||||
Height = 2160,
|
||||
FrameRate = Rational.Fps2997,
|
||||
Codec = codec,
|
||||
};
|
||||
|
||||
[Test]
|
||||
public void DefaultTemplateNamesTheRender()
|
||||
{
|
||||
var name = ExportNaming.Expand("{date} {title} - {preset}", Context());
|
||||
Assert.Equal("2024-06-21 Harbour sunset - 4K UHD HEVC", name.Name);
|
||||
Assert.True(name.IsValid);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void EveryTokenExpands()
|
||||
{
|
||||
var name = ExportNaming.Expand("{date:yyyyMMdd}_{width}x{height}_{fps}fps_{codec}_{{raw}}", Context());
|
||||
Assert.Equal("20240621_3840x2160_29.97fps_HEVC_{raw}", name.Name);
|
||||
Assert.Equal("PNG", ExportNaming.CodecLabel(VideoCodec.PngSequence));
|
||||
Assert.Equal("H.264", ExportNaming.CodecLabel(VideoCodec.H264));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void IllegalCharactersAndProblemsAreReported()
|
||||
{
|
||||
var name = ExportNaming.Expand("{title} {bogus} {", Context(title: "a/b:c*d?"));
|
||||
Assert.Equal("a-b_c_d_ {", name.Name);
|
||||
Assert.Count(2, name.Errors);
|
||||
Assert.Equal("UnknownToken", name.Errors[0].Code);
|
||||
Assert.Equal("UnclosedBrace", name.Errors[1].Code);
|
||||
Assert.Equal(ExportNaming.FallbackName, ExportNaming.Expand("{title}", Context(title: null)).Name);
|
||||
Assert.Equal("2024-06-21 - 4K UHD HEVC", ExportNaming.Expand("{date} {title} - {preset}", Context(title: null)).Name);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CollisionsGetANumberedSuffix()
|
||||
{
|
||||
var dir = _context.CreateTempDirectory();
|
||||
var first = ExportNaming.OutputPath(dir, "{title}", Context());
|
||||
Assert.Equal(Path.Combine(dir, "Harbour sunset.mp4"), first);
|
||||
File.WriteAllBytes(first, [1]);
|
||||
var second = ExportNaming.OutputPath(dir, "{title}", Context());
|
||||
Assert.Equal(Path.Combine(dir, "Harbour sunset (2).mp4"), second);
|
||||
File.WriteAllBytes(second, [1]);
|
||||
Assert.Equal(Path.Combine(dir, "Harbour sunset (3).mp4"), ExportNaming.OutputPath(dir, "{title}", Context()));
|
||||
|
||||
var sequence = ExportNaming.OutputPath(dir, "{title}", Context(VideoCodec.PngSequence));
|
||||
Assert.Equal(Path.Combine(dir, "Harbour sunset"), sequence);
|
||||
Directory.CreateDirectory(sequence);
|
||||
Assert.Equal(Path.Combine(dir, "Harbour sunset (2)"), ExportNaming.OutputPath(dir, "{title}", Context(VideoCodec.PngSequence)));
|
||||
Assert.Equal(Path.Combine(dir, "Harbour sunset.gif"), ExportNaming.OutputPath(dir, "{title}", Context(VideoCodec.Gif)));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
using Titano.Core.Export;
|
||||
using Titano.Core.Project;
|
||||
using Titano.Core.Video;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.Core.Tests.Export;
|
||||
|
||||
public sealed class ExportResolverTests
|
||||
{
|
||||
private static ExportSettings Export(string preset, ExportOverrides? overrides = null) =>
|
||||
new() { Preset = new Auto<string>().WithManual(preset), Overrides = overrides ?? new ExportOverrides() };
|
||||
|
||||
[Test]
|
||||
public void EveryBuiltInPresetResolvesToItself()
|
||||
{
|
||||
foreach (var preset in ExportPresets.BuiltIn)
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export(preset.Id));
|
||||
Assert.Equal(preset.Id, resolved.PresetId);
|
||||
Assert.False(resolved.IsCustom);
|
||||
Assert.Equal(preset.NameKey, resolved.NameKey);
|
||||
Assert.Equal(preset.Codec, resolved.Codec);
|
||||
Assert.Empty(resolved.Warnings);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void EditingAValueMakesTheExportCustom()
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export("4k-hevc", new ExportOverrides { BitRate = 50_000_000 }));
|
||||
Assert.True(resolved.IsCustom);
|
||||
Assert.Equal(ExportResolver.CustomId, resolved.PresetId);
|
||||
Assert.Equal("4k-hevc", resolved.BasePresetId);
|
||||
Assert.Null(resolved.NameKey);
|
||||
Assert.Equal(50_000_000L, resolved.EffectiveBitRate(3840, 2160));
|
||||
Assert.Equal(3840, resolved.Width);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ValuesEqualToThePresetRestoreItsName()
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export("1080p-h264", new ExportOverrides
|
||||
{
|
||||
Codec = "h.264",
|
||||
Container = "mp4",
|
||||
Width = 1920,
|
||||
Height = 1080,
|
||||
FrameRate = "30",
|
||||
BitRate = 6_220_800, // the preset's 0.10 bpp at 1920×1080×30
|
||||
GopFrames = 30,
|
||||
Profile = "H264High",
|
||||
RateControl = "vbr",
|
||||
}));
|
||||
Assert.Equal("1080p-h264", resolved.PresetId);
|
||||
Assert.Empty(resolved.Warnings);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ValuesEqualToAnotherPresetTakeItsName()
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export("1080p-h264", new ExportOverrides { FrameRate = "60" }));
|
||||
Assert.Equal("1080p60", resolved.PresetId);
|
||||
Assert.Equal(60, resolved.GopFrames);
|
||||
Assert.Equal("1080p-h264", resolved.BasePresetId);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FractionalRatesAndGopFollowTheOverride()
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export("4k-h264", new ExportOverrides { FrameRate = "24000/1001" }));
|
||||
Assert.True(resolved.IsCustom);
|
||||
Assert.Equal(Rational.Fps23976, resolved.FrameRate);
|
||||
Assert.Equal(24, resolved.GopFrames);
|
||||
var settings = resolved.ToEncodeSettings("x.mp4", 3840, 2160);
|
||||
Assert.Equal(24, settings.GopLength);
|
||||
Assert.Equal((long)Math.Round(0.10 * 3840 * 2160 * 24000 / 1001.0), settings.BitRate);
|
||||
Assert.Equal(CodecProfile.H264High, settings.Profile);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void BadOverridesAreIgnoredWithWarnings()
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export("1080p-h264", new ExportOverrides { Codec = "divx", FrameRate = "fast", Container = "avi", Profile = "ultra", RateControl = "magic" }));
|
||||
Assert.Equal("1080p-h264", resolved.PresetId);
|
||||
Assert.SequenceEqual(new[] { "Export.Warning.UnknownCodec", "Export.Warning.ContainerIgnored", "Export.Warning.UnknownProfile", "Export.Warning.UnknownFrameRate", "Export.Warning.UnknownRateControl" }, resolved.Warnings);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void UnknownOrCustomSelectionsStartFromTheDefaultPreset()
|
||||
{
|
||||
var unknown = ExportResolver.Resolve(Export("deleted-user-preset"));
|
||||
Assert.Equal(ExportResolver.DefaultPresetId, unknown.PresetId);
|
||||
Assert.Contains("Export.Warning.UnknownPreset", unknown.Warnings);
|
||||
|
||||
var custom = ExportResolver.Resolve(Export("custom", new ExportOverrides { Codec = "png", Width = 0, Height = 0, BitDepth = 16, FrameRate = "30", GopFrames = 30, BFrames = 0, Quality = 92 }));
|
||||
Assert.Empty(custom.Warnings);
|
||||
Assert.Equal(VideoCodec.PngSequence, custom.Codec);
|
||||
Assert.True(custom.IsCustom);
|
||||
|
||||
var auto = ExportResolver.Resolve(new ExportSettings());
|
||||
Assert.Equal(ExportResolver.DefaultPresetId, auto.PresetId);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ChangingTheCodecResetsCodecSpecificValues()
|
||||
{
|
||||
var resolved = ExportResolver.Resolve(Export("1080p-h264", new ExportOverrides { Codec = "HEVC" }));
|
||||
Assert.Equal(VideoCodec.Hevc, resolved.Codec);
|
||||
Assert.Equal(CodecProfile.Auto, resolved.Profile);
|
||||
Assert.Equal((long)Math.Round(0.07 * 1920 * 1080 * 30), resolved.EffectiveBitRate(1920, 1080));
|
||||
Assert.True(resolved.IsCustom);
|
||||
Assert.True(ExportResolver.TryParseCodec("TIFF-16", out var tiff) && tiff == VideoCodec.Tiff16Sequence);
|
||||
Assert.False(ExportResolver.TryParseCodec("", out _));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void FrameRateTextRoundTrips()
|
||||
{
|
||||
Assert.True(FrameRateText.TryParse("30000/1001", out var ntsc));
|
||||
Assert.Equal(Rational.Fps2997, ntsc);
|
||||
Assert.True(FrameRateText.TryParse("29.97", out var decimalNtsc));
|
||||
Assert.Equal(Rational.Fps2997, decimalNtsc);
|
||||
Assert.True(FrameRateText.TryParse(" 25 ", out var pal));
|
||||
Assert.Equal("25", FrameRateText.Format(pal));
|
||||
Assert.Equal("24000/1001", FrameRateText.Format(Rational.Fps23976));
|
||||
Assert.True(FrameRateText.AreEqual(new Rational(48000, 2002), Rational.Fps23976));
|
||||
Assert.False(FrameRateText.TryParse("0", out _));
|
||||
Assert.False(FrameRateText.TryParse("1/0", out _));
|
||||
Assert.False(FrameRateText.TryParse(null, out _));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user