CI / Build and test (push) Successful in 8m19s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 12m9s
CI / PostgreSQL 16 integration (push) Successful in 7m49s
CI / PostgreSQL 17 integration (push) Successful in 7m19s
CI / Docker image (push) Successful in 46s
Release / Server image (push) Successful in 1m14s
Owner review 1 R5 + R6. Camera rotation, mirror, flip, straighten and crop handles locked to the output; an Exposure Look group; Export output size ("proportions win"); settings format 2 with older-node gates. Also fixes project text and hashes differing between Windows and Linux.
Closes #19
Closes #20
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.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");
|
||
}
|
||
}
|