Routing sizes render jobs from the resolved preset, and the node wait applies the same routing as the claim, so a re-routed job neither keeps a stale size nor waits for a node that will never take it. Settings an older server cannot read stay on this side for the remote editor, archive sync and workspace push, and the reason is shown where it applies. A turn on one side and a framing on the other merge as one conflict. Orientation and framing fixes: an out-of-range crop turns with the content it shows, the aspect text transposes exactly, the Rotation row counts turns as shown on screen, and Reset framing undoes the orientation press by press, so keyframes and aspect stay on their content. The advisor places the horizon in the view as shown. A look at zero strength is cleared and no longer reaches the motion vectors. Preview changes: the middle button pans, a press inside a box with no slack pans while zoomed, the selected box shows a ring, and screen readers hear when the crop value changes. Tooltips in en and it updated; stale translations of changed tooltips removed so they fall back to English. Test changes: the pinned hash is OS-independent, and the tautological encoder and warning assertions became real checks. Added a non-screen test of the Straighten slider binding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
302 lines
14 KiB
C#
302 lines
14 KiB
C#
using Chronos.Core.Export;
|
||
using Chronos.Core.Imaging;
|
||
using Chronos.Core.Video;
|
||
using Chronos.Core.Windows.MediaFoundation;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.Core.Windows.Tests.MediaFoundation;
|
||
|
||
[Serial] // encoders share GPU sessions and the MF runtime
|
||
public sealed class MediaFoundationEncoderTests(TestContext context)
|
||
{
|
||
private const long Frame30 = 3000; // 1/30 s at 90 kHz
|
||
|
||
[Test]
|
||
public void VendorIdsMapToNames()
|
||
{
|
||
Assert.Equal("NVIDIA", MediaFoundationEncoderProvider.VendorName("VEN_10DE"));
|
||
Assert.Equal("Intel", MediaFoundationEncoderProvider.VendorName("ven_8086"));
|
||
Assert.Equal("AMD", MediaFoundationEncoderProvider.VendorName("VEN_1002"));
|
||
Assert.Equal("VEN_ABCD", MediaFoundationEncoderProvider.VendorName("VEN_ABCD"));
|
||
Assert.Null(MediaFoundationEncoderProvider.VendorName(null));
|
||
}
|
||
|
||
[Test]
|
||
[WindowsOnly]
|
||
public void EnumeratesEncodersAndHidesSoftwareHevcAndAv1()
|
||
{
|
||
RequireMediaFoundation();
|
||
var encoders = MediaFoundationEncoders.Enumerate();
|
||
foreach (var e in encoders) context.Log($"{e.Codec} \"{e.Name}\" hardware={e.IsHardware} async={e.IsAsync} vendor={e.VendorId} 10-bit={e.SupportsTenBit}");
|
||
Assert.True(encoders.All(e => !string.IsNullOrWhiteSpace(e.Name)));
|
||
|
||
var capabilities = new MediaFoundationEncoderProvider().Capabilities;
|
||
Assert.True(capabilities.All(c => c.Hardware || c.Codec == VideoCodec.H264), "HEVC/AV1 are hardware-only");
|
||
Assert.True(capabilities.All(c => !c.SupportsTenBit || c.Codec != VideoCodec.H264));
|
||
Assert.Equal(encoders.Count(e => e.IsHardware || e.Codec == VideoCodec.H264), capabilities.Count);
|
||
}
|
||
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(60_000)]
|
||
public void SoftwareH264EncodeProducesAValidMp4()
|
||
{
|
||
RequireEncoder(VideoCodec.H264, hardware: false, tenBit: false);
|
||
var dir = context.CreateTempDirectory();
|
||
var settings = Settings(Path.Combine(dir, "software.mp4"), VideoCodec.H264, 8) with { PreferHardware = false };
|
||
var provider = new MediaFoundationEncoderProvider();
|
||
Assert.True(provider.CanEncode(settings));
|
||
using (var session = provider.Open(settings))
|
||
{
|
||
Assert.False(session.IsHardware);
|
||
context.Log("encoder: " + session.EncoderName);
|
||
WriteFrames(session, 60, 8);
|
||
session.Complete();
|
||
}
|
||
|
||
var report = Mp4Inspector.Inspect(settings.OutputPath);
|
||
context.Log(report.ToString());
|
||
Assert.True(report.IsValid, string.Join("; ", report.Errors));
|
||
Assert.Equal(VideoCodec.H264, report.Codec);
|
||
Assert.Equal(1280, report.Width);
|
||
Assert.Equal(720, report.Height);
|
||
Assert.Equal(60, report.FrameCount);
|
||
Assert.Approximately(2.0, report.Duration.TotalSeconds, 0.034);
|
||
Assert.True(report.FastStart);
|
||
Assert.Count(1, Directory.GetFiles(dir)); // no temporary file left behind
|
||
}
|
||
|
||
/// <summary>
|
||
/// BRIEF §20.2: what the encoder writes plays in Windows. MediaPlayer (Windows Media Player's pipeline) opens it at
|
||
/// the encoded size and length. Where Windows Media Player is missing or unusable (Windows Server, "N" editions) the
|
||
/// test is skipped with that reason, and <see cref="SourceReaderDecodesTheSoftwareH264Output"/> is the check.
|
||
/// </summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(120_000)]
|
||
public void MediaPlayerOpensTheSoftwareH264Output()
|
||
{
|
||
RequireEncoder(VideoCodec.H264, hardware: false, tenBit: false);
|
||
RequireMediaPlayer();
|
||
var opened = OpenWithMediaPlayer(Encoded("playback.mp4", VideoCodec.H264, 8, hardware: false));
|
||
context.Log($"MediaPlayer: {opened}");
|
||
Assert.Equal(1280, opened.Width);
|
||
Assert.Equal(720, opened.Height);
|
||
Assert.Approximately(2.0, opened.Duration.TotalSeconds, 0.05);
|
||
}
|
||
|
||
/// <summary>
|
||
/// BRIEF §20.2: a Media Foundation source reader decodes the encoder's first frame to the picture that was encoded.
|
||
/// It needs no Windows Media Player, so it runs on every Windows with Media Foundation, Server editions included.
|
||
/// </summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(60_000)]
|
||
public void SourceReaderDecodesTheSoftwareH264Output()
|
||
{
|
||
RequireEncoder(VideoCodec.H264, hardware: false, tenBit: false);
|
||
var frame = Mp4Playback.DecodeFirstFrame(Encoded("decode.mp4", VideoCodec.H264, 8, hardware: false));
|
||
context.Log($"source reader: {frame.Width}×{frame.Height}, {frame.Duration}, luma square {frame.LumaAt(100, 360)}, corner {frame.LumaAt(4, 4)}");
|
||
Assert.Equal(1280, frame.Width);
|
||
Assert.Equal(720, frame.Height);
|
||
Assert.Approximately(2.0, frame.Duration.TotalSeconds, 0.05);
|
||
// Frame 0 as WriteFrames drew it: the white square centred at (100, 360) on a dark blue corner.
|
||
Assert.Greater(frame.LumaAt(100, 360), 200);
|
||
Assert.Less(frame.LumaAt(4, 4), 60);
|
||
}
|
||
|
||
/// <summary>The hardware HEVC Main10 output opens in MediaPlayer at its size and length, where Windows can decode HEVC.</summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(120_000)]
|
||
public void MediaPlayerOpensTheHardwareHevcMain10Output()
|
||
{
|
||
RequireEncoder(VideoCodec.Hevc, hardware: true, tenBit: true);
|
||
RequireMediaPlayer();
|
||
if (!Mp4Playback.HasDecoder(VideoCodec.Hevc)) TestContext.Skip("No HEVC decoder on this machine (HEVC Video Extensions)");
|
||
var opened = OpenWithMediaPlayer(Encoded("main10.mp4", VideoCodec.Hevc, 10, hardware: true));
|
||
context.Log($"MediaPlayer: {opened}");
|
||
Assert.Equal(1280, opened.Width);
|
||
Assert.Equal(720, opened.Height);
|
||
Assert.Approximately(2.0, opened.Duration.TotalSeconds, 0.05);
|
||
}
|
||
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(60_000)]
|
||
public void HardwareHevcMain10EncodeWhenAvailable()
|
||
{
|
||
RequireEncoder(VideoCodec.Hevc, hardware: true, tenBit: true);
|
||
var dir = context.CreateTempDirectory();
|
||
var settings = Settings(Path.Combine(dir, "main10.mp4"), VideoCodec.Hevc, 10);
|
||
using (var session = new MediaFoundationEncoderProvider().Open(settings))
|
||
{
|
||
Assert.True(session.IsHardware);
|
||
context.Log("encoder: " + session.EncoderName);
|
||
WriteFrames(session, 60, 10);
|
||
session.Complete();
|
||
}
|
||
var report = Mp4Inspector.Inspect(settings.OutputPath);
|
||
context.Log(report.ToString());
|
||
Assert.True(report.IsValid, string.Join("; ", report.Errors));
|
||
Assert.Equal(VideoCodec.Hevc, report.Codec);
|
||
Assert.Equal(10, report.BitDepth);
|
||
Assert.Equal(60, report.FrameCount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Owner review 1, phase 4: 4K at 9:16 is 2160×3840. Each H.264 encoder of this machine is asked for portrait UHD and
|
||
/// its landscape twin: none takes one and refuses the other, so the announced limits are a long edge × short edge
|
||
/// (<see cref="EncoderSelector.Takes"/>), and portrait UHD is announced wherever landscape UHD is. Encoders that refuse
|
||
/// both (Microsoft's DX12 encoder on some GPUs) are left to the provider, which then opens the next one.
|
||
/// </summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(180_000)]
|
||
public void PortraitUhdH264EncodesWhereLandscapeDoes()
|
||
{
|
||
RequireMediaFoundation();
|
||
var provider = new MediaFoundationEncoderProvider();
|
||
var h264 = provider.Capabilities.Where(c => c.Codec == VideoCodec.H264).ToList();
|
||
if (h264.Count == 0) TestContext.Skip("No H.264 encoder on this machine");
|
||
foreach (var capability in h264)
|
||
{
|
||
var (portrait, landscape) = (Accepts(capability, 2160, 3840), Accepts(capability, 3840, 2160));
|
||
Assert.Equal(landscape, portrait, $"{capability.Name} takes portrait UHD as it takes landscape UHD");
|
||
Assert.True(EncoderSelector.Takes(capability, 2160, 3840), $"{capability.Name} announces portrait UHD");
|
||
if (!capability.Hardware) Assert.False(EncoderSelector.Takes(capability, 2400, 3840), $"{capability.Name}: the short edge is over the software limit");
|
||
}
|
||
var request = Settings(Path.Combine(context.CreateTempDirectory(), "portrait.mp4"), VideoCodec.H264, 8);
|
||
Assert.Equal(provider.CanEncode(request with { Width = 3840, Height = 2160 }), provider.CanEncode(request with { Width = 2160, Height = 3840 }));
|
||
|
||
bool Accepts(EncoderCapability capability, int width, int height)
|
||
{
|
||
var settings = Settings(Path.Combine(context.CreateTempDirectory(), $"{width}x{height}.mp4"), VideoCodec.H264, 8) with
|
||
{
|
||
Width = width,
|
||
Height = height,
|
||
EncoderName = capability.Name,
|
||
PreferHardware = capability.Hardware,
|
||
BitRate = 20_000_000,
|
||
};
|
||
try
|
||
{
|
||
using (var session = provider.Open(settings))
|
||
{
|
||
using var frame = new ImageBuffer(width, height);
|
||
for (var c = 0; c < 3; c++) frame.Plane(c).Fill(0.25f);
|
||
for (var f = 0; f < 3; f++) session.WriteFrame(frame, Frame30);
|
||
session.Complete();
|
||
}
|
||
var report = Mp4Inspector.Inspect(settings.OutputPath);
|
||
context.Log($"{capability.Name} {width}×{height}: {report}");
|
||
return report.IsValid && (report.Width, report.Height) == (width, height);
|
||
}
|
||
catch (NotSupportedException ex)
|
||
{
|
||
context.Log($"{capability.Name} {width}×{height}: refused ({ex.InnerException?.Message ?? ex.Message})");
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
[Test]
|
||
[WindowsOnly]
|
||
[Timeout(60_000)]
|
||
public void DisposeWithoutCompleteLeavesNoFile()
|
||
{
|
||
RequireEncoder(VideoCodec.H264, hardware: false, tenBit: false);
|
||
var dir = context.CreateTempDirectory();
|
||
var settings = Settings(Path.Combine(dir, "cancelled.mp4"), VideoCodec.H264, 8) with { PreferHardware = false };
|
||
using (var session = new MediaFoundationEncoderProvider().Open(settings))
|
||
{
|
||
WriteFrames(session, 5, 8);
|
||
}
|
||
Assert.Empty(Directory.GetFiles(dir));
|
||
}
|
||
|
||
private static EncodeSettings Settings(string path, VideoCodec codec, int bitDepth) => new()
|
||
{
|
||
OutputPath = path,
|
||
Codec = codec,
|
||
Width = 1280,
|
||
Height = 720,
|
||
FrameRate = new Rational(30, 1),
|
||
BitDepth = bitDepth,
|
||
Profile = codec == VideoCodec.Hevc ? (bitDepth == 10 ? CodecProfile.HevcMain10 : CodecProfile.HevcMain) : CodecProfile.H264High,
|
||
BitRate = 4_000_000,
|
||
GopLength = 30,
|
||
};
|
||
|
||
/// <summary>A moving colour ramp with a bright square, distinct per frame.</summary>
|
||
private static void WriteFrames(IVideoEncoderSession session, int count, int bitDepth)
|
||
{
|
||
using var frame = new ImageBuffer(1280, 720);
|
||
for (var f = 0; f < count; f++)
|
||
{
|
||
for (var y = 0; y < 720; y++)
|
||
{
|
||
var r = frame.Row(0, y);
|
||
var g = frame.Row(1, y);
|
||
var b = frame.Row(2, y);
|
||
for (var x = 0; x < 1280; x++)
|
||
{
|
||
var square = Math.Abs(x - 100 - f * 15) < 60 && Math.Abs(y - 360) < 60;
|
||
r[x] = square ? 1f : (float)ColorSpace.SrgbToLinear((x + f * 7) % 1280 / 1280.0);
|
||
g[x] = square ? 1f : (float)ColorSpace.SrgbToLinear(y / 720.0);
|
||
b[x] = (float)ColorSpace.SrgbToLinear(bitDepth == 10 ? 0.5 + 0.4 * Math.Sin((x + y) * 0.01) : 0.3);
|
||
}
|
||
}
|
||
session.WriteFrame(frame, Frame30);
|
||
}
|
||
}
|
||
|
||
/// <summary>Two seconds of <see cref="WriteFrames"/> (60 frames at 30 fps, 1280×720) in a new temporary file.</summary>
|
||
private string Encoded(string name, VideoCodec codec, int bitDepth, bool hardware)
|
||
{
|
||
var settings = Settings(Path.Combine(context.CreateTempDirectory(), name), codec, bitDepth) with { PreferHardware = hardware };
|
||
using (var session = new MediaFoundationEncoderProvider().Open(settings))
|
||
{
|
||
Assert.Equal(hardware, session.IsHardware);
|
||
context.Log("encoder: " + session.EncoderName);
|
||
WriteFrames(session, 60, bitDepth);
|
||
session.Complete();
|
||
}
|
||
return settings.OutputPath;
|
||
}
|
||
|
||
/// <summary>
|
||
/// <see cref="Mp4Playback.OpenWithMediaPlayer"/>, skipped when WPF finds Windows Media Player present but unusable
|
||
/// (its <see cref="NotSupportedException"/>, "version 10 or later is required").
|
||
/// </summary>
|
||
private static Mp4Playback.Opened OpenWithMediaPlayer(string path)
|
||
{
|
||
try
|
||
{
|
||
return Mp4Playback.OpenWithMediaPlayer(path, TimeSpan.FromSeconds(60));
|
||
}
|
||
catch (NotSupportedException ex)
|
||
{
|
||
TestContext.Skip("Windows Media Player cannot be used: " + ex.Message);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
private static void RequireMediaPlayer()
|
||
{
|
||
if (!Mp4Playback.HasMediaPlayer) TestContext.Skip("Windows Media Player is not installed (Windows Server, \"N\" editions); the source reader test checks playback");
|
||
}
|
||
|
||
private static void RequireMediaFoundation()
|
||
{
|
||
if (!MediaFoundationRuntime.IsAvailable) TestContext.Skip("Media Foundation is not installed (Windows N or Server without Media Foundation)");
|
||
}
|
||
|
||
private static void RequireEncoder(VideoCodec codec, bool hardware, bool tenBit)
|
||
{
|
||
RequireMediaFoundation();
|
||
if (!MediaFoundationEncoders.Enumerate().Any(e => e.Codec == codec && e.IsHardware == hardware && (!tenBit || e.SupportsTenBit)))
|
||
TestContext.Skip($"No {(hardware ? "hardware" : "software")} {codec}{(tenBit ? " 10-bit" : string.Empty)} encoder on this machine");
|
||
}
|
||
}
|