Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.
C# audio-converteravaloniabatch-conversionconvertercsharpdocument-converterdocx-to-pdfdotnetdrag-and-dropfile-conversionfile-converterheic-converterhwphwpximage-converterlinuxmacospdf-convertervideo-converterwindows
// Video and audio with FFmpeg: routes, command-line choices (no FFmpeg needed) and real conversions, which run only
// when Filee's FFmpeg is installed (`pwsh build/fetch-engines.ps1 -Only ffmpeg`; CI does not install it). Inputs are
// generated by FFmpeg itself (test pattern + sine tone) and every output is checked with ffprobe.
using System.Buffers.Binary;
using System.Diagnostics;
using System.Globalization;
using System.Text;
using System.Text.Json;
using Filee.Core.Conversion;
using Filee.Core.Formats;
using Filee.Core.Presets;
using Filee.Engines.Infrastructure;
using Filee.Engines.Media;
namespace Filee.Engines.Tests;
/// <summary>
/// FFmpeg keeps every core busy: its tests run on their own, so timing-sensitive tests of other classes (progress
/// estimates) are not starved meanwhile.
/// </summary>
[CollectionDefinition(nameof(FfmpegCollection), DisableParallelization = true)]
public sealed class FfmpegCollection;
[Collection(nameof(FfmpegCollection))]
public class MediaTests(EngineFixture fx) : IClassFixture<EngineFixture>
{
[Fact]
public void Cri_usm_game_videos_go_to_mp4_through_ffmpeg()
{
// #485: read only, through FFmpeg's usm demuxer; never a step towards something else.
SkipUnlessInstalled();
var route = fx.Catalog.CreatePlanner().Plan("usm", "mp4");
Assert.NotNull(route);
Assert.Equal("ffmpeg", Assert.Single(route.Steps).Converter.Id);
Assert.Null(fx.Catalog.CreatePlanner().Plan("mp4", "usm"));
}
[Fact]
public void M4s_pieces_are_read_but_never_written()
{
// #354: a fragmented MP4 FFmpeg reads directly; never a target.
var route = Planner().Plan("m4s", "mp4");
Assert.NotNull(route);
Assert.Equal("ffmpeg", Assert.Single(route.Steps).Converter.Id);
Assert.Null(Planner().Plan("mp4", "m4s"));
}
[Fact]
public void Dav_recordings_are_read_but_never_written()
{
// #594: Dahua DVR recordings, read by FFmpeg's dhav demuxer; never a target.
var route = Planner().Plan("dav", "mp4");
Assert.NotNull(route);
Assert.Equal("ffmpeg", Assert.Single(route.Steps).Converter.Id);
Assert.Null(Planner().Plan("mp4", "dav"));
}
[Fact]
public async Task A_dahua_dav_recording_converts_to_mp4()
{
// FFmpeg has no DHAV muxer, so the recording is put together here the way Dahua cameras write it: H.264 frames
// and G.711 A-law sound in DHAV chunks.
SkipUnlessInstalled();
var folder = fx.NewFolder();
var h264 = await MakeClipAsync(folder, "camera.h264", size: "160x120", audio: false,
extra: ["-c:v", "libx264", "-g", "25", "-bsf:v", "h264_metadata=aud=insert"]);
var alaw = Path.Combine(folder, "camera.alaw");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi",
"-i", "sine=frequency=440:sample_rate=8000:duration=2", "-ac", "1", "-f", "alaw", alaw]);
var dav = Path.Combine(folder, "ch01_main.dav");
await File.WriteAllBytesAsync(dav, Dhav.Recording(await File.ReadAllBytesAsync(h264, TestContext.Current.CancellationToken),
await File.ReadAllBytesAsync(alaw, TestContext.Current.CancellationToken), 160, 120), TestContext.Current.CancellationToken);
var probe = await ProcessRunner.RunAsync(Tools!.Value.Ffprobe, ["-v", "error", "-show_entries", "format=format_name", "-of", "csv=p=0", dav],
TimeSpan.FromMinutes(1), CancellationToken.None);
Assert.Equal("dhav", probe.StandardOutput.Trim());
var probed = await ProbeAsync(await ConvertAsync(dav, "mp4"));
var video = probed.Video;
Assert.NotNull(video);
Assert.Equal(("h264", 160, 120, 50), (video.Codec, video.Width, video.Height, video.Frames));
Assert.Equal("aac", probed.Audio?.Codec);
Assert.InRange(probed.Duration, 1.7, 2.4);
}
/// <summary>Dahua's DHAV container, as far as FFmpeg's dhav demuxer reads it.</summary>
private static class Dhav
{
/// <summary>
/// One video chunk per H.264 access unit (each starting with an access unit delimiter) at 25 fps, each followed
/// by 40 ms of 8 kHz mono A-law sound.
/// </summary>
public static byte[] Recording(byte[] annexB, byte[] alaw, int width, int height)
{
var units = AccessUnits(annexB);
var output = new MemoryStream();
for (var i = 0; i < units.Count; i++)
{
var ms = i * 40;
// 0x80: size in units of 8 pixels; 0x81: codec 8 (H.264) at 25 fps.
byte[] video = [0x80, 0, (byte)(width / 8), (byte)(height / 8), 0x81, 0, 0x08, 25];
Chunk(output, IsKeyFrame(units[i]) ? (byte)0xFD : (byte)0xFC, i + 1, ms, video, units[i]);
var sound = alaw.AsSpan().Slice(Math.Min(i * 320, alaw.Length), Math.Clamp(alaw.Length - i * 320, 0, 320));
// 0x83: one channel, codec 0x0E (A-law), sample rate 0 (8 kHz).
if (!sound.IsEmpty)
Chunk(output, 0xF0, i + 1, ms, [0x83, 1, 0x0E, 0], sound);
}
return output.ToArray();
}
private static void Chunk(MemoryStream output, byte type, int number, int ms, ReadOnlySpan<byte> extension, ReadOnlySpan<byte> payload)
{
var length = 24 + extension.Length + payload.Length + 8;
var seconds = ms / 1000;
// Wall-clock time of the chunk: 2026-10-05 15:mm:ss.
var date = (uint)(seconds % 60 | seconds / 60 % 60 << 6 | 15 << 12 | 5 << 17 | 10 << 22 | (2026 - 2000) << 26);
Span<byte> header = stackalloc byte[24];
"DHAV"u8.CopyTo(header);
header[4] = type;
BinaryPrimitives.WriteInt32LittleEndian(header[8..], number);
BinaryPrimitives.WriteInt32LittleEndian(header[12..], length);
BinaryPrimitives.WriteUInt32LittleEndian(header[16..], date);
BinaryPrimitives.WriteUInt16LittleEndian(header[20..], (ushort)ms);
header[22] = (byte)extension.Length;
output.Write(header);
output.Write(extension);
output.Write(payload);
output.Write("dhav"u8);
Span<byte> trailer = stackalloc byte[4];
BinaryPrimitives.WriteInt32LittleEndian(trailer, length);
output.Write(trailer);
}
private static List<byte[]> AccessUnits(byte[] annexB)
{
byte[] delimiter = [0, 0, 0, 1, 9];
var starts = new List<int>();
for (var at = annexB.AsSpan().IndexOf(delimiter); at >= 0;)
{
starts.Add(at);
var next = annexB.AsSpan(at + 1).IndexOf(delimiter);
at = next < 0 ? -1 : at + 1 + next;
}
return starts.Select((start, i) => annexB[start..(i + 1 < starts.Count ? starts[i + 1] : annexB.Length)]).ToList();
}
/// <summary>An access unit with an IDR slice (NAL type 5).</summary>
private static bool IsKeyFrame(byte[] unit)
{
for (var i = 0; i + 3 < unit.Length; i++)
{
if (unit[i] == 0 && unit[i + 1] == 0 && unit[i + 2] == 1 && (unit[i + 3] & 0x1F) == 5)
return true;
}
return false;
}
}
[Fact]
public async Task A_self_contained_m4s_converts_and_a_bare_dash_segment_is_refused()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// Several fragments after an empty moov, as DASH packagers write them.
var fragmented = await MakeClipAsync(folder, "fragmented.mp4", seconds: 2, size: "160x120",
extra: ["-movflags", "+frag_keyframe+empty_moov+default_base_moof", "-frag_duration", "500000"]);
var boxes = TopLevelBoxes(await File.ReadAllBytesAsync(fragmented, TestContext.Current.CancellationToken));
Assert.Equal(["ftyp", "moov"], boxes.Take(2).Select(b => b.Type));
Assert.True(boxes.Count(b => b.Type == "moof") >= 2, string.Join(" ", boxes.Select(b => b.Type)));
// The reporter's layout (GPAC): ftyp + moov, then a styp before every moof / mdat pair.
byte[] styp = [0, 0, 0, 24, .. "stypmsdh"u8, 0, 0, 0, 0, .. "msdhmsix"u8];
var whole = Path.Combine(folder, "whole.m4s");
await File.WriteAllBytesAsync(whole, boxes.SelectMany(b => b.Type == "moof" ? [.. styp, .. b.Bytes] : b.Bytes).ToArray(),
TestContext.Current.CancellationToken);
var probed = await ProbeAsync(await ConvertAsync(whole, "mp4"));
Assert.NotNull(probed.Video);
Assert.NotNull(probed.Audio);
Assert.InRange(probed.Duration, 1.7, 2.4);
// Without ftyp and moov the fragments need an init segment: Filee's message, not FFmpeg's error.
var segment = Path.Combine(folder, "segment.m4s");
await File.WriteAllBytesAsync(segment, styp.Concat(boxes.Skip(2).SelectMany(b => b.Bytes)).ToArray(),
TestContext.Current.CancellationToken);
var job = await fx.ConvertAsync([segment], new Preset { TargetFormat = "mp4" });
var file = Assert.Single(job.Files);
Assert.Equal((FileState.Failed, "error.m4s_needs_init"), (file.State, file.ErrorKey));
Assert.Empty(Directory.GetFiles(folder, "segment*.mp4"));
}
[Fact]
public void Voice_memo_qta_goes_to_every_audio_target_in_one_ffmpeg_step()
{
// #646: Apple Voice Memos' QuickTime audio, read through FFmpeg's mov demuxer; never a target.
foreach (var target in MediaEncoding.AudioTargets.Keys)
{
var route = Planner().Plan("qta", target);
Assert.True(route is not null, target);
Assert.Equal("ffmpeg", Assert.Single(route.Steps).Converter.Id);
}
Assert.DoesNotContain(new FfmpegConverter().Edges, e => e.To == "qta");
Assert.Null(Planner().Plan("mp3", "qta"));
}
[Fact]
public async Task A_voice_memo_qta_converts_to_audio()
{
SkipUnlessInstalled();
var memo = Path.Combine(fx.NewFolder(), "memo.qta");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi",
"-i", "sine=frequency=440:sample_rate=44100:duration=2", "-c:a", "aac", "-f", "mov", memo]);
foreach (var target in new[] { "mp3", "wav", "m4a" })
{
var probed = await ProbeAsync(await ConvertAsync(memo, target));
var audio = Assert.Single(probed.Streams, s => s.Type == "audio");
Assert.InRange(probed.Duration, 1.7, 2.4);
if (target == "m4a")
Assert.Equal("aac", audio.Codec);
}
}
[Fact]
public async Task A_qta_with_more_tracks_converts_its_first_audio_track()
{
// #646: audio targets take the first sound track (-map 0:a:0), not the second one or a mix of both, and leave
// text and timecode (data) tracks out. The tracks differ in channels and length so the result tells them apart.
SkipUnlessInstalled();
var folder = fx.NewFolder();
var srt = Path.Combine(folder, "words.srt");
await File.WriteAllTextAsync(srt, "1\n00:00:00,000 --> 00:00:00,900\nhello\n", TestContext.Current.CancellationToken);
// FFmpeg writes a timecode (tmcd) track only beside a video track, so the memo is copied out of a clip with one.
var stage = Path.Combine(folder, "stage.mov");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=44100:duration=1",
"-f", "lavfi", "-i", "sine=frequency=880:sample_rate=44100:duration=2",
"-i", srt, "-f", "lavfi", "-i", "testsrc2=size=64x64:rate=1:duration=1",
"-ac:a:1", "2", "-map", "0:a", "-map", "1:a", "-map", "2:s", "-map", "3:v",
"-c:a", "aac", "-c:s", "mov_text", "-c:v", "mjpeg", "-timecode", "00:00:00:00", "-f", "mov", stage]);
var memo = Path.Combine(folder, "memo.qta");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-i", stage,
"-map", "0:a", "-map", "0:s", "-map", "0:d", "-c", "copy", "-f", "mov", memo]);
var source = await ProbeAsync(memo);
Assert.Equal(["audio", "audio", "subtitle", "data"], source.Streams.Select(s => s.Type));
Assert.Equal([1, 2], source.Streams.Where(s => s.Type == "audio").Select(s => s.Channels));
var probed = await ProbeAsync(await ConvertAsync(memo, "mka"));
var audio = Assert.Single(probed.Streams);
Assert.Equal(("audio", 1), (audio.Type, audio.Channels));
Assert.InRange(probed.Duration, 0.8, 1.3);
}
[Fact]
public async Task A_qta_whose_first_track_ffmpeg_cannot_decode_converts_the_next_one()
{
SkipUnlessInstalled();
var memo = Path.Combine(fx.NewFolder(), "memo.qta");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000:duration=2",
"-f", "lavfi", "-i", "sine=frequency=880:sample_rate=44100:duration=1",
"-ac:a:0", "4", "-map", "0:a", "-map", "1:a", "-c:a", "aac", "-f", "mov", memo]);
WithoutDecoder(memo);
Assert.Equal(["apple_apac", "aac"], (await ProbeAsync(memo)).Streams.Select(s => s.Codec));
foreach (var target in new[] { "mp3", "wav", "m4a" })
{
var probed = await ProbeAsync(await ConvertAsync(memo, target));
var audio = Assert.Single(probed.Streams);
Assert.Equal(("audio", 1), (audio.Type, audio.Channels));
Assert.InRange(probed.Duration, 0.8, 1.3);
}
}
[Fact]
public async Task A_qta_whose_only_sound_ffmpeg_cannot_decode_fails_naming_the_codec()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var memo = Path.Combine(folder, "memo.qta");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "sine=frequency=440:duration=2", "-c:a", "aac", "-f", "mov", memo]);
WithoutDecoder(memo);
var job = await fx.ConvertAsync([memo], new Preset { TargetFormat = "mp3" });
var file = Assert.Single(job.Files);
Assert.Equal(FileState.Failed, file.State);
Assert.Contains("apple_apac", file.ErrorDetail);
Assert.Empty(Directory.GetFiles(folder, "*.mp3"));
}
[Fact]
public async Task A_video_whose_first_sound_ffmpeg_cannot_decode_keeps_the_next_one()
{
SkipUnlessInstalled();
var video = Path.Combine(fx.NewFolder(), "clip.mov");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "testsrc2=size=64x64:rate=10:duration=2",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000:duration=2",
"-f", "lavfi", "-i", "sine=frequency=880:sample_rate=44100:duration=2",
"-map", "0:v", "-map", "1:a", "-map", "2:a", "-ac:a:0", "4",
"-c:v", "mjpeg", "-c:a", "aac", "-f", "mov", video]);
WithoutDecoder(video);
Assert.Equal(["apple_apac", "aac"], (await ProbeAsync(video)).Streams.Where(s => s.Type == "audio").Select(s => s.Codec));
var probed = await ProbeAsync(await ConvertAsync(video, "mkv"));
Assert.Equal(1, Assert.Single(probed.Streams, s => s.Type == "audio").Channels);
Assert.Single(probed.Streams, s => s.Type == "video");
}
[Fact]
public async Task A_video_whose_first_sound_ffprobe_cannot_name_keeps_the_next_one()
{
SkipUnlessInstalled();
var video = Path.Combine(fx.NewFolder(), "clip.mov");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "testsrc2=size=64x64:rate=10:duration=2",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000:duration=2",
"-f", "lavfi", "-i", "sine=frequency=880:sample_rate=44100:duration=2",
"-map", "0:v", "-map", "1:a", "-map", "2:a", "-ac:a:0", "4",
"-c:v", "mjpeg", "-c:a", "aac", "-f", "mov", video]);
WithoutDecoder(video, tag: "zzzz");
var result = await ProcessRunner.RunAsync(Tools.Value.Ffprobe,
["-v", "error", "-select_streams", "a", "-show_entries", "stream=codec_name", "-of", "json", video],
TimeSpan.FromMinutes(1), CancellationToken.None);
Assert.True(result.ExitCode == 0, result.StandardError);
using var json = JsonDocument.Parse(result.StandardOutput);
Assert.Equal([null, "aac"], json.RootElement.GetProperty("streams").EnumerateArray()
.Select(s => s.TryGetProperty("codec_name", out var codec) ? codec.GetString() : null));
var probed = await ProbeAsync(await ConvertAsync(video, "mkv"));
Assert.Equal(1, Assert.Single(probed.Streams, s => s.Type == "audio").Channels);
Assert.Single(probed.Streams, s => s.Type == "video");
}
[Fact]
public async Task A_video_whose_later_sound_ffmpeg_cannot_decode_keeps_only_the_first()
{
SkipUnlessInstalled();
var video = Path.Combine(fx.NewFolder(), "clip.mov");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "testsrc2=size=64x64:rate=10:duration=2",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=44100:duration=2",
"-f", "lavfi", "-i", "sine=frequency=880:sample_rate=48000:duration=2",
"-map", "0:v", "-map", "1:a", "-map", "2:a", "-ac:a:1", "4",
"-c:v", "mjpeg", "-c:a", "aac", "-f", "mov", video]);
WithoutDecoder(video, track: 1);
Assert.Equal(["aac", "apple_apac"], (await ProbeAsync(video)).Streams.Where(s => s.Type == "audio").Select(s => s.Codec));
var probed = await ProbeAsync(await ConvertAsync(video, "mkv"));
Assert.Equal(1, Assert.Single(probed.Streams, s => s.Type == "audio").Channels);
Assert.Single(probed.Streams, s => s.Type == "video");
}
[Fact]
public async Task A_late_starting_first_sound_stays_the_first_track()
{
SkipUnlessInstalled();
var late = Path.Combine(fx.NewFolder(), "late.ts");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", "testsrc2=size=64x64:rate=10:duration=12",
"-itsoffset", "8", "-f", "lavfi", "-i", "sine=frequency=440:duration=4",
"-f", "lavfi", "-i", "sine=frequency=880:duration=12",
"-map", "0:v", "-map", "1:a", "-map", "2:a", "-c:v", "mpeg2video", "-c:a", "aac", "-f", "mpegts", late]);
var info = await MediaInfo.ProbeAsync(Tools.Value.Ffprobe, late, TestContext.Current.CancellationToken);
Assert.Equal(("aac", 0), (info.Audio!.Codec, info.Audio.Ordinal));
Assert.Equal([0, 1], info.AudioTracks.Select(t => t.Ordinal));
var args = Args("mkv", info: info);
Assert.Equal(["0:V:0", "0:a:0", "0:a:1"], args.Where((a, i) => i > 0 && args[i - 1] == "-map"));
var probed = await ProbeAsync(await ConvertAsync(late, "mp3"));
Assert.Single(probed.Streams, s => s.Type == "audio");
Assert.InRange(probed.Duration, 3.5, 4.6);
}
/// <summary>Marks one AAC QuickTime track as APAC, which the bundled FFmpeg identifies but cannot decode,
/// or a tag ffprobe knows no codec for ("zzzz").</summary>
internal static void WithoutDecoder(string path, int track = 0, string tag = "apac")
{
var bytes = File.ReadAllBytes(path);
var at = 0;
for (var i = 0; i < (track + 1) * 3; i++)
{
var index = bytes.AsSpan(at).IndexOf("mp4a"u8);
Assert.True(index >= 0, "AAC sample entry not found.");
at += index;
if (i >= track * 3)
Encoding.ASCII.GetBytes(tag).CopyTo(bytes.AsSpan(at));
at += 4;
}
at = 0;
for (var i = 0; i <= track; i++)
{
var index = bytes.AsSpan(at).IndexOf("esds"u8);
Assert.True(index >= 0, "AAC descriptor not found.");
at += index;
if (i == track)
"free"u8.CopyTo(bytes.AsSpan(at));
at += 4;
}
File.WriteAllBytes(path, bytes);
}
/// <summary>The top-level boxes of a short MP4 (32-bit sizes, as FFmpeg writes them for small files).</summary>
private static List<(string Type, byte[] Bytes)> TopLevelBoxes(byte[] data)
{
var boxes = new List<(string, byte[])>();
for (var at = 0; at + 8 <= data.Length;)
{
var size = (int)System.Buffers.Binary.BinaryPrimitives.ReadUInt32BigEndian(data.AsSpan(at));
Assert.InRange(size, 8, data.Length - at);
boxes.Add((System.Text.Encoding.Latin1.GetString(data, at + 4, 4), data[at..(at + size)]));
at += size;
}
return boxes;
}
private static readonly (string Ffmpeg, string Ffprobe)? Tools = FfmpegConverter.Locate();
private static void SkipUnlessInstalled() =>
Assert.SkipUnless(Tools is not null, "FFmpeg is not installed (pwsh build/fetch-engines.ps1 -Only ffmpeg)");
// ───────────────────────── Routes (no FFmpeg needed) ─────────────────────────
/// <summary>A planner that treats FFmpeg as installed, so these tests also run where it is not.</summary>
private RoutePlanner Planner() => fx.Catalog.CreatePlanner(["ffmpeg"]);
[Theory]
[InlineData("mp4", "webm")]
[InlineData("mov", "mp4")]
[InlineData("mkv", "mp4")]
[InlineData("avi", "mp4")]
[InlineData("mp4", "mp4")] // re-encode, e.g. the "MP4 720p" preset
[InlineData("mp4", "gif")]
[InlineData("mp4", "mp3")]
[InlineData("webm", "m4a")]
[InlineData("wav", "mp3")]
[InlineData("flac", "mp3")]
[InlineData("mp3", "mp3")] // re-encode, e.g. "MP3 128k"
[InlineData("m4a", "wav")]
[InlineData("amr", "mp3")]
[InlineData("gif", "mp4")]
[InlineData("gif", "webm")]
[InlineData("png", "mov")]
[InlineData("apng", "mp4")]
[InlineData("mov", "apng")]
[InlineData("rm", "mp4")]
[InlineData("dss", "mp3")]
[InlineData("mp4", "png")]
[InlineData("ape", "flac")]
[InlineData("wv", "mp3")]
[InlineData("tta", "wv")]
[InlineData("mpc", "m4a")]
[InlineData("tak", "flac")]
[InlineData("dsf", "wav")]
[InlineData("dff", "flac")]
[InlineData("dts", "eac3")]
[InlineData("spx", "ogg")]
[InlineData("wav", "w64")]
[InlineData("mkv", "eac3")]
public void Media_conversions_take_one_ffmpeg_step(string from, string to)
{
var route = Planner().Plan(from, to);
Assert.NotNull(route);
var step = Assert.Single(route.Steps);
Assert.Equal("ffmpeg", step.Converter.Id);
}
[Theory]
[InlineData("mp4", "jpg", "magick")]
[InlineData("mkv", "webp", "magick")]
[InlineData("mov", "pdf", "pdfsharp")]
public void Video_to_images_goes_through_one_still_frame_not_an_animated_gif(string from, string to, string imageEngine)
{
var route = Planner().Plan(from, to);
Assert.NotNull(route);
Assert.Equal([("ffmpeg", from, "png"), (imageEngine, "png", to)], route.Steps.Select(s => (s.Converter.Id, s.From, s.To)));
Assert.DoesNotContain(route.Steps, s => s.FrameSequence);
}
[Theory]
[InlineData("mp4", "png")]
[InlineData("mov", "jpg")]
[InlineData("mkv", "jpg")]
public void Every_frame_is_one_ffmpeg_step_only_when_asked_for(string from, string to)
{
var frames = Planner().Plan(from, to, frames: true);
Assert.NotNull(frames);
var step = Assert.Single(frames.Steps);
Assert.Equal(("ffmpeg", from, to, true), (step.Converter.Id, step.From, step.To, step.FrameSequence));
// Without it the same conversion is the still frame, as before.
var still = Planner().Plan(from, to);
Assert.NotNull(still);
Assert.DoesNotContain(still.Steps, s => s.FrameSequence);
Assert.Equal(("ffmpeg", from, "png"), (still.Steps[0].Converter.Id, still.Steps[0].From, still.Steps[0].To));
}
[Theory]
[InlineData("mp4", "webp")] // frames are PNG or JPG only, never a step towards another format
[InlineData("png", "jpg")] // not a video
[InlineData("gif", "png")]
public void Every_frame_has_no_route_but_its_own(string from, string to) =>
Assert.Null(Planner().Plan(from, to, frames: true));
[Theory]
[InlineData("jpg", "wav")]
[InlineData("png", "mp3")]
[InlineData("gif", "flac")]
public void A_picture_never_becomes_sound(string from, string to)
{
// Picture → video → audio would only make a silent file.
Assert.Null(Planner().Plan(from, to));
Assert.NotNull(Planner().Plan("mp4", to)); // a video still gives its sound
}
[Theory]
[InlineData("jpg", "srt")]
[InlineData("png", "vtt")]
[InlineData("gif", "ass")]
public void A_picture_never_becomes_subtitles(string from, string to)
{
// Picture → video → subtitles would only find none.
Assert.Null(Planner().Plan(from, to));
Assert.NotNull(Planner().Plan("mkv", to)); // a video still gives its subtitle track
}
[Fact]
public void A_video_to_jpg_is_still_turned_by_the_image_engine()
{
// Rotate and flip presets on a video: the still frame is turned by ImageMagick, as before frames existed.
var route = Planner().Plan("mp4", "jpg");
Assert.NotNull(route);
Assert.Equal(1, route.FirstTransformStep());
}
[Fact]
public void Ordinary_routes_never_take_a_frame_step()
{
var planner = Planner();
foreach (var from in FormatRegistry.Known.Where(f => f.Category == FormatCategory.Video).Select(f => f.Id))
{
foreach (var to in new[] { "jpg", "png", "webp", "pdf", "tiff", "gif", "mp4" })
{
if (planner.Plan(from, to) is { } route)
Assert.DoesNotContain(route.Steps, s => s.FrameSequence);
}
}
}
[Theory]
[InlineData("heic", "mov", "magick")]
[InlineData("jpg", "mp4", "magick")]
[InlineData("avif", "webm", "magick")]
[InlineData("svg", "mov", "vector")]
[InlineData("qoi", "mp4", "magick")]
public void Photos_reach_video_as_a_full_colour_png_not_a_gif(string from, string to, string imageEngine)
{
var route = Planner().Plan(from, to);
Assert.NotNull(route);
Assert.Equal([(imageEngine, from, "png"), ("ffmpeg", "png", to)], route.Steps.Select(s => (s.Converter.Id, s.From, s.To)));
}
[Theory]
[InlineData("pdf", "mp4", "pdfium")] // a slideshow of the pages
[InlineData("webp", "mov", "magick")] // an animated WebP keeps moving
[InlineData("tiff", "webm", "magick")]
[InlineData("mng", "mp4", "magick")]
public void Animations_and_pages_still_reach_video_through_gif(string from, string to, string imageEngine)
{
var route = Planner().Plan(from, to);
Assert.NotNull(route);
Assert.Equal([(imageEngine, from, "gif"), ("ffmpeg", "gif", to)], route.Steps.Select(s => (s.Converter.Id, s.From, s.To)));
}
[Fact]
public void Every_writable_video_and_audio_format_is_a_target()
{
// A new format in the catalog must get an encoding (or a documented reason why not) in MediaEncoding.
Assert.Equal(
FormatRegistry.Known.Where(f => f.Category == FormatCategory.Video && f.Writable).Select(f => f.Id).Order(),
MediaEncoding.VideoTargets.Keys.Order());
Assert.Equal(
FormatRegistry.Known.Where(f => f.Category == FormatCategory.Audio && f.Writable).Select(f => f.Id).Order(),
MediaEncoding.AudioTargets.Keys.Order());
}
[Fact]
public void Audio_is_never_turned_into_video_and_ffmpeg_is_unavailable_until_installed()
{
var planner = Planner();
Assert.Null(planner.Plan("mp3", "mp4"));
Assert.Null(planner.Plan("wav", "gif"));
var ffmpeg = fx.Converters.Single(c => c.Id == "ffmpeg");
Assert.Equal(Tools is not null, ffmpeg.GetStatus().IsAvailable);
if (Tools is null)
Assert.Equal("engine.reason.not_installed", ffmpeg.GetStatus().ReasonKey);
}
// ───────────────────────── Command lines (no FFmpeg needed) ─────────────────────────
private static readonly VideoStreamInfo Hd = new(1920, 1080, 1, 0, 29.97);
private static IReadOnlyList<string> Args(string target, MediaOptions? options = null, MediaInfo? info = null) =>
MediaEncoding.Plan("in.mkv", "out." + target, target, options ?? new MediaOptions(),
info ?? new MediaInfo(TimeSpan.FromSeconds(10), Hd, new AudioStreamInfo(6, 44100), null), "work").Single().Arguments;
private static string After(IReadOnlyList<string> args, string option) => args[args.ToList().IndexOf(option) + 1];
[Fact]
public void Audio_targets_map_the_track_the_probe_chose()
{
var info = new MediaInfo(TimeSpan.FromSeconds(1), null, new AudioStreamInfo(1, 44100, "aac", 1), null);
Assert.Equal("0:a:1", After(Args("mp3", info: info), "-map"));
}
[Fact]
public void Quality_bitrate_and_size_options_reach_the_encoders()
{
var mp4 = Args("mp4", new MediaOptions { Quality = MediaQuality.High, MaxHeight = 720 });
Assert.Equal("libx264", After(mp4, "-c:v"));
Assert.Equal("18", After(mp4, "-crf"));
Assert.Equal("scale=w=-2:h='trunc(min(ih,720)/2)*2'", After(mp4, "-vf"));
Assert.Equal("+faststart", After(mp4, "-movflags"));
Assert.Equal("768k", After(mp4, "-b:a")); // 256k per stereo pair × 3 pairs (5.1)
Assert.Equal("mp4", After(mp4, "-f"));
var webm = Args("webm", new MediaOptions { Quality = MediaQuality.Small, RemoveAudio = true });
Assert.Equal(["-b:v", "0", "-crf", "38"], webm.SkipWhile(a => a != "-b:v").Take(4));
Assert.Contains("-an", webm);
Assert.DoesNotContain("0:a:0", webm);
var mp3 = Args("mp3", new MediaOptions { AudioBitrateKbps = 130 });
Assert.Equal("128k", After(mp3, "-b:a")); // snapped to the MP3 bitrate table
Assert.DoesNotContain("-q:a", mp3);
Assert.Equal("2", After(Args("mp3"), "-q:a")); // VBR V2 by default
Assert.Equal("2", After(Args("wma"), "-ac")); // WMA holds two channels at most
Assert.Equal("8000", After(Args("amr"), "-ar"));
Assert.Equal("30000/1001", After(Args("mpg"), "-r"));
Assert.Equal("448k", After(Args("vob"), "-b:a")); // DVD 5.1
}
[Fact]
public void Channels_sample_rate_and_bit_depth_reach_the_audio_encoders()
{
// Low Opus bitrates for speech, mono (#37).
var opus = Args("opus", new MediaOptions { AudioBitrateKbps = 32, AudioChannels = 1 });
Assert.Equal("32k", After(opus, "-b:a"));
Assert.Equal("1", After(opus, "-ac"));
Assert.DoesNotContain("-ac", Args("opus"));
var wav = Args("wav", new MediaOptions { AudioChannels = 1, AudioSampleRate = 16000, WavFormat = WavSampleFormat.Pcm24 });
Assert.Equal("pcm_s24le", After(wav, "-c:a"));
Assert.Equal("1", After(wav, "-ac"));
Assert.Equal("16000", After(wav, "-ar"));
Assert.Equal("pcm_s16le", After(Args("wav"), "-c:a")); // 16-bit stays the default
Assert.DoesNotContain("-ar", Args("wav"));
Assert.Equal("pcm_u8", After(Args("wav", new MediaOptions { WavFormat = WavSampleFormat.Pcm8 }), "-c:a"));
Assert.Equal("pcm_f32le", After(Args("wav", new MediaOptions { WavFormat = WavSampleFormat.Float32 }), "-c:a"));
// The sample rate is a WAV option only; AMR keeps its fixed mono 8 kHz.
Assert.DoesNotContain("-ar", Args("flac", new MediaOptions { AudioSampleRate = 16000 }));
var amr = Args("amr", new MediaOptions { AudioChannels = 2 });
Assert.All(amr.Where((_, i) => i > 0 && amr[i - 1] == "-ac"), channels => Assert.Equal("1", channels));
}
[Fact]
public void Streams_the_target_takes_as_they_are_are_copied()
{
var phone = new MediaInfo(TimeSpan.FromSeconds(10), new VideoStreamInfo(1920, 1080, 1, -90, 30, "hevc", "yuv420p10le"),
new AudioStreamInfo(2, 44100, "aac"), null);
var mp4 = Args("mp4", info: phone);
Assert.Equal("copy", After(mp4, "-c:v"));
Assert.Equal("hvc1", After(mp4, "-tag:v")); // Apple plays HEVC in MP4 only under this tag
Assert.Equal("copy", After(mp4, "-c:a"));
Assert.DoesNotContain("-vf", mp4);
Assert.Equal("+faststart", After(mp4, "-movflags"));
// WebM takes neither HEVC nor AAC.
var webm = Args("webm", info: phone);
Assert.Equal(("libvpx-vp9", "libopus"), (After(webm, "-c:v"), After(webm, "-c:a")));
// Re-encoded: scaled down (the portrait video is 1920 high as shown), a small file asked for, a pixel format
// players don't decode.
Assert.Equal("libx264", After(Args("mp4", new MediaOptions { MaxHeight = 1080 }, phone), "-c:v"));
Assert.Equal("copy", After(Args("mp4", new MediaOptions { MaxHeight = 2160 }, phone), "-c:v"));
Assert.Equal("libx264", After(Args("mp4", new MediaOptions { Quality = MediaQuality.Small }, phone), "-c:v"));
var yuv444 = phone with { Video = phone.Video! with { Codec = "h264", PixelFormat = "yuv444p" } };
Assert.Equal("libx264", After(Args("mp4", info: yuv444), "-c:v"));
// Audio alone is re-encoded when the container does not take it or the preset sets bitrate or channels.
var pcm = phone with { Audio = new AudioStreamInfo(2, 48000, "pcm_s16le") };
Assert.Equal(("copy", "aac"), (After(Args("mp4", info: pcm), "-c:v"), After(Args("mp4", info: pcm), "-c:a")));
Assert.Equal("aac", After(Args("mov", new MediaOptions { AudioBitrateKbps = 128 }, phone), "-c:a"));
Assert.Equal("aac", After(Args("mov", new MediaOptions { AudioChannels = 1 }, phone), "-c:a"));
Assert.Equal("copy", After(Args("mov", new MediaOptions { AudioChannels = 2 }, phone), "-c:a"));
}
[Fact]
public void Hevc_and_av1_presets_encode_with_x265_and_svt_av1()
{
var hevc = Args("mp4", new MediaOptions { VideoCodec = VideoCodec.Hevc });
Assert.Equal(("libx265", "26", "yuv420p", "hvc1"), (After(hevc, "-c:v"), After(hevc, "-crf"), After(hevc, "-pix_fmt"), After(hevc, "-tag:v")));
Assert.Equal("log-level=error", After(hevc, "-x265-params"));
Assert.Equal("aac", After(hevc, "-c:a"));
Assert.Equal(("22", "30"), (After(Args("mkv", new MediaOptions { VideoCodec = VideoCodec.Hevc, Quality = MediaQuality.High }), "-crf"),
After(Args("mkv", new MediaOptions { VideoCodec = VideoCodec.Hevc, Quality = MediaQuality.Small }), "-crf")));
Assert.DoesNotContain("-tag:v", Args("mkv", new MediaOptions { VideoCodec = VideoCodec.Hevc }));
var av1 = Args("mp4", new MediaOptions { VideoCodec = VideoCodec.Av1 });
Assert.Equal(("libsvtav1", "8", "32"), (After(av1, "-c:v"), After(av1, "-preset"), After(av1, "-crf")));
var webm = Args("webm", new MediaOptions { VideoCodec = VideoCodec.Av1 });
Assert.Equal(("libsvtav1", "libopus"), (After(webm, "-c:v"), After(webm, "-c:a")));
// Targets that can't hold the codec keep their own: WebM has no HEVC, QuickTime no AV1, AVI neither.
Assert.Equal("libvpx-vp9", After(Args("webm", new MediaOptions { VideoCodec = VideoCodec.Hevc }), "-c:v"));
Assert.Equal("libx264", After(Args("mov", new MediaOptions { VideoCodec = VideoCodec.Av1 }), "-c:v"));
Assert.Equal("mpeg4", After(Args("avi", new MediaOptions { VideoCodec = VideoCodec.Hevc }), "-c:v"));
}
[Fact]
public void Av1_falls_back_to_libaom_and_a_missing_encoder_is_reported()
{
var info = new MediaInfo(TimeSpan.FromSeconds(10), Hd, new AudioStreamInfo(2, 48000), null);
IReadOnlyList<string> Plan(VideoCodec codec, params string[] encoders) => MediaEncoding.Plan("in.mov", "out.mkv", "mkv",
new MediaOptions { VideoCodec = codec }, info, "work", encoders: encoders.ToHashSet()).Single().Arguments;
var aom = Plan(VideoCodec.Av1, "libaom-av1", "libx264", "aac");
Assert.Equal(("libaom-av1", "0", "32", "6"), (After(aom, "-c:v"), After(aom, "-b:v"), After(aom, "-crf"), After(aom, "-cpu-used")));
Assert.Contains("AV1 encoder", Assert.Throws<InvalidOperationException>(() => Plan(VideoCodec.Av1, "libx264")).Message);
Assert.Contains("HEVC encoder", Assert.Throws<InvalidOperationException>(() => Plan(VideoCodec.Hevc, "libx264")).Message);
// A video already in the codec needs no encoder at all.
var hevcSource = info with { Video = Hd with { Codec = "hevc", PixelFormat = "yuv420p" } };
Assert.Equal("copy", After(MediaEncoding.Plan("in.mov", "out.mkv", "mkv", new MediaOptions { VideoCodec = VideoCodec.Hevc }, hevcSource, "work",
encoders: new HashSet<string>()).Single().Arguments, "-c:v"));
}
[Fact]
public void Ten_bit_and_hdr_sources_stay_ten_bit_and_matching_codecs_are_copied()
{
var hlg = new VideoColor("bt2020", "arib-std-b67", "bt2020nc", "tv");
var phone = new MediaInfo(TimeSpan.FromSeconds(10), new VideoStreamInfo(3840, 2160, 1, 0, 30, "hevc", "yuv420p10le", hlg),
new AudioStreamInfo(2, 48000, "aac"), null);
// HEVC asked for, HEVC given: rewrapped, 10-bit HDR untouched.
Assert.Equal("copy", After(Args("mp4", new MediaOptions { VideoCodec = VideoCodec.Hevc }, phone), "-c:v"));
// AV1 asked for: encoded in 10 bits with the HDR tags.
var av1 = Args("mkv", new MediaOptions { VideoCodec = VideoCodec.Av1 }, phone);
Assert.Equal(("libsvtav1", "yuv420p10le"), (After(av1, "-c:v"), After(av1, "-pix_fmt")));
Assert.Equal(("bt2020", "arib-std-b67", "bt2020nc"), (After(av1, "-color_primaries"), After(av1, "-color_trc"), After(av1, "-colorspace")));
// Scaled down: re-encoded, still 10 bits.
var small = Args("mp4", new MediaOptions { VideoCodec = VideoCodec.Hevc, MaxHeight = 1080 }, phone);
Assert.Equal(("libx265", "yuv420p10le"), (After(small, "-c:v"), After(small, "-pix_fmt")));
// An H.264 source with HEVC asked for is encoded; an AV1 source with AV1 asked for goes into MP4 as it is.
var h264 = phone with { Video = new VideoStreamInfo(1920, 1080, 1, 0, 30, "h264", "yuv420p") };
var hevc = Args("mp4", new MediaOptions { VideoCodec = VideoCodec.Hevc }, h264);
Assert.Equal(("libx265", "yuv420p"), (After(hevc, "-c:v"), After(hevc, "-pix_fmt")));
Assert.DoesNotContain("-color_trc", hevc);
var av1Source = phone with { Video = new VideoStreamInfo(1920, 1080, 1, 0, 30, "av1", "yuv420p") };
Assert.Equal("copy", After(Args("mp4", new MediaOptions { VideoCodec = VideoCodec.Av1 }, av1Source), "-c:v"));
Assert.Equal("libx264", After(Args("mp4", info: av1Source), "-c:v")); // H.264 stays the default for MP4
Assert.True(new VideoStreamInfo(1, 1, 1, 0, 0, PixelFormat: "p010le").IsHighBitDepth);
Assert.True(new VideoStreamInfo(1, 1, 1, 0, 0, PixelFormat: "yuv422p12le").IsHighBitDepth);
Assert.False(new VideoStreamInfo(1, 1, 1, 0, 0, PixelFormat: "yuvj420p").IsHighBitDepth);
}
[Fact]
public void Lossless_and_new_audio_targets_get_their_encoders()
{
var alac = Args("m4a", new MediaOptions { AudioCodec = AudioCodec.Alac, AudioBitrateKbps = 128 });
Assert.Equal(("alac", "ipod"), (After(alac, "-c:a"), After(alac, "-f")));
Assert.DoesNotContain("-b:a", alac);
Assert.Equal("libmp3lame", After(Args("mp3", new MediaOptions { AudioCodec = AudioCodec.Alac }), "-c:a")); // ALAC is for M4A only
Assert.Equal(("wavpack", "wv"), (After(Args("wv"), "-c:a"), After(Args("wv"), "-f")));
Assert.Equal(("tta", "tta"), (After(Args("tta"), "-c:a"), After(Args("tta"), "-f")));
var w64 = Args("w64", new MediaOptions { WavFormat = WavSampleFormat.Pcm24, AudioSampleRate = 48000 });
Assert.Equal(("pcm_s24le", "48000", "w64"), (After(w64, "-c:a"), After(w64, "-ar"), After(w64, "-f")));
Assert.Equal(("eac3", "576k"), (After(Args("eac3"), "-c:a"), After(Args("eac3"), "-b:a"))); // 192k per pair × 3 (5.1)
// DSD (2.8 MHz) becomes 88.2 kHz PCM for lossless targets; lossy encoders choose their own rate.
var dsd = new MediaInfo(TimeSpan.FromSeconds(10), null, new AudioStreamInfo(2, 2_822_400, "dsd_lsbf_planar"), null);
Assert.Equal("88200", After(Args("flac", info: dsd), "-ar"));
Assert.Equal("88200", After(Args("wav", info: dsd), "-ar"));
Assert.Equal("16000", After(Args("wav", new MediaOptions { AudioSampleRate = 16000 }, dsd), "-ar"));
Assert.Equal("44100", After(Args("ogg", info: dsd), "-ar"));
Assert.DoesNotContain("-ar", Args("mp3", info: dsd));
}
[Fact]
public void Dvd_and_dv_frames_are_letterboxed_into_the_nearest_tv_shape()
{
// 16:9 source: fills the anamorphic 16:9 NTSC frame.
Assert.Equal("scale=720:480,pad=720:480:(ow-iw)/2:(oh-ih)/2:black,setdar=16/9", MediaEncoding.DvdOrDvFilter(Hd, pal: false));
// 4:3 source at PAL.
Assert.Equal("scale=720:576,pad=720:576:(ow-iw)/2:(oh-ih)/2:black,setdar=4/3",
MediaEncoding.DvdOrDvFilter(new VideoStreamInfo(640, 480, 1, 0, 25), pal: true));
// Cinemascope 2.39:1: 16:9 frame with bars above and below.
Assert.Equal("scale=720:358,pad=720:480:(ow-iw)/2:(oh-ih)/2:black,setdar=16/9",
MediaEncoding.DvdOrDvFilter(new VideoStreamInfo(1920, 804, 1, 0, 24), pal: false));
// Portrait phone video (landscape pixels + 90° rotation): 4:3 frame with bars left and right.
Assert.Equal("scale=304:480,pad=720:480:(ow-iw)/2:(oh-ih)/2:black,setdar=4/3",
MediaEncoding.DvdOrDvFilter(new VideoStreamInfo(1920, 1080, 1, -90, 30), pal: false));
Assert.True(MediaEncoding.IsPal(25));
Assert.True(MediaEncoding.IsPal(50));
Assert.False(MediaEncoding.IsPal(29.97));
Assert.False(MediaEncoding.IsPal(0));
}
[Theory]
[InlineData(29.97003, "30000/1001", "30000/1001")]
[InlineData(25, "25", "25")]
[InlineData(29.87, "30", "30000/1001")]
[InlineData(15, "15", "24000/1001")]
[InlineData(0, null, "25")]
public void Frame_rates_are_made_encodable(double fps, string? nearest, string broadcast)
{
Assert.Equal(nearest, MediaEncoding.NearestRate(fps));
Assert.Equal(broadcast, MediaEncoding.BroadcastRate(fps));
}
[Fact]
public void Gif_uses_a_palette_pass_and_limits_size()
{
var passes = MediaEncoding.Plan("in.mp4", "out.gif", "gif", new MediaOptions { MaxHeight = 200 },
new MediaInfo(TimeSpan.FromSeconds(3), Hd, null, null), "work");
Assert.Equal(2, passes.Count);
Assert.Equal(1, passes.Sum(p => p.Weight), 6);
var first = passes[0].Arguments;
var palette = After(first, "image2");
Assert.StartsWith(Path.Combine("work", "palette-"), palette);
Assert.Contains("palettegen", After(first, "-filter_complex"));
var second = passes[1].Arguments;
Assert.Equal(palette, second[second.ToList().LastIndexOf("-i") + 1]);
Assert.Contains("fps=12,scale=w='min(iw,480)':h='min(ih,200)'", After(second, "-filter_complex"));
Assert.Contains("paletteuse", After(second, "-filter_complex"));
}
[Fact]
public void Apng_is_one_full_colour_looping_pass_with_the_gif_limits()
{
var pass = Assert.Single(MediaEncoding.Plan("in.mp4", "out.apng", "apng", new MediaOptions { Quality = MediaQuality.High },
new MediaInfo(TimeSpan.FromSeconds(3), Hd, new AudioStreamInfo(2, 44100), null), "work"));
var args = pass.Arguments;
Assert.Equal("fps=15,scale=w='min(iw,640)':h=ih:force_original_aspect_ratio=decrease:flags=lanczos", After(args, "-vf"));
Assert.Equal("apng", After(args, "-c:v"));
Assert.Equal("rgb24", After(args, "-pix_fmt"));
Assert.Equal("0", After(args, "-plays"));
Assert.Equal("apng", After(args, "-f"));
Assert.Contains("-an", args);
}
[Fact]
public void A_still_picture_is_shown_for_five_seconds_at_full_size()
{
var photo = new MediaInfo(null, new VideoStreamInfo(4033, 3025, 1, 0, 25), null, null);
var mov = MediaEncoding.PlanStill("in.png", "out.mov", "mov", new MediaOptions(), photo).Single().Arguments;
Assert.Equal(["-loop", "1", "-framerate", "30", "-i", "in.png"], mov.SkipWhile(a => a != "-loop").Take(6));
Assert.Equal("+icc_profiles", After(mov, "-flags2"));
Assert.Equal("5", After(mov, "-t"));
Assert.Equal("premultiply=inplace=1,scale=4032:3024:flags=lanczos:out_color_matrix=bt709:out_range=tv,format=yuv420p", After(mov, "-vf"));
Assert.Equal(("libx264", "18", "stillimage", "bt709"), (After(mov, "-c:v"), After(mov, "-crf"), After(mov, "-tune"), After(mov, "-colorspace")));
Assert.Contains("-an", mov);
Assert.Equal("mov", After(mov, "-f"));
var webm = MediaEncoding.PlanStill("in.png", "out.webm", "webm", new MediaOptions { Quality = MediaQuality.Small }, photo).Single().Arguments;
Assert.Equal(("libvpx-vp9", "32"), (After(webm, "-c:v"), After(webm, "-crf"))); // one step up: Small → Balanced
Assert.DoesNotContain("-tune", webm);
Assert.Throws<NotSupportedException>(() => MediaEncoding.PlanStill("in.png", "out.avi", "avi", new MediaOptions(), photo));
}
[Theory]
[InlineData(4032, 3024, 0, "scale=4032:3024")]
[InlineData(1001, 751, 0, "scale=1000:750")] // even sides for 4:2:0
[InlineData(4032, 3024, 720, "scale=960:720")]
[InlineData(8064, 6048, 0, "scale=6894:5170")] // 48 MP: down to the 35.6 MP H.264/VP9 level 6.2 limit
[InlineData(30000, 2000, 0, "scale=16384:1092")] // panorama: at most 16384 wide
[InlineData(0, 0, 0, "scale=w='trunc(iw/2)*2':h='trunc(ih/2)*2'")]
public void Still_pictures_are_scaled_down_only_to_what_players_decode(int width, int height, int maxHeight, string expected) =>
Assert.Equal(expected + ":flags=lanczos", MediaEncoding.StillScale(new VideoStreamInfo(width, height, 1, 0, 25), maxHeight));
[Fact]
public void Missing_streams_are_reported_clearly()
{
var silent = new MediaInfo(TimeSpan.FromSeconds(1), Hd, null, null);
var noVideo = new MediaInfo(TimeSpan.FromSeconds(1), null, new AudioStreamInfo(2, 48000), null);
Assert.Equal("The file has no audio track.", Assert.Throws<InvalidOperationException>(() => Args("mp3", info: silent)).Message);
Assert.Equal("The file has no video stream.", Assert.Throws<InvalidOperationException>(() => Args("mp4", info: noVideo)).Message);
// Video without sound converts to video without an audio track.
Assert.Contains("-an", Args("mkv", info: silent));
}
[Fact]
public void Probe_output_is_parsed()
{
const string json = """
{
"streams": [
{ "index": 0, "codec_name": "h264", "codec_type": "video", "width": 1920, "height": 1080,
"sample_aspect_ratio": "1:1", "r_frame_rate": "30/1", "avg_frame_rate": "30000/1001",
"disposition": { "attached_pic": 0 }, "side_data_list": [ { "side_data_type": "Display Matrix", "rotation": -90 } ] },
{ "index": 1, "codec_name": "aac", "codec_type": "audio", "channels": 2, "sample_rate": "48000", "duration": "12.5" },
{ "index": 2, "codec_name": "mjpeg", "codec_type": "video", "width": 300, "height": 300,
"disposition": { "attached_pic": 1 } },
{ "index": 3, "codec_name": "subrip", "codec_type": "subtitle", "tags": { "language": "kor" } }
],
"format": { "duration": "12.480000" }
}
""";
var info = MediaInfo.Parse(json);
Assert.Equal(12.48, info.Duration!.Value.TotalSeconds, 3);
Assert.Equal(new VideoStreamInfo(1920, 1080, 1, -90, 30000 / 1001.0, "h264"), info.Video);
Assert.Equal(9 / 16.0, info.Video!.DisplayAspect, 3);
Assert.Equal(1920, info.Video.DisplayHeight);
Assert.Equal(new AudioStreamInfo(2, 48000, "aac"), info.Audio);
Assert.Equal(2, info.CoverStreamIndex);
Assert.Equal([new SubtitleStreamInfo(3, "subrip", "kor")], info.Subtitles);
var raw = MediaInfo.Parse("""{ "streams": [ { "index": 0, "codec_type": "audio", "channels": 1, "sample_rate": "8000" } ], "format": {} }""");
Assert.Null(raw.Duration);
Assert.Null(raw.Video);
}
[Fact]
public void Probe_skips_audio_ffmpeg_cannot_decode()
{
const string json = """
{ "streams": [
{ "index": 0, "codec_type": "video", "codec_name": "h264" },
{ "index": 1, "codec_type": "audio", "codec_name": "apple_apac", "channels": 4, "sample_rate": "48000" },
{ "index": 2, "codec_type": "audio", "codec_name": "aac", "channels": 0, "sample_rate": "0" },
{ "index": 3, "codec_type": "audio", "codec_name": "aac", "channels": 2, "sample_rate": "48000", "sample_fmt": "fltp" },
{ "index": 4, "codec_type": "audio", "channels": 2 }
] }
""";
var decodable = new HashSet<string> { "h264", "aac" };
var info = MediaInfo.Parse(json, decodable);
Assert.Equal(new AudioStreamInfo(0, 0, "aac", 1), info.Audio);
Assert.Equal([1, 2], info.AudioTracks.Select(t => t.Ordinal));
var unknown = MediaInfo.Parse(json);
Assert.Equal(new AudioStreamInfo(4, 48000, "apple_apac"), unknown.Audio);
Assert.Equal([0, 1, 2, 3], unknown.AudioTracks.Select(t => t.Ordinal));
var only = MediaInfo.Parse("""
{ "streams": [{ "codec_type": "audio", "codec_name": "apple_apac", "channels": 4, "sample_rate": "48000" }] }
""", decodable);
Assert.Equal(new AudioStreamInfo(4, 48000, "apple_apac"), only.Audio);
Assert.Equal([0], only.AudioTracks.Select(t => t.Ordinal));
var unnamed = MediaInfo.Parse("""{ "streams": [{ "codec_type": "audio", "channels": 2 }] }""", decodable);
Assert.Equal(0, unnamed.Audio!.Ordinal);
Assert.Equal([0], unnamed.AudioTracks.Select(t => t.Ordinal));
}
[Fact]
public void Ffmpeg_progress_and_errors_are_read()
{
Assert.Equal(2.5, FfmpegRunner.ParsePosition("out_time_us=2500000"));
Assert.Null(FfmpegRunner.ParsePosition("out_time_us=N/A"));
Assert.Equal(1.25, FfmpegRunner.ParsePosition("frame_time=1.25"));
Assert.Null(FfmpegRunner.ParsePosition("progress=continue"));
Assert.Equal("too many channels: got 6, need 2 or fewer Error while opening encoder",
FfmpegRunner.Summarize("[wmav2 @ 000001e0] too many channels: got 6, need 2 or fewer\r\n" +
"[aost#0:1/wmav2 @ 000001e0] [enc:wmav2 @ 000001e0] Error while opening encoder\r\n"));
}
// ───────────────────────── Real conversions ─────────────────────────
/// <summary>Writes a test clip with FFmpeg: moving test pattern (+ a 440 Hz tone unless <paramref name="audio"/> is false).</summary>
private static async Task<string> MakeClipAsync(string folder, string name, double seconds = 2, string size = "320x240", int fps = 25,
bool audio = true, int channels = 2, params string[] extra)
{
var path = Path.Combine(folder, name);
List<string> args =
[
"-hide_banner", "-nostdin", "-v", "error", "-y",
"-f", "lavfi", "-i", $"testsrc2=size={size}:rate={fps}:duration={seconds.ToString(CultureInfo.InvariantCulture)}",
];
if (audio)
args.AddRange(["-f", "lavfi", "-i", $"sine=frequency=440:sample_rate=44100:duration={seconds.ToString(CultureInfo.InvariantCulture)}",
"-ac", channels.ToString(CultureInfo.InvariantCulture)]);
args.AddRange(extra);
args.Add(path);
await RunAsync(Tools!.Value.Ffmpeg, args);
return path;
}
/// <summary>A WAV tone (44.1 kHz stereo).</summary>
private static async Task<string> MakeToneAsync(string folder, string name, double seconds = 2)
{
var path = Path.Combine(folder, name);
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi",
"-i", $"sine=frequency=440:sample_rate=44100:duration={seconds.ToString(CultureInfo.InvariantCulture)}", "-ac", "2", path]);
return path;
}
private static async Task RunAsync(string exe, IEnumerable<string> args)
{
var result = await ProcessRunner.RunAsync(exe, args, TimeSpan.FromMinutes(2), CancellationToken.None);
Assert.True(result.ExitCode == 0, result.StandardError);
}
/// <summary>What ffprobe sees in a file.</summary>
private sealed record Probed(double Duration, List<Track> Streams)
{
public Track? Video => Streams.FirstOrDefault(s => s.Type == "video" && !s.Cover);
public Track? Audio => Streams.FirstOrDefault(s => s.Type == "audio");
}
private sealed record Track(string Type, string Codec, int Width, int Height, int Channels, int SampleRate, long BitRate, bool Cover, int Frames);
private static async Task<Probed> ProbeAsync(string path)
{
var result = await ProcessRunner.RunAsync(Tools!.Value.Ffprobe,
["-v", "error", "-count_frames", "-print_format", "json", "-show_format", "-show_streams", path],
TimeSpan.FromMinutes(1), CancellationToken.None);
Assert.True(result.ExitCode == 0, $"ffprobe {path}: {result.StandardError}");
using var json = JsonDocument.Parse(result.StandardOutput);
static string S(JsonElement e, string name) => e.TryGetProperty(name, out var v) ? v.ToString() : "";
static long N(JsonElement e, string name) => long.TryParse(S(e, name), out var n) ? n : 0;
var streams = json.RootElement.GetProperty("streams").EnumerateArray().Select(s => new Track(
S(s, "codec_type"), S(s, "codec_name"), (int)N(s, "width"), (int)N(s, "height"), (int)N(s, "channels"),
(int)N(s, "sample_rate"), N(s, "bit_rate"),
s.TryGetProperty("disposition", out var d) && d.TryGetProperty("attached_pic", out var a) && a.GetInt32() == 1,
(int)N(s, "nb_read_frames"))).ToList();
var duration = double.TryParse(S(json.RootElement.GetProperty("format"), "duration"), NumberStyles.Float, CultureInfo.InvariantCulture, out var d2) ? d2 : 0;
return new Probed(duration, streams);
}
private async Task<string> ConvertAsync(string input, string target, MediaOptions? media = null)
{
var preset = new Preset { TargetFormat = target, Media = media ?? new MediaOptions() };
var job = await fx.ConvertAsync([input], preset);
Assert.True(job.State == JobState.Completed, string.Join("; ", job.Files.Select(f => $"{f.ErrorKey} {f.ErrorDetail}")));
var output = Assert.Single(job.Outputs);
if (!Directory.Exists(output))
Assert.Equal("." + FormatRegistry.Get(target).PrimaryExtension, Path.GetExtension(output));
return output;
}
/// <summary>ffprobe's codec name for each encoder Filee uses.</summary>
private static string Decoded(string encoder) => encoder switch
{
"libx264" => "h264",
"libvpx-vp9" => "vp9",
"libtheora" => "theora",
"libopus" => "opus",
"libmp3lame" => "mp3",
"libvorbis" => "vorbis",
"libopencore_amrnb" => "amr_nb",
_ => encoder,
};
[Theory]
[InlineData("webm")]
[InlineData("mov")]
[InlineData("mkv")]
[InlineData("avi")]
public async Task Mp4_converts_to_other_video_formats(string target)
{
SkipUnlessInstalled();
var source = await MakeClipAsync(fx.NewFolder(), "clip.mp4");
var probed = await ProbeAsync(await ConvertAsync(source, target));
var spec = MediaEncoding.VideoTargets[target];
Assert.Equal(Decoded(spec.VideoCodec!), probed.Video?.Codec);
Assert.Equal(Decoded(spec.AudioCodec), probed.Audio?.Codec);
Assert.Equal((320, 240), (probed.Video!.Width, probed.Video.Height));
Assert.InRange(probed.Duration, 1.7, 2.4);
}
[Fact]
public async Task Every_target_format_is_written_with_the_planned_codecs()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "all.mp4", seconds: 1, size: "160x120");
var failures = new System.Collections.Concurrent.ConcurrentBag<string>();
var targets = MediaEncoding.VideoTargets.Concat(MediaEncoding.AudioTargets).ToList();
await Parallel.ForEachAsync(targets, new ParallelOptions { MaxDegreeOfParallelism = 3 }, async (entry, _) =>
{
var (target, spec) = entry;
try
{
var probed = await ProbeAsync(await ConvertAsync(source, target));
if (spec.VideoCodec is not null && probed.Video?.Codec != Decoded(spec.VideoCodec))
failures.Add($"{target}: video {probed.Video?.Codec}");
if (spec.VideoCodec is null && probed.Video is not null)
failures.Add($"{target}: unexpected video stream");
if (probed.Audio?.Codec != Decoded(spec.AudioCodec))
failures.Add($"{target}: audio {probed.Audio?.Codec}");
if (probed.Duration is < 0.7 or > 1.5)
failures.Add($"{target}: duration {probed.Duration}");
if (target is "vob" or "dv" && probed.Video is { } frame && (frame.Width, frame.Height) != (720, 576)) // 25 fps source = PAL
failures.Add($"{target}: frame {frame.Width}×{frame.Height}");
}
catch (Exception ex)
{
failures.Add($"{target}: {ex.Message}");
}
});
Assert.Empty(failures);
}
[Fact]
public async Task Hevc_and_av1_presets_write_those_codecs_and_keep_ten_bits()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var h264 = await MakeClipAsync(folder, "clip.mp4", seconds: 1, size: "320x240");
// A 10-bit HLG source, like a phone's HDR video.
var hdr = await MakeClipAsync(folder, "hdr.mkv", seconds: 1, size: "320x240",
extra: ["-c:v", "libx265", "-pix_fmt", "yuv420p10le",
"-x265-params", "colorprim=bt2020:transfer=arib-std-b67:colormatrix=bt2020nc:log-level=error"]);
async Task<JsonElement> VideoOf(string file)
{
var result = await ProcessRunner.RunAsync(Tools!.Value.Ffprobe,
["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=codec_name,codec_tag_string,pix_fmt,color_transfer", "-of", "json", file],
TimeSpan.FromMinutes(1), CancellationToken.None);
return JsonDocument.Parse(result.StandardOutput).RootElement.GetProperty("streams")[0].Clone();
}
var hevc = await VideoOf(await ConvertAsync(h264, "mp4", new MediaOptions { VideoCodec = VideoCodec.Hevc }));
Assert.Equal(("hevc", "hvc1", "yuv420p"), (hevc.GetProperty("codec_name").GetString(), hevc.GetProperty("codec_tag_string").GetString(), hevc.GetProperty("pix_fmt").GetString()));
var av1 = await VideoOf(await ConvertAsync(hdr, "mp4", new MediaOptions { VideoCodec = VideoCodec.Av1 }));
Assert.Equal(("av1", "yuv420p10le", "arib-std-b67"), (av1.GetProperty("codec_name").GetString(), av1.GetProperty("pix_fmt").GetString(), av1.GetProperty("color_transfer").GetString()));
var webm = await VideoOf(await ConvertAsync(h264, "webm", new MediaOptions { VideoCodec = VideoCodec.Av1, Quality = MediaQuality.Small }));
Assert.Equal("av1", webm.GetProperty("codec_name").GetString());
}
[Fact]
public async Task Alac_speex_and_dts_are_written_and_read()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var tone = await MakeToneAsync(folder, "tone.wav");
var alac = await ProbeAsync(await ConvertAsync(tone, "m4a", new MediaOptions { AudioCodec = AudioCodec.Alac }));
Assert.Equal("alac", alac.Audio?.Codec);
Assert.InRange(alac.Duration, 1.9, 2.1);
// Formats Filee only reads, made with FFmpeg's own encoders (DTS's is experimental), then converted.
var spx = Path.Combine(folder, "voice.spx");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-i", tone, "-ar", "16000", "-ac", "1", "-c:a", "libspeex", "-f", "ogg", spx]);
var dts = Path.Combine(folder, "surround.dts");
await RunAsync(Tools.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-i", tone, "-ar", "48000", "-c:a", "dca", "-strict", "-2", "-f", "dts", dts]);
Assert.Equal("pcm_s16le", (await ProbeAsync(await ConvertAsync(spx, "wav"))).Audio?.Codec);
Assert.Equal("flac", (await ProbeAsync(await ConvertAsync(dts, "flac"))).Audio?.Codec);
Assert.Equal("wavpack", (await ProbeAsync(await ConvertAsync(dts, "wv"))).Audio?.Codec);
}
[Fact]
public async Task An_iphone_hdr_mov_is_rewrapped_into_mp4_without_re_encoding()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// Like an iPhone video: HEVC Main 10 with HLG (BT.2020) in MOV, recorded sideways with a display matrix, AAC sound.
var hevc = await MakeClipAsync(folder, "hevc.mov", seconds: 2, size: "640x360",
extra: ["-c:v", "libx265", "-pix_fmt", "yuv420p10le",
"-x265-params", "colorprim=bt2020:transfer=arib-std-b67:colormatrix=bt2020nc:log-level=error", "-c:a", "aac"]);
var phone = Path.Combine(folder, "phone.mov");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-display_rotation", "90", "-i", hevc, "-c", "copy", phone]);
var mp4 = await ConvertAsync(phone, "mp4");
var result = await ProcessRunner.RunAsync(Tools.Value.Ffprobe,
["-v", "error", "-show_entries", "stream=codec_type,codec_name,codec_tag_string,pix_fmt,color_transfer,nb_frames:stream_side_data=rotation",
"-of", "json", mp4], TimeSpan.FromMinutes(1), CancellationToken.None);
using var json = JsonDocument.Parse(result.StandardOutput);
var video = json.RootElement.GetProperty("streams").EnumerateArray().Single(s => s.GetProperty("codec_type").GetString() == "video");
Assert.Equal("hevc", video.GetProperty("codec_name").GetString());
Assert.Equal("hvc1", video.GetProperty("codec_tag_string").GetString());
Assert.Equal("yuv420p10le", video.GetProperty("pix_fmt").GetString()); // 10-bit HDR kept
Assert.Equal("arib-std-b67", video.GetProperty("color_transfer").GetString());
Assert.Contains("rotation", video.GetProperty("side_data_list").ToString()); // still shown upright
Assert.Equal("50", video.GetProperty("nb_frames").GetString()); // every frame, none re-encoded or dropped
// The coded pictures are the source's, byte for byte.
async Task<string> Hash(string file)
{
var hash = await ProcessRunner.RunAsync(Tools.Value.Ffmpeg,
["-hide_banner", "-v", "error", "-i", file, "-map", "0:v", "-c", "copy", "-f", "hash", "-hash", "md5", "-"],
TimeSpan.FromMinutes(1), CancellationToken.None);
return hash.StandardOutput.Trim();
}
Assert.Equal(await Hash(phone), await Hash(mp4));
}
[Fact]
public async Task Video_becomes_an_animated_gif_and_back()
{
SkipUnlessInstalled();
var source = await MakeClipAsync(fx.NewFolder(), "anim.mp4", size: "640x360");
var gif = await ConvertAsync(source, "gif");
var probed = await ProbeAsync(gif);
Assert.Equal("gif", probed.Video?.Codec);
Assert.Equal((480, 270), (probed.Video!.Width, probed.Video.Height)); // Balanced: at most 480 px wide
Assert.InRange(probed.Video.Frames, 20, 30); // 2 s at 12 fps
Assert.Null(probed.Audio);
// GIF → MP4.
var mp4 = await ProbeAsync(await ConvertAsync(gif, "mp4"));
Assert.Equal("h264", mp4.Video?.Codec);
Assert.Equal((480, 270), (mp4.Video!.Width, mp4.Video.Height));
Assert.InRange(mp4.Duration, 1.5, 2.5);
}
[Fact]
public async Task Video_becomes_an_apng_and_back()
{
SkipUnlessInstalled();
var source = await MakeClipAsync(fx.NewFolder(), "anim.mp4", seconds: 1, size: "640x360", audio: false);
var apng = await ConvertAsync(source, "apng");
var probed = await ProbeAsync(apng);
Assert.Equal("apng", probed.Video?.Codec);
Assert.Equal((480, 270), (probed.Video!.Width, probed.Video.Height)); // Balanced: at most 480 px wide
Assert.InRange(probed.Video.Frames, 10, 15); // 1 s at 12 fps
// Filee's own reader takes FFmpeg's APNG: every frame, as GIF.
var gif = await ConvertAsync(apng, "gif");
using (var frames = new ImageMagick.MagickImageCollection(gif))
Assert.Equal(probed.Video.Frames, frames.Count);
// APNG → MP4 straight through FFmpeg.
var mp4 = await ProbeAsync(await ConvertAsync(apng, "mp4"));
Assert.Equal("h264", mp4.Video?.Codec);
Assert.InRange(mp4.Duration, 0.7, 1.3);
}
[Fact]
public async Task Ffmpeg_reads_the_apng_filee_writes()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var gif = Path.Combine(folder, "anim.gif");
using (var frames = new ImageMagick.MagickImageCollection())
{
foreach (var color in new[] { ImageMagick.MagickColors.Red, ImageMagick.MagickColors.Lime, ImageMagick.MagickColors.Blue })
frames.Add(new ImageMagick.MagickImage(color, 64, 48) { AnimationDelay = 20 });
frames.Write(gif, ImageMagick.MagickFormat.Gif);
}
var apng = await ConvertAsync(gif, "apng");
var probed = await ProbeAsync(apng);
Assert.Equal("apng", probed.Video?.Codec);
Assert.Equal((64, 48, 3), (probed.Video!.Width, probed.Video.Height, probed.Video.Frames));
// FFmpeg takes the frame delays: three frames of 0.2 s make a 0.6 s video.
var mp4 = await ProbeAsync(await ConvertAsync(apng, "mp4"));
Assert.InRange(mp4.Duration, 0.5, 0.75);
}
[Fact]
public async Task A_photo_becomes_a_still_video_in_full_colour()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// Odd-sized gradient with a transparent corner, as a JPG (→ PNG → MOV) and a PNG (→ WEBM).
var png = EngineFixture.MakeImage(folder, "photo.png", ImageMagick.MagickFormat.Png, 1001, 751);
var jpg = Path.Combine(folder, "photo.jpg");
using (var source = new ImageMagick.MagickImage(png))
source.Write(jpg, ImageMagick.MagickFormat.Jpeg);
foreach (var (input, target, codec) in new[] { (jpg, "mov", "h264"), (png, "webm", "vp9") })
{
var video = await ConvertAsync(input, target);
var probed = await ProbeAsync(video);
Assert.Equal(codec, probed.Video?.Codec);
Assert.Equal((1000, 750), (probed.Video!.Width, probed.Video.Height));
Assert.InRange(probed.Duration, 4.9, 5.1);
Assert.Null(probed.Audio);
var frame = Path.Combine(folder, $"frame-{target}.png");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-i", video, "-frames:v", "1", frame]);
using var picture = new ImageMagick.MagickImage(frame);
// Colours stay put (BT.709 both ways): the middle is halfway between #7F77DD and #1D9E75.
var middle = picture.GetPixels().GetPixel(500, 375).ToColor()!;
Assert.InRange(middle.R, 0x4E - 6, 0x4E + 6);
Assert.InRange(middle.G, 0x8A - 6, 0x8A + 6);
Assert.InRange(middle.B, 0xA9 - 6, 0xA9 + 6);
if (target == "webm")
Assert.True(picture.GetPixels().GetPixel(10, 10).ToColor()!.R < 16, "the transparent corner turns black");
}
// Every colour of a 64-level colour cube: a GIF on the way would leave at most 256 of them.
var cube = Path.Combine(folder, "cube.png");
using (var colours = new ImageMagick.MagickImage("hald:8"))
colours.Write(cube);
var cubeFrame = Path.Combine(folder, "frame-cube.png");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-i", await ConvertAsync(cube, "mp4"), "-frames:v", "1", cubeFrame]);
using var cubePicture = new ImageMagick.MagickImage(cubeFrame);
Assert.True(cubePicture.TotalColors > 10_000, $"{cubePicture.TotalColors} colours");
}
[Fact]
public async Task Video_gives_a_still_frame_for_images()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// Anamorphic 4:3 DV-style video: 720×480 pixels that are shown narrower than they are stored.
var source = await MakeClipAsync(folder, "still.mkv", seconds: 3, size: "720x480", extra: ["-vf", "setsar=8/9"]);
var png = await ProbeAsync(await ConvertAsync(source, "png"));
Assert.Equal("png", png.Video?.Codec);
Assert.Equal((640, 480), (png.Video!.Width, png.Video.Height)); // square pixels
var jpg = await ConvertAsync(source, "jpg");
using var image = new ImageMagick.MagickImage(jpg);
Assert.Equal((640u, 480u), (image.Width, image.Height));
}
[Fact]
public async Task Video_to_image_slices_frames_to_unique_subfolders()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "seq.mkv", seconds: 2, size: "640x360");
var options = new MediaOptions { SaveEveryFrame = true };
var pngFolder1 = await ConvertAsync(source, "png", options);
Assert.True(Directory.Exists(pngFolder1));
Assert.Equal(Path.Combine(folder, "seq_frames"), pngFolder1);
var png1Files = Directory.GetFiles(pngFolder1, "frame_*.png");
Assert.NotEmpty(png1Files);
Assert.Contains(png1Files, f => Path.GetFileName(f) == "frame_000001.png");
// A second run creates a unique folder seq_frames (2) instead of writing into an existing one.
var pngFolder2 = await ConvertAsync(source, "png", options);
Assert.True(Directory.Exists(pngFolder2));
Assert.Equal(Path.Combine(folder, "seq_frames (2)"), pngFolder2);
Assert.NotEmpty(Directory.GetFiles(pngFolder2, "frame_*.png"));
// JPG sequence extraction also creates unique folder and valid images
var jpgFolder = await ConvertAsync(source, "jpg", options);
Assert.True(Directory.Exists(jpgFolder));
Assert.Equal(Path.Combine(folder, "seq_frames (3)"), jpgFolder);
var jpgFiles = Directory.GetFiles(jpgFolder, "frame_*.jpg");
Assert.NotEmpty(jpgFiles);
Assert.Contains(jpgFiles, f => Path.GetFileName(f) == "frame_000001.jpg");
using var image = new ImageMagick.MagickImage(jpgFiles.First());
Assert.True(image.Width > 0 && image.Height > 0);
}
[Fact]
public void Video_frame_sequence_arguments_use_proper_flags()
{
var video = new VideoStreamInfo(720, 480, 8.0 / 9.0, 0, 30);
var jpg = MediaEncoding.FrameSequence("in.mp4", "out_frames/frame_%06d.jpg", "jpg", video, quality: 100, frameInterval: 5);
Assert.Contains("-q:v", jpg);
Assert.Equal("2", After(jpg, "-q:v"));
Assert.Contains("-vf", jpg);
var vf = After(jpg, "-vf");
Assert.Contains("scale=w='trunc(iw*sar/2)*2':h=ih,setsar=1", vf);
Assert.Contains("select='not(mod(n\\,5))'", vf);
Assert.Contains("-fps_mode", jpg);
Assert.Equal("vfr", After(jpg, "-fps_mode"));
Assert.Equal("out_frames/frame_%06d.jpg", jpg[^1]);
Assert.Equal("0:V:0", After(jpg, "-map"));
// Every frame: each decoded frame once, never paced to a constant rate.
var every = MediaEncoding.FrameSequence("in.mp4", "out_frames/frame_%06d.png", "png", video);
Assert.Equal("passthrough", After(every, "-fps_mode"));
Assert.Equal("0:V:0", After(every, "-map"));
Assert.Equal("png", After(every, "-c:v"));
Assert.DoesNotContain("-q:v", every);
Assert.EndsWith("setsar=1,null", After(every, "-vf")); // square pixels, no frame left out
Assert.Equal("out_frames/frame_%06d.png", every[^1]);
}
[Fact]
public void Every_frame_is_estimated_before_anything_is_written()
{
var hd = new VideoStreamInfo(1920, 1080, 1, 0, 30);
var hour = new MediaInfo(TimeSpan.FromHours(1), hd, null, null);
// An hour at 30 fps: 108,000 pictures, over the limit; every second frame is fine.
Assert.Equal(108_000, FrameSequenceWriter.EstimatedFrames(hour, 1));
Assert.Equal(54_000, FrameSequenceWriter.EstimatedFrames(hour, 2));
Assert.True(FrameSequenceWriter.EstimatedFrames(hour, 1) > MediaOptions.MaxFrames);
// Unknown duration or frame rate: no estimate, no refusal.
Assert.Null(FrameSequenceWriter.EstimatedFrames(hour with { Duration = null }, 1));
Assert.Null(FrameSequenceWriter.EstimatedFrames(hour with { Video = hd with { FrameRate = 0 } }, 1));
// Full HD: about 3 MB a PNG, half a MB a JPG; 10-bit video becomes 16-bit PNG, twice the size.
Assert.Equal(3_110_400, FrameSequenceWriter.EstimatedBytes(hd, "png", 1));
Assert.Equal(518_400, FrameSequenceWriter.EstimatedBytes(hd, "jpg", 1));
Assert.Equal(6_220_800, FrameSequenceWriter.EstimatedBytes(hd with { PixelFormat = "yuv420p10le" }, "png", 1));
}
[Fact]
public async Task Every_frame_of_a_variable_frame_rate_video_is_saved_once()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// One second at 30 fps, then three seconds at 10 fps: 60 frames, as a phone records a darker scene. Paced to a
// constant 30 fps the slow part would come out three times over (120 pictures).
var source = Path.Combine(folder, "vfr.mkv");
await RunAsync(Tools!.Value.Ffmpeg,
[
"-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc2=size=160x120:rate=30:duration=2",
"-vf", "setpts='if(lt(N,30),N/30,1+(N-30)/10)/TB'", "-fps_mode", "vfr", "-c:v", "libx264", "-pix_fmt", "yuv420p", source,
]);
var decoded = (await ProbeAsync(source)).Video!.Frames;
Assert.Equal(60, decoded);
var frames = await ConvertAsync(source, "png", new MediaOptions { SaveEveryFrame = true });
Assert.Equal(decoded, Directory.GetFiles(frames, "*.png").Length);
}
[Fact]
public async Task Odd_sized_surround_video_is_encoded_everywhere()
{
SkipUnlessInstalled();
// 321×241 at 15 fps with 6 channels: odd sizes, a rate MPEG-2 cannot store and more channels than WMA/MP3 hold.
var source = await MakeClipAsync(fx.NewFolder(), "odd.mkv", size: "320x240", fps: 15, channels: 6,
extra: ["-vf", "pad=321:241", "-c:v", "libx264", "-pix_fmt", "yuv444p", "-c:a", "aac"]);
foreach (var target in new[] { "mp4", "wmv", "mpg", "avi", "wma", "mp3" })
{
var probed = await ProbeAsync(await ConvertAsync(source, target));
Assert.NotNull(probed.Audio);
if (probed.Video is { } video)
Assert.Equal((320, 240), (video.Width, video.Height));
}
}
[Theory]
[InlineData("mp3", "mp3")]
[InlineData("flac", "flac")]
[InlineData("ogg", "vorbis")]
[InlineData("opus", "opus")]
[InlineData("m4a", "aac")]
public async Task Wav_converts_to_audio_formats(string target, string codec)
{
SkipUnlessInstalled();
var source = await MakeToneAsync(fx.NewFolder(), "tone.wav");
var probed = await ProbeAsync(await ConvertAsync(source, target));
Assert.Equal(codec, probed.Audio?.Codec);
Assert.Equal(2, probed.Audio!.Channels);
Assert.Null(probed.Video);
Assert.InRange(probed.Duration, 1.8, 2.3);
}
[Fact]
public async Task Audio_is_extracted_from_video()
{
SkipUnlessInstalled();
var source = await MakeClipAsync(fx.NewFolder(), "talk.mp4");
var probed = await ProbeAsync(await ConvertAsync(source, "mp3"));
Assert.Equal("mp3", Assert.Single(probed.Streams).Codec);
Assert.InRange(probed.Duration, 1.8, 2.3);
}
[Fact]
public async Task Max_height_scales_down_only()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var hd = await MakeClipAsync(folder, "hd.mp4", seconds: 1, size: "1920x1080", audio: false);
var probed = await ProbeAsync(await ConvertAsync(hd, "mp4", new MediaOptions { MaxHeight = 720 }));
Assert.Equal((1280, 720), (probed.Video!.Width, probed.Video.Height));
var small = await MakeClipAsync(folder, "small.mp4", seconds: 1, size: "320x240", audio: false);
probed = await ProbeAsync(await ConvertAsync(small, "mp4", new MediaOptions { MaxHeight = 720 }));
Assert.Equal((320, 240), (probed.Video!.Width, probed.Video.Height));
}
[Fact]
public async Task Portrait_phone_video_is_rotated_upright()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var landscape = await MakeClipAsync(folder, "landscape.mp4", seconds: 1, size: "640x360");
// Like a phone: landscape pixels plus a display matrix that turns them by 90°.
var phone = Path.Combine(folder, "phone.mp4");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-display_rotation", "90", "-i", landscape, "-c", "copy", phone]);
var probed = await ProbeAsync(await ConvertAsync(phone, "webm", new MediaOptions { MaxHeight = 320 }));
Assert.Equal((180, 320), (probed.Video!.Width, probed.Video.Height));
}
[Fact]
public async Task Remove_audio_and_audio_bitrate_options_apply()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "options.mp4");
var muted = await ProbeAsync(await ConvertAsync(source, "mp4", new MediaOptions { RemoveAudio = true }));
Assert.NotNull(muted.Video);
Assert.Null(muted.Audio);
var tone = await MakeToneAsync(folder, "bitrate.wav");
var mp3 = await ProbeAsync(await ConvertAsync(tone, "mp3", new MediaOptions { AudioBitrateKbps = 128 }));
Assert.Equal(128_000, mp3.Audio!.BitRate);
var m4a = await ProbeAsync(await ConvertAsync(tone, "m4a", new MediaOptions { AudioBitrateKbps = 96 }));
Assert.InRange(m4a.Audio!.BitRate, 70_000, 110_000);
// #37: mono speech Opus at 32 kbit/s, and a WAV for a phone system (mono, 8 kHz, 8-bit).
var opus = await ProbeAsync(await ConvertAsync(tone, "opus", new MediaOptions { AudioBitrateKbps = 32, AudioChannels = 1 }));
Assert.Equal(("opus", 1), (opus.Audio!.Codec, opus.Audio.Channels));
var wav = await ProbeAsync(await ConvertAsync(tone, "wav",
new MediaOptions { AudioChannels = 1, AudioSampleRate = 8000, WavFormat = WavSampleFormat.Pcm8 }));
Assert.Equal(("pcm_u8", 1, 8000), (wav.Audio!.Codec, wav.Audio.Channels, wav.Audio.SampleRate));
var float32 = await ProbeAsync(await ConvertAsync(tone, "wav", new MediaOptions { WavFormat = WavSampleFormat.Float32 }));
Assert.Equal(("pcm_f32le", 2, 44100), (float32.Audio!.Codec, float32.Audio.Channels, float32.Audio.SampleRate));
}
[Fact]
public async Task Video_without_sound_converts_but_has_no_audio_to_extract()
{
SkipUnlessInstalled();
var source = await MakeClipAsync(fx.NewFolder(), "silent.mp4", audio: false);
var probed = await ProbeAsync(await ConvertAsync(source, "webm"));
Assert.Equal("vp9", probed.Video?.Codec);
Assert.Null(probed.Audio);
var job = await fx.ConvertAsync([source], new Preset { TargetFormat = "mp3" });
var file = Assert.Single(job.Files);
Assert.Equal(FileState.Failed, file.State);
Assert.Contains("no audio track", file.ErrorDetail);
Assert.Empty(Directory.GetFiles(Path.GetDirectoryName(source)!, "*.mp3"));
}
[Fact]
public async Task Cover_art_and_tags_are_kept()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var cover = Path.Combine(folder, "cover.png");
await RunAsync(Tools!.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc2=size=200x200", "-frames:v", "1", cover]);
var song = Path.Combine(folder, "song.mp3");
await RunAsync(Tools.Value.Ffmpeg, ["-hide_banner", "-nostdin", "-v", "error", "-y", "-f", "lavfi", "-i", "sine=duration=2", "-i", cover,
"-map", "0:a", "-map", "1:v", "-c:v", "copy", "-disposition:v:0", "attached_pic", "-metadata", "title=노래 제목", song]);
// FLAC and M4A take a picture stream; Opus and Ogg a METADATA_BLOCK_PICTURE comment; MKA an attachment.
foreach (var target in new[] { "flac", "m4a", "opus", "ogg", "mka" })
{
var output = await ConvertAsync(song, target);
var probed = await ProbeAsync(output);
Assert.True(probed.Streams.Any(s => s.Cover && s.Codec == "png"), $"{target}: no cover");
var tags = await ProcessRunner.RunAsync(Tools.Value.Ffprobe,
["-v", "error", "-show_entries", "format_tags=title,major_brand:stream_tags=title", "-of", "json", output],
TimeSpan.FromMinutes(1), CancellationToken.None);
Assert.True(tags.StandardOutput.Contains("노래 제목"), $"{target}: title lost");
}
}
// ───────────────────────── Progress and cancellation ─────────────────────────
private sealed class FolderAllocator(string folder) : IOutputAllocator
{
public List<string> Allocated { get; } = [];
public string? Allocate(string extension, string? suffix = null)
{
var path = Path.Combine(folder, extension.Length == 0 ? $"out{suffix}" : $"out{suffix}.{extension}");
Allocated.Add(path);
return path;
}
}
/// <summary>Records every reported value synchronously (Progress<T> would post to the thread pool).</summary>
private sealed class Recorder(Action<double>? onReport = null) : IProgress<double>
{
public List<double> Values { get; } = [];
public void Report(double value)
{
lock (Values)
Values.Add(value);
onReport?.Invoke(value);
}
}
private static ConversionStep Step(string input, string from, string to, string folder, MediaOptions? media = null) =>
new(input, from, to, new Preset { TargetFormat = to, Media = media ?? new MediaOptions() }, new FolderAllocator(folder), folder);
[Fact]
public async Task Progress_rises_while_ffmpeg_works()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// Long enough for several of FFmpeg's half-second progress reports.
var source = await MakeClipAsync(folder, "long.mp4", seconds: 40, size: "640x360", extra: ["-c:v", "libx264", "-preset", "ultrafast"]);
var converter = new FfmpegConverter();
Assert.True(converter.GetStatus().IsAvailable);
var recorder = new Recorder();
// Small: H.264 + AAC in MKV would otherwise only be rewrapped, which takes too little time to report progress.
var outputs = await converter.ConvertAsync(Step(source, "mp4", "mkv", folder, new MediaOptions { Quality = MediaQuality.Small }), recorder, CancellationToken.None);
Assert.True(File.Exists(Assert.Single(outputs)));
var values = recorder.Values.ToList();
Assert.Equal(1, values[^1]);
Assert.True(values.Zip(values.Skip(1)).All(p => p.First <= p.Second), string.Join(", ", values));
Assert.True(values.Count(v => v is > 0.02 and < 1) >= 3, string.Join(", ", values));
}
[Fact]
public async Task Gif_palette_pass_reports_progress_too()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "gifprogress.mp4", seconds: 30, size: "640x360", audio: false, extra: ["-c:v", "libx264", "-preset", "ultrafast"]);
var recorder = new Recorder();
var converter = new FfmpegConverter();
converter.GetStatus();
await converter.ConvertAsync(Step(source, "mp4", "gif", folder, new MediaOptions { Quality = MediaQuality.Small }), recorder, CancellationToken.None);
// The palette pass covers the first 40 %: values inside it prove its progress is read.
Assert.Contains(recorder.Values, v => v is > 0.05 and < 0.4);
}
[Fact]
public async Task Cancelling_kills_ffmpeg_and_removes_the_partial_output()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "cancel.mp4", seconds: 60, size: "1280x720", extra: ["-c:v", "libx264", "-preset", "ultrafast"]);
using var cancellation = new CancellationTokenSource();
var recorder = new Recorder(v =>
{
if (v > 0.05)
cancellation.Cancel();
});
var converter = new FfmpegConverter();
converter.GetStatus();
var step = Step(source, "mp4", "webm", folder, new MediaOptions { Quality = MediaQuality.High });
cancellation.CancelAfter(TimeSpan.FromSeconds(30)); // in case no progress arrives at all
var watch = Stopwatch.StartNew();
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => converter.ConvertAsync(step, recorder, cancellation.Token));
Assert.True(watch.Elapsed < TimeSpan.FromSeconds(60), "VP9 encoding of the whole clip should not have finished");
var output = Assert.Single(((FolderAllocator)step.Output).Allocated);
Assert.False(File.Exists(output));
// No FFmpeg of ours is left running (it would keep the CPU busy and the output locked).
var deadline = Stopwatch.StartNew();
while (RunningFfmpeg(Tools!.Value.Ffmpeg) && deadline.Elapsed < TimeSpan.FromSeconds(10))
await Task.Delay(200, TestContext.Current.CancellationToken);
Assert.False(RunningFfmpeg(Tools.Value.Ffmpeg));
}
[Fact]
public async Task Cancelling_every_frame_leaves_no_pictures_behind()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "cancelframes.mp4", seconds: 60, size: "1280x720", audio: false,
extra: ["-c:v", "libx264", "-preset", "ultrafast"]);
using var cancellation = new CancellationTokenSource();
var recorder = new Recorder(v =>
{
if (v > 0.05)
cancellation.Cancel();
});
var converter = new FfmpegConverter();
converter.GetStatus();
var preset = new Preset { TargetFormat = "png", Media = { SaveEveryFrame = true } };
var step = new ConversionStep(source, "mp4", "png", preset, new FolderAllocator(folder), folder, FrameSequence: true);
cancellation.CancelAfter(TimeSpan.FromSeconds(30)); // in case no progress arrives at all
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => converter.ConvertAsync(step, recorder, cancellation.Token));
// Neither the output folder nor the hidden one the frames were written into is left, and FFmpeg has ended.
Assert.Equal([Path.Combine(folder, "out_frames")], ((FolderAllocator)step.Output).Allocated);
Assert.Equal([source], Directory.GetFileSystemEntries(folder));
Assert.False(RunningFfmpeg(Tools!.Value.Ffmpeg));
}
[Fact]
public async Task Every_frame_goes_into_its_own_folder_named_like_other_outputs()
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
var source = await MakeClipAsync(folder, "100% clip.mkv", seconds: 1, size: "160x120", fps: 10, audio: false);
var preset = new Preset { TargetFormat = "jpg", Media = { SaveEveryFrame = true } };
var first = Assert.Single((await fx.ConvertAsync([source], preset)).Outputs);
var second = Assert.Single((await fx.ConvertAsync([source], preset)).Outputs);
preset.Output.Conflict = ConflictPolicy.Skip;
var skipped = await fx.ConvertAsync([source], preset);
Assert.Equal(Path.Combine(folder, "100% clip_frames"), first);
Assert.Equal(Path.Combine(folder, "100% clip_frames (2)"), second);
Assert.Empty(skipped.Outputs);
Assert.Equal(FileState.Skipped, skipped.Files.Single().State);
Assert.Equal(10, Directory.GetFiles(first, "frame_*.jpg").Length);
Assert.False(new DirectoryInfo(first).Attributes.HasFlag(FileAttributes.Hidden));
// Nothing else next to the source: no hidden folder left over.
Assert.Equal(3, Directory.GetFileSystemEntries(folder).Length);
}
/// <summary>
/// True if a process started from <paramref name="exe"/> is running (tests of this class run one at a time, so
/// it can only be the one that should have been killed).
/// </summary>
private static bool RunningFfmpeg(string exe)
{
foreach (var process in Process.GetProcessesByName(Path.GetFileNameWithoutExtension(exe)))
{
using (process)
{
try
{
if (!process.HasExited && string.Equals(process.MainModule?.FileName, exe, StringComparison.OrdinalIgnoreCase))
return true;
}
catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception)
{
// Exited meanwhile or belongs to another user: not ours.
}
}
}
return false;
}
// ───────────────────────── Video CD (issue #292) ─────────────────────────
[Theory]
[InlineData("mp4")]
[InlineData("mkv")]
public async Task A_video_cd_dat_file_converts_with_its_picture_and_sound(string target)
{
SkipUnlessInstalled();
var folder = fx.NewFolder();
// A Video CD keeps its MPEG-1 streams in MPEGAV/AVSEQ01.DAT.
var input = Path.Combine(folder, "AVSEQ01.DAT");
var create = await ProcessRunner.RunAsync(Tools!.Value.Ffmpeg,
["-hide_banner", "-loglevel", "error", "-f", "lavfi", "-i", "testsrc2=size=352x288:rate=25",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=44100", "-t", "0.4",
"-target", "pal-vcd", "-f", "mpeg", input], TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken);
Assert.True(create.ExitCode == 0, create.StandardError);
Assert.Equal("mpg", FormatRegistry.Detect(input)?.Id);
var job = await fx.ConvertAsync([input], new Preset { TargetFormat = target });
Assert.True(job.State == JobState.Completed, string.Join("; ", job.Files.Select(f => f.ErrorDetail)));
var decode = await ProcessRunner.RunAsync(Tools.Value.Ffmpeg,
["-v", "error", "-i", Assert.Single(job.Outputs), "-map", "0:v:0", "-map", "0:a:0", "-f", "null", "-"],
TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken);
Assert.True(decode.ExitCode == 0, decode.StandardError);
}
[Fact]
public async Task A_dat_file_that_is_no_video_fails()
{
SkipUnlessInstalled();
var input = Path.Combine(fx.NewFolder(), "database.dat");
await File.WriteAllTextAsync(input, "This is application data, not a video.", TestContext.Current.CancellationToken);
var job = await fx.ConvertAsync([input], new Preset { TargetFormat = "mp4" });
Assert.Equal(JobState.Failed, job.State);
Assert.Empty(job.Outputs);
}
}