From 429dbcc3d84ecc2a55873d4e42b54c2a3660c4b9 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Wed, 4 Nov 2026 19:19:12 +0100 Subject: [PATCH] feat(color): implement the built-in colour looks and their self-test check The seven looks (mono, sepia, warm, cool, vivid, muted, fade) are now real: a linear-light 3x3 matrix built from Rec.709 luminance (saturation mixed as (1 - k)L + kI, tint gains normalised to luminance 1), a contrast power about mid grey 0.18 and a lift, blended by strength, never clamped so the knee that follows compresses any overshoot. The kernel is vectorised with Vector and runs the last pixels through the same kernel, padded, so a pixel's result does not depend on its position; large frames split across cores like the exposure processor. A double-precision scalar reference backs the tests. The self-test gains proc.look (mono renders grey at the picture's luminance; an unknown look is ignored with Export.Render.LookIgnored). New tests cover the closed form per look, mono luminance, the strength midpoint, identity byte-equality, look-then-knee order, the render capture against FrameFinish, a median stack with mono and PNG determinism. Co-Authored-By: Claude Opus 5.5 --- src/Chronos.Core/Imaging/Color/LookFilter.cs | 199 ++++++++++++++- .../Diagnostics/SelfTestColourChecks.cs | 32 ++- .../Imaging/LookFilterTests.cs | 230 ++++++++++++++++++ .../Render/LookRenderTests.cs | 82 +++++++ 4 files changed, 537 insertions(+), 6 deletions(-) create mode 100644 tests/Chronos.Core.Tests/Imaging/LookFilterTests.cs create mode 100644 tests/Chronos.Core.Tests/Render/LookRenderTests.cs diff --git a/src/Chronos.Core/Imaging/Color/LookFilter.cs b/src/Chronos.Core/Imaging/Color/LookFilter.cs index 3efc98e2..7534dda7 100644 --- a/src/Chronos.Core/Imaging/Color/LookFilter.cs +++ b/src/Chronos.Core/Imaging/Color/LookFilter.cs @@ -1,3 +1,6 @@ +using System.Numerics; +using System.Runtime.InteropServices; + namespace Chronos.Core.Imaging.Color; /// @@ -6,26 +9,212 @@ namespace Chronos.Core.Imaging.Color; /// strength; values are never clamped (the highlight knee that follows compresses any overshoot). Applied to output /// frames only (), never seen by measuring, flow or stacking. /// +/// +/// Per pixel, with c the linear RGB value and s the strength: m = M·c; p = 0.18·(m / 0.18)^γ for each channel above 0 +/// (others kept as they are); q = lift + (1 − lift)·p; result c + s·(q − c). The matrices are built from the Rec.709 +/// luminance () and keep it: a saturation k mixes the luminance and the colour as +/// (1 − k)·L + k·I, and a tint scales the rows by gains whose luminance is 1. Mid grey (0.18) is the contrast's pivot. +/// public static class LookFilter { /// The identity look's name. public const string None = "none"; + /// The contrast power's pivot: mid grey in linear light, kept by every contrast. + public const double Pivot = 0.18; + + private const int ParallelThreshold = 1 << 20; + private const int Chunk = 1 << 16; + /// Every look this Chronos renders, in the order the editor lists them; names are lower case. public static IReadOnlyList Names { get; } = [None, "mono", "sepia", "warm", "cool", "vivid", "muted", "fade"]; + private static readonly LookDefinition[] Definitions = + [ + Saturated("mono", 0, 1, 0), + Tinted("sepia", 1.30, 0.97, 0.62, 0, 1.05, 0), + Tinted("warm", 1.10, 1.00, 0.86, 1.05, 1, 0), + Tinted("cool", 0.90, 1.00, 1.14, 1, 1, 0), + Saturated("vivid", 1.35, 1.12, 0), + Saturated("muted", 0.6, 0.92, 0), + Saturated("fade", 0.8, 0.85, 0.025), + ]; + /// A name this Chronos renders: null (none) or one of (ordinal, case-sensitive). public static bool IsKnown(string? name) => name is null || Names.Contains(name, StringComparer.Ordinal); /// - /// Applies the look at (0..1) to the colour planes of a - /// linear-light in place; a fourth (alpha) channel is left untouched. None, an unknown name and - /// a strength of 0 leave the image as it is. + /// Applies the look at (0..1, above 1 read as 1) to the colour + /// planes of a linear-light in place; a fourth (alpha) channel is left untouched, and so is a + /// single-channel image. None, an unknown name and a strength of 0 (or not a number) leave the image as it is. + /// Vectorised with (the last pixels too, padded, so a pixel's result never depends on where it + /// lies); large images are split across cores. /// public static void Apply(ImageBuffer image, string? filter, double strength) { ArgumentNullException.ThrowIfNull(image); - if (filter is null or None || !(strength > 0) || !IsKnown(filter)) return; - // Every look renders as the identity until the looks are implemented. + if (filter is null or None || !(strength > 0) || image.Channels < 3 || Definition(filter) is not { } look) return; + var kernel = new Kernel(look, Math.Min(strength, 1)); + ForChunks(image.PlaneLength, (start, length) => + kernel.Run(image.Plane(0).Slice(start, length), image.Plane(1).Slice(start, length), image.Plane(2).Slice(start, length))); + } + + /// + /// Scalar reference of for one linear RGB value, worked out in double + /// precision; none, an unknown name and a strength of 0 return the value as it is. + /// + public static (float R, float G, float B) Apply(string? filter, double strength, float r, float g, float b) + { + if (filter is null or None || !(strength > 0) || Definition(filter) is not { } look) return (r, g, b); + var s = Math.Min(strength, 1); + var m = look.Matrix; + double[] c = [r, g, b]; + var result = new float[3]; + for (var i = 0; i < 3; i++) + { + var v = m[3 * i] * c[0] + m[3 * i + 1] * c[1] + m[3 * i + 2] * c[2]; + if (v > 0 && look.Contrast != 1) v = Pivot * Math.Pow(v / Pivot, look.Contrast); + v = look.Lift + (1 - look.Lift) * v; + result[i] = (float)(c[i] + s * (v - c[i])); + } + return (result[0], result[1], result[2]); + } + + /// The parameters of a look this Chronos renders other than none; null for none or an unknown name. + internal static LookDefinition? Definition(string? name) + { + foreach (var look in Definitions) + { + if (string.Equals(look.Name, name, StringComparison.Ordinal)) return look; + } + return null; + } + + /// A look that changes the saturation by (0 = grey, 1 = as it is). + private static LookDefinition Saturated(string name, double saturation, double contrast, double lift) => + Tinted(name, 1, 1, 1, saturation, contrast, lift); + + /// A saturation followed by channel gains, scaled so that their luminance is 1 (the look keeps luminance). + private static LookDefinition Tinted(string name, double red, double green, double blue, double saturation, double contrast, double lift) + { + double[] luma = [ColorSpace.LumaR, ColorSpace.LumaG, ColorSpace.LumaB]; + var norm = luma[0] * red + luma[1] * green + luma[2] * blue; + double[] gains = [red / norm, green / norm, blue / norm]; + var matrix = new double[9]; + for (var i = 0; i < 3; i++) + { + for (var j = 0; j < 3; j++) matrix[3 * i + j] = gains[i] * ((1 - saturation) * luma[j] + (i == j ? saturation : 0)); + } + return new LookDefinition(name, matrix, contrast, lift); + } + + private static void ForChunks(int length, Action body) + { + if (length < ParallelThreshold) + { + body(0, length); + return; + } + var chunks = (length + Chunk - 1) / Chunk; + Parallel.For(0, chunks, i => + { + var start = i * Chunk; + body(start, Math.Min(Chunk, length - start)); + }); + } + + /// A look's coefficients in single precision, broadcast for the vector kernel. + private sealed class Kernel + { + private readonly Vector[] _matrix = new Vector[9]; + private readonly bool _contrast; + private readonly Vector _gamma; + private readonly Vector _offset; + private readonly bool _lift; + private readonly Vector _liftScale; + private readonly Vector _liftOffset; + private readonly bool _blend; + private readonly Vector _strength; + + public Kernel(LookDefinition look, double strength) + { + for (var i = 0; i < 9; i++) _matrix[i] = new Vector((float)look.Matrix[i]); + _contrast = look.Contrast != 1; + // 0.18·(v / 0.18)^γ = exp(γ·ln v + (1 − γ)·ln 0.18). + _gamma = new Vector((float)look.Contrast); + _offset = new Vector((float)((1 - look.Contrast) * Math.Log(Pivot))); + _lift = look.Lift != 0; + _liftScale = new Vector((float)(1 - look.Lift)); + _liftOffset = new Vector((float)look.Lift); + _blend = strength < 1; + _strength = new Vector((float)strength); + } + + public void Run(Span r, Span g, Span b) + { + var vr = MemoryMarshal.Cast>(r); + var vg = MemoryMarshal.Cast>(g); + var vb = MemoryMarshal.Cast>(b); + for (var i = 0; i < vr.Length; i++) Map(ref vr[i], ref vg[i], ref vb[i]); + var done = vr.Length * Vector.Count; + var rest = r.Length - done; + if (rest == 0) return; + // The last pixels go through the same kernel, padded with zeros, so they match the vectorised ones exactly. + var count = Vector.Count; + Span pad = stackalloc float[3 * count]; + pad.Clear(); + r[done..].CopyTo(pad); + g[done..].CopyTo(pad[count..]); + b[done..].CopyTo(pad[(2 * count)..]); + var tr = new Vector(pad[..count]); + var tg = new Vector(pad.Slice(count, count)); + var tb = new Vector(pad.Slice(2 * count, count)); + Map(ref tr, ref tg, ref tb); + tr.CopyTo(pad); + tg.CopyTo(pad[count..]); + tb.CopyTo(pad[(2 * count)..]); + pad[..rest].CopyTo(r[done..]); + pad.Slice(count, rest).CopyTo(g[done..]); + pad.Slice(2 * count, rest).CopyTo(b[done..]); + } + + private void Map(ref Vector r, ref Vector g, ref Vector b) + { + var m = _matrix; + var nr = m[0] * r + m[1] * g + m[2] * b; + var ng = m[3] * r + m[4] * g + m[5] * b; + var nb = m[6] * r + m[7] * g + m[8] * b; + if (_contrast) + { + nr = Power(nr); + ng = Power(ng); + nb = Power(nb); + } + if (_lift) + { + nr = nr * _liftScale + _liftOffset; + ng = ng * _liftScale + _liftOffset; + nb = nb * _liftScale + _liftOffset; + } + if (_blend) + { + nr = r + _strength * (nr - r); + ng = g + _strength * (ng - g); + nb = b + _strength * (nb - b); + } + r = nr; + g = ng; + b = nb; + } + + /// The contrast power for values above 0; zero, negative and NaN values are kept as they are. + private Vector Power(Vector v) => + Vector.ConditionalSelect(Vector.GreaterThan(v, Vector.Zero), Vector.Exp(_gamma * Vector.Log(v) + _offset), v); } } + +/// +/// One built-in look (): a row-major linear-light 3×3 , the contrast power +/// about (1 = none) and the of black. +/// +internal sealed record LookDefinition(string Name, IReadOnlyList Matrix, double Contrast, double Lift); diff --git a/src/Chronos.Core/Render/Diagnostics/SelfTestColourChecks.cs b/src/Chronos.Core/Render/Diagnostics/SelfTestColourChecks.cs index d8f4761d..ba7f42c3 100644 --- a/src/Chronos.Core/Render/Diagnostics/SelfTestColourChecks.cs +++ b/src/Chronos.Core/Render/Diagnostics/SelfTestColourChecks.cs @@ -1,7 +1,37 @@ +using Chronos.Core.Imaging; +using Chronos.Core.Project; + namespace Chronos.Core.Render.Diagnostics; /// Colour look checks (owner review 1, R6). public static partial class SelfTest { - private static IEnumerable ColourChecks() => []; + private static IEnumerable ColourChecks() + { + yield return Check("proc.look", "The mono look renders grey at the picture's luminance and an unknown look renders nothing", async context => + { + var source = Synthetic(2); + var plain = await RenderDecodedAsync(context, Input(source), name: "plain").ConfigureAwait(false); + var mono = await RenderDecodedAsync(context, Input(source, Plain with { Look = new LookSettings { Filter = "mono" } }), name: "mono").ConfigureAwait(false); + double grey = 0, luminance = 0; + var compared = 0; + for (var i = 0; i < plain[1].PlaneLength; i++) + { + var (r, g, b) = (mono[1].Plane(0)[i], mono[1].Plane(1)[i], mono[1].Plane(2)[i]); + grey = double.Max(grey, double.Max(double.Abs(r - g), double.Abs(g - b))); + var (pr, pg, pb) = (plain[1].Plane(0)[i], plain[1].Plane(1)[i], plain[1].Plane(2)[i]); + // Clipped highlights lose the luminance the look kept: only values the PNG holds are compared. + if (float.Max(pr, float.Max(pg, pb)) > 0.95f) continue; + luminance = double.Max(luminance, double.Abs(ColorSpace.Luminance(pr, pg, pb) - r)); + compared++; + } + DisposeAll(plain); + DisposeAll(mono); + var warnings = new List(); + var unknown = FrameFinish.Look(new LookSettings { Filter = "technicolor" }, warnings); + Require(grey == 0 && compared > 0 && luminance < 1e-3, Invariant($"mono channel spread {grey:0.######}, luminance error {luminance:0.######} over {compared} pixels")); + Require(unknown is null && warnings.Count == 1 && warnings[0].Key == "Export.Render.LookIgnored", "an unknown look is not ignored with a warning"); + return Invariant($"luminance error {luminance:0.######}"); + }); + } } diff --git a/tests/Chronos.Core.Tests/Imaging/LookFilterTests.cs b/tests/Chronos.Core.Tests/Imaging/LookFilterTests.cs new file mode 100644 index 00000000..e2fe0e6d --- /dev/null +++ b/tests/Chronos.Core.Tests/Imaging/LookFilterTests.cs @@ -0,0 +1,230 @@ +using System.Numerics; +using Chronos.Core.Analysis; +using Chronos.Core.Imaging; +using Chronos.Core.Imaging.Color; +using Chronos.Core.Project; +using Chronos.Core.Render; +using Chronos.Testing; + +namespace Chronos.Core.Tests.Imaging; + +public sealed class LookFilterTests +{ + /// Flat linear patches: black, shadows, mid grey, white, highlights above 1, saturated colours and a negative channel. + private static readonly (float R, float G, float B)[] Patches = + [ + (0, 0, 0), (0.001f, 0.002f, 0.0005f), (0.05f, 0.04f, 0.03f), (0.18f, 0.18f, 0.18f), (0.5f, 0.25f, 0.1f), (1, 1, 1), (1.4f, 1.2f, 0.9f), + (0.9f, 0.1f, 0.05f), (0.05f, 0.6f, 0.1f), (0.1f, 0.2f, 0.8f), (0.3f, -0.01f, 0.2f), (2.5f, 0.3f, 0.02f), + ]; + + /// One row of every patch, repeated so the row is not a whole number of vectors (the padded tail runs too). + private static ImageBuffer PatchImage(int channels = 3, int repeats = 3) + { + var width = Patches.Length * repeats + 1; + Assert.NotEqual(0, width % Vector.Count); + var image = new ImageBuffer(width, 2, channels); + for (var y = 0; y < 2; y++) + { + for (var x = 0; x < width; x++) + { + var (r, g, b) = Patches[x % Patches.Length]; + (image[0, x, y], image[1, x, y], image[2, x, y]) = (r, g, b); + if (channels == 4) image[3, x, y] = 0.25f + x * 0.01f; + } + } + return image; + } + + /// The closed form of a look: m = M·c, p = 0.18·(m / 0.18)^γ above 0, q = lift + (1 − lift)·p, c + s·(q − c). + private static double[] ClosedForm(string name, double strength, double r, double g, double b) + { + var look = LookFilter.Definition(name)!; + var m = look.Matrix; + double[] c = [r, g, b]; + var result = new double[3]; + for (var i = 0; i < 3; i++) + { + var v = m[3 * i] * r + m[3 * i + 1] * g + m[3 * i + 2] * b; + if (v > 0) v = 0.18 * Math.Pow(v / 0.18, look.Contrast); + v = look.Lift + (1 - look.Lift) * v; + result[i] = c[i] + strength * (v - c[i]); + } + return result; + } + + private static void Near(double expected, double actual, string message) => + Assert.Approximately(expected, actual, 1e-6 * Math.Max(1, Math.Abs(expected)), message); + + private static IEnumerable Looks => LookFilter.Names.Where(n => n != LookFilter.None); + + [Test] + public void NamesAreKnownOrdinallyAndEachLookIsDefined() + { + Assert.Equal(8, LookFilter.Names.Count); + Assert.True(LookFilter.IsKnown(null)); + Assert.True(LookFilter.Names.All(LookFilter.IsKnown)); + Assert.False(LookFilter.IsKnown("Mono")); + Assert.False(LookFilter.IsKnown("technicolor")); + Assert.Null(LookFilter.Definition(LookFilter.None)); + foreach (var name in Looks) + { + var look = LookFilter.Definition(name); + Assert.NotNull(look); + Assert.Equal(9, look!.Matrix.Count); + Assert.True(look.Matrix.All(double.IsFinite) && look.Contrast > 0 && look.Lift is >= 0 and < 0.1, name); + } + } + + [Test] + public void TheIdentityANullLookAndStrengthZeroLeaveThePictureByteEqual() + { + using var original = PatchImage(channels: 4); + foreach (var (filter, strength) in new (string?, double)[] { (null, 1), (LookFilter.None, 1), ("vivid", 0), ("vivid", -1), ("vivid", double.NaN), ("technicolor", 1) }) + { + using var image = original.Clone(); + LookFilter.Apply(image, filter, strength); + Assert.True(image.Data.SequenceEqual(original.Data), $"{filter} at {strength}"); + Assert.Equal((0.5f, 0.25f, 0.1f), LookFilter.Apply(filter, strength, 0.5f, 0.25f, 0.1f)); + } + LookSettings?[] identities = [null, new LookSettings(), new LookSettings { Filter = LookFilter.None }, new LookSettings { Filter = "sepia", Strength = 0 }, + new LookSettings { Filter = "technicolor" }]; + foreach (var look in identities) + { + using var image = original.Clone(); + FrameFinish.Apply(image, look, null); + Assert.True(image.Data.SequenceEqual(original.Data), look?.ToString()); + Assert.True(FrameFinish.IsIdentity(look, null), look?.ToString()); + } + } + + [Theory] + [Case("mono")] + [Case("sepia")] + [Case("warm")] + [Case("cool")] + [Case("vivid")] + [Case("muted")] + [Case("fade")] + public void EachLookMatchesItsClosedFormScalarAndVectorised(string name) + { + foreach (var strength in new[] { 1, 0.5, 0.3 }) + { + using var image = PatchImage(); + LookFilter.Apply(image, name, strength); + for (var x = 0; x < image.Width; x++) + { + var (r, g, b) = Patches[x % Patches.Length]; + var expected = ClosedForm(name, strength, r, g, b); + var scalar = LookFilter.Apply(name, strength, r, g, b); + double[] reference = [scalar.R, scalar.G, scalar.B]; + for (var c = 0; c < 3; c++) + { + var label = $"{name} at {strength}, patch {x % Patches.Length}, channel {c}"; + Near(expected[c], reference[c], "scalar " + label); + Near(expected[c], image[c, x, 1], "vectorised " + label); + } + } + } + } + + [Test] + public void MonoIsTheRec709Luminance() + { + using var image = PatchImage(); + LookFilter.Apply(image, "mono", 1); + for (var x = 0; x < image.Width; x++) + { + var (r, g, b) = Patches[x % Patches.Length]; + Assert.Equal(image[0, x, 0], image[1, x, 0]); + Assert.Equal(image[1, x, 0], image[2, x, 0]); + Near(ColorSpace.Luminance(r, g, b), image[0, x, 0], $"patch {x % Patches.Length}"); + } + } + + [Test] + public void HalfStrengthIsTheMidpoint() + { + foreach (var name in Looks) + { + using var full = PatchImage(); + using var half = PatchImage(); + using var original = PatchImage(); + LookFilter.Apply(full, name, 1); + LookFilter.Apply(half, name, 0.5); + for (var i = 0; i < original.Data.Length; i++) + Near((original.Data[i] + (double)full.Data[i]) / 2, half.Data[i], $"{name} sample {i}"); + } + } + + [Test] + public void AStrengthAboveOneIsOne() + { + using var one = PatchImage(); + using var more = PatchImage(); + LookFilter.Apply(one, "fade", 1); + LookFilter.Apply(more, "fade", 3); + Assert.True(one.Data.SequenceEqual(more.Data)); + } + + [Test] + public void AlphaAndSingleChannelPicturesAreLeftAlone() + { + using var original = PatchImage(channels: 4); + using var image = original.Clone(); + LookFilter.Apply(image, "sepia", 1); + Assert.True(image.Plane(3).SequenceEqual(original.Plane(3))); + Assert.False(image.Plane(0).SequenceEqual(original.Plane(0))); + + using var grey = new ImageBuffer(5, 1, 1); + grey.Data.Fill(0.4f); + LookFilter.Apply(grey, "fade", 1); + Assert.True(grey.Data.ToArray().All(v => v == 0.4f)); + } + + [Test] + public void ValuesAboveOneAreKeptThenTheKneeIsApplied() + { + using var looked = PatchImage(); + LookFilter.Apply(looked, "vivid", 1); + Assert.Greater(looked.Data.ToArray().Max(), 1.5); + + var look = new LookSettings { Filter = "vivid" }; + using var finished = PatchImage(); + FrameFinish.Apply(finished, look, 0.8); + using var expected = looked.Clone(); + ExposureProcessor.Apply(expected, 0, null, 0.8); + Assert.True(finished.Data.SequenceEqual(expected.Data)); + Assert.Less(finished.Data.ToArray().Max(), 1); + } + + [Test] + public void APixelsResultDoesNotDependOnWhereItLies() + { + // Over 2^20 pixels the planes are split across cores; the row of a small picture must come out the same. + using var small = PatchImage(repeats: 1); + using var large = new ImageBuffer(small.Width, (1 << 20) / small.Width + 3); + for (var c = 0; c < 3; c++) + { + for (var y = 0; y < large.Height; y++) small.Row(c, 0).CopyTo(large.Row(c, y)); + } + LookFilter.Apply(small, "fade", 0.7); + LookFilter.Apply(large, "fade", 0.7); + for (var c = 0; c < 3; c++) + { + for (var y = 0; y < large.Height; y += 997) Assert.True(large.Row(c, y).SequenceEqual(small.Row(c, 0)), $"channel {c}, row {y}"); + Assert.True(large.Row(c, large.Height - 1).SequenceEqual(small.Row(c, 0)), $"channel {c}, last row"); + } + } + + [Test] + public void AnUnknownLookIsIgnoredWithAWarning() + { + var warnings = new List(); + Assert.Null(FrameFinish.Look(new LookSettings { Filter = "technicolor", Strength = 0.5 }, warnings)); + Assert.Equal("Export.Render.LookIgnored(technicolor)", warnings.Single().ToString()); + warnings.Clear(); + Assert.Null(FrameFinish.Look(new LookSettings { Filter = LookFilter.None }, warnings)); + Assert.NotNull(FrameFinish.Look(new LookSettings { Filter = "warm" }, warnings)); + Assert.Empty(warnings); + } +} diff --git a/tests/Chronos.Core.Tests/Render/LookRenderTests.cs b/tests/Chronos.Core.Tests/Render/LookRenderTests.cs new file mode 100644 index 00000000..6d43dabc --- /dev/null +++ b/tests/Chronos.Core.Tests/Render/LookRenderTests.cs @@ -0,0 +1,82 @@ +using Chronos.Core.Imaging; +using Chronos.Core.Imaging.Color; +using Chronos.Core.Project; +using Chronos.Core.Render; +using Chronos.Testing; +using static Chronos.Core.Tests.Render.RenderFixture; + +namespace Chronos.Core.Tests.Render; + +/// The colour look in renders (owner review 1, R6): once per output frame, after stacking, before the knee. +public sealed class LookRenderTests(TestContext context) +{ + private static ProjectSettings With(LookSettings? look, double? knee = null, StackSettings? stack = null) => + Plain with { Look = look, Exposure = new ExposureSettings { HighlightKnee = knee }, Stack = stack ?? new StackSettings() }; + + private static void SameFrames(IReadOnlyList expected, IReadOnlyList actual) + { + Assert.Equal(expected.Count, actual.Count); + for (var i = 0; i < expected.Count; i++) Assert.True(expected[i].Data.SequenceEqual(actual[i].Data), $"frame {i}"); + } + + [Test] + public async Task TheIdentityLooksRenderTheSameBytesAsNoLook() + { + var (plain, _) = await CaptureAsync(Input(Source(4), With(null)), cancellationToken: context.Cancellation); + foreach (var look in new[] { new LookSettings { Filter = LookFilter.None }, new LookSettings { Filter = "vivid", Strength = 0 } }) + { + var (encode, result) = await CaptureAsync(Input(Source(4), With(look)), cancellationToken: context.Cancellation); + SameFrames(plain.Frames, encode.Frames); + Assert.Empty(result.Warnings); + } + } + + [Test] + public async Task AnUnknownLookRendersAsNoneWithAWarning() + { + var (plain, _) = await CaptureAsync(Input(Source(4), With(null)), cancellationToken: context.Cancellation); + var (encode, result) = await CaptureAsync(Input(Source(4), With(new LookSettings { Filter = "technicolor" })), cancellationToken: context.Cancellation); + SameFrames(plain.Frames, encode.Frames); + Assert.Contains(result.Warnings, w => w.Key == "Export.Render.LookIgnored" && w.Args.SequenceEqual(["technicolor"])); + } + + [Test] + public async Task ACaptureWithALookIsTheFinishOfThePlainCapture() + { + // The look comes before the knee: the plain render has no knee, so the finish adds both in its own order. + var look = new LookSettings { Filter = "sepia", Strength = 0.7 }; + var source = Source(6, configure: o => o with { StartEv = 1, EndEv = 2 }); + var (plain, _) = await CaptureAsync(Input(source, With(null)), cancellationToken: context.Cancellation); + var (encode, result) = await CaptureAsync(Input(source, With(look, knee: 0.85)), cancellationToken: context.Cancellation); + Assert.Empty(result.Warnings); + foreach (var frame in plain.Frames) FrameFinish.Apply(frame, look, 0.85); + SameFrames(plain.Frames, encode.Frames); + Assert.Less(encode.Frames.Max(f => f.Data.ToArray().Max()), 1); + } + + [Test] + public async Task AMedianStackWithMonoIsMonoOfTheMedian() + { + var stack = new StackSettings { Mode = StackSetting.Median, Length = 5 }; + var source = Source(9, motion: i => (0.5 * i, 0)); + var (median, _) = await CaptureAsync(Input(source, With(null, stack: stack)), cancellationToken: context.Cancellation); + var (mono, _) = await CaptureAsync(Input(source, With(new LookSettings { Filter = "mono" }, stack: stack)), cancellationToken: context.Cancellation); + foreach (var frame in median.Frames) LookFilter.Apply(frame, "mono", 1); + SameFrames(median.Frames, mono.Frames); + Assert.True(mono.Frames.All(f => f.Plane(0).SequenceEqual(f.Plane(1)) && f.Plane(1).SequenceEqual(f.Plane(2)))); + } + + [Test] + public async Task PngOutputWithALookIsByteIdenticalAcrossRuns() + { + var dir = context.CreateTempDirectory(); + var project = With(new LookSettings { Filter = "fade", Strength = 0.8 }, knee: 0.9); + var first = await Pipeline().RenderAsync(Input(Source(5), project), Target(dir, Preset("png-sequence") with { BitDepth = 16 }, "a"), cancellationToken: context.Cancellation); + var second = await Pipeline().RenderAsync(Input(Source(5), project), Target(dir, Preset("png-sequence") with { BitDepth = 16 }, "b"), cancellationToken: context.Cancellation); + var a = Directory.GetFiles(first.OutputPath).Order(StringComparer.Ordinal).ToArray(); + var b = Directory.GetFiles(second.OutputPath).Order(StringComparer.Ordinal).ToArray(); + Assert.Equal(5, a.Length); + Assert.Equal(a.Length, b.Length); + for (var i = 0; i < a.Length; i++) Assert.BytesEqual(File.ReadAllBytes(a[i]), File.ReadAllBytes(b[i])); + } +}