using System.Text; using Titano.Core.Diagnostics.Synthetic; using Titano.Core.Export; using Titano.Core.Imaging; using Titano.Core.Imaging.Decoders; using Titano.Core.Localization; using Titano.Core.Model; using Titano.Core.Project; using Titano.Data.Jobs; using Titano.Data.Processing; using Titano.Testing; namespace Titano.Data.Tests.Processing; [Category("processing")] public sealed class RenderJobTests(TestContext context) { private const int Frames = 24; /// MJPEG at the source size, named by codec so the tests know the file names. private static readonly ExportSettings Mjpeg = new() { Preset = new Auto().WithManual("mjpeg-avi"), Overrides = new ExportOverrides { Width = 96, Height = 64 }, NameTemplate = "clip-{codec}", }; private static SyntheticSequence Scene() => SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = Frames, StartEv = 0.5, EndEv = -0.5 }); [Test] public async Task ABatchWritesPlayableManagedOutputsIntoExportsAndRecordsThem() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Scene()); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["png-sequence", "gif-preview"] }, 96, 64)); await fx.WaitForAsync(job.Id, JobState.Done); var exports = fx.Folder(sequence).Exports; var avi = await File.ReadAllBytesAsync(Path.Combine(exports, "clip-MJPEG.avi"), fx.Ct); Assert.Equal(("RIFF", "AVI "), (Encoding.ASCII.GetString(avi, 0, 4), Encoding.ASCII.GetString(avi, 8, 4))); Assert.Contains("idx1", Encoding.ASCII.GetString(avi)); var pngs = Directory.GetFiles(Path.Combine(exports, "clip-PNG")).Order().ToList(); Assert.Equal(Frames, pngs.Count); Assert.Equal("clip-PNG_000001.png", Path.GetFileName(pngs[0])); using (var decoded = DecoderFactory.CreateServer().Decode(new DecodeRequest(pngs[^1]))) Assert.Equal((96, 64), (Assert.NotNull(decoded).Pixels.Width, decoded.Pixels.Height)); var gif = await File.ReadAllBytesAsync(Path.Combine(exports, "clip-GIF.gif"), fx.Ct); Assert.Equal("GIF89a", Encoding.ASCII.GetString(gif, 0, 6)); Assert.Empty(Directory.EnumerateFileSystemEntries(exports, ".*")); var renders = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).OrderBy(r => r.OutputPath, StringComparer.Ordinal).ToList(); Assert.SequenceEqual(["Synthetic/exports/clip-GIF.gif", "Synthetic/exports/clip-MJPEG.avi", "Synthetic/exports/clip-PNG"], renders.Select(r => r.OutputPath)); var mjpeg = renders[1]; Assert.Equal((Loc.L("Export.Preset.Custom"), "Mjpeg", 96, 64, "test-pc", (long)avi.Length), (mjpeg.PresetName, mjpeg.Codec, mjpeg.Width, mjpeg.Height, mjpeg.ProducedBy, mjpeg.Bytes)); Assert.Equal(Loc.L("Export.Preset.Gif"), renders[0].PresetName); Assert.Equal(3, (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.RenderedCount); } [Test] public async Task ACancelledRenderLeavesNothingBehind() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Scene()); fx.Decoder.HoldFrame(12, DecodePurpose.Render); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); await fx.Engine.CancelAsync(job.Id, fx.Ct); await fx.WaitForAsync(job.Id, JobState.Cancelled); await WaitUntilIdleAsync(fx, job.Id); Assert.Empty(Entries(fx.Folder(sequence).Exports)); Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } [Test] public async Task AFailedRenderLeavesNothingBehindAndSaysWhy() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Scene()); // Damaged after indexing: nothing flags the frame, so only decoding finds out. await File.WriteAllBytesAsync(Path.Combine(fx.Archive.Paths.Root, "Synthetic", ProcessingFixture.FileName(10)), new byte[5000], fx.Ct); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); var failed = await fx.WaitForAsync(job.Id, JobState.Failed); Assert.Equal(Loc.L(SequenceFrameSource.FrameUnreadableKey, "11", ProcessingFixture.FileName(10)), failed.Error); Assert.Empty(Entries(fx.Folder(sequence).Exports)); Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } [Test] public async Task ARenderInterruptedByACrashStartsItsOutputAgainCleanly() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Scene()); var exports = fx.Folder(sequence).Exports; var output = Path.Combine(exports, "clip-MJPEG.avi"); // The crashed attempt left its encoder's temporary file and a finished output it never recorded. Directory.CreateDirectory(exports); await File.WriteAllBytesAsync(Path.Combine(exports, ".clip-MJPEG.avi.0badf00d.tmp"), new byte[100], fx.Ct); await File.WriteAllBytesAsync(output, new byte[100], fx.Ct); await fx.StartEngineAsync(); var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["gif-preview"] }, 96, 64), new RenderCheckpoint([], 0, output).ToJson()); await fx.WaitForAsync(job.Id, JobState.Done); Assert.SequenceEqual(["clip-GIF.gif", "clip-MJPEG.avi"], Entries(exports)); Assert.Equal("RIFF", Encoding.ASCII.GetString((await File.ReadAllBytesAsync(output, fx.Ct))[..4])); Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } [Test] public async Task ARenderInterruptedAfterRecordingAnOutputResumesWithTheNextOne() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Scene()); var exports = fx.Folder(sequence).Exports; var output = Path.Combine(exports, "clip-MJPEG.avi"); Directory.CreateDirectory(exports); var recorded = Encoding.ASCII.GetBytes("RIFF recorded before the crash"); await File.WriteAllBytesAsync(output, recorded, fx.Ct); await fx.Db.Renders.InsertAsync(new Render { Id = Guid.CreateVersion7(), SequenceId = sequence.Id, PresetName = "MJPEG", OutputPath = "Synthetic/exports/clip-MJPEG.avi", Created = DateTimeOffset.UtcNow, }, fx.Ct); await fx.StartEngineAsync(); var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg with { Batch = ["gif-preview"] }, 96, 64), new RenderCheckpoint([], 0, output).ToJson()); await fx.WaitForAsync(job.Id, JobState.Done); var kept = await File.ReadAllBytesAsync(output, fx.Ct); Assert.BytesEqual(recorded, kept); Assert.SequenceEqual(["clip-GIF.gif", "clip-MJPEG.avi"], Entries(exports)); Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } [Test] public async Task AServerTakesOnlyTheRendersItsManagedEncodersProduce() { await using var fx = await ProcessingFixture.CreateAsync(context); var server = new ProcessingService(fx.Db, new ProcessingOptions { Host = EncoderHost.Server }); var handler = Assert.NotNull(server.CreateJobHandlers().Single(h => h.Kind == JobKind.Render) as ISelectiveJobHandler); var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic" }; bool Accepts(ExportSettings export) => handler.Accepts(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = ProcessingJobs.Render(sequence, export, 96, 64).ParametersJson }); Assert.True(Accepts(Mjpeg with { Batch = ["png-sequence", "gif-preview"] }), "managed outputs only"); Assert.False(Accepts(new ExportSettings { Preset = new Auto().WithManual("4k-hevc") }), "HEVC needs a render node"); Assert.False(Accepts(Mjpeg with { Batch = ["1080p-h264"] }), "one MP4 in the batch"); Assert.True(handler.Accepts(new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, ParametersJson = "{}" }), "unreadable: fails with its reason"); var client = new ProcessingService(fx.Db).CreateJobHandlers().Single(h => h.Kind == JobKind.Render); Assert.False(client is ISelectiveJobHandler, "a client renders whatever it is given"); } [Test] public void ABatchForAServerBecomesOneJobPerPreset() { var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = Guid.CreateVersion7(), Folder = "Synthetic", Title = "Roof" }; var jobs = ProcessingJobs.RenderEach(sequence, Mjpeg with { Batch = ["mjpeg-avi", "gif-preview", "GIF-preview", "4k-hevc"] }, 96, 64); var parameters = jobs.Select(j => System.Text.Json.JsonSerializer.Deserialize(j.ParametersJson!, Titano.Protocol.ProtocolJson.Default.RenderJobParameters)!).ToList(); Assert.SequenceEqual(["mjpeg", "gif", "hevc"], parameters.Select(p => p.Codec)); Assert.True(jobs.All(j => j.Kind == JobKind.Render && j.Targets.SequenceEqual([sequence.Id])), "render jobs of the sequence"); Assert.True(parameters.All(p => ProcessingJobs.ReadExport(p.PresetJson).Batch.Count == 0), "no job carries a batch"); Assert.Equal((3840, 2160), (parameters[2].Width, parameters[2].Height)); } private static List Entries(string folder) => Directory.Exists(folder) ? [.. Directory.EnumerateFileSystemEntries(folder).Select(e => Path.GetFileName(e)).Order(StringComparer.Ordinal)] : []; /// The engine marks a job cancelled before its handler has unwound; wait until the worker let it go. private static async Task WaitUntilIdleAsync(ProcessingFixture fx, Guid jobId) { var until = DateTime.UtcNow.AddSeconds(30); while (fx.Engine.RunningJobIds.Contains(jobId)) { Assert.True(DateTime.UtcNow < until, "the render did not stop"); await Task.Delay(20, fx.Ct); } } }