1054 lines
44 KiB
C#
1054 lines
44 KiB
C#
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using Age.Engine.Diagnostics;
|
|
using Age.Engine.Hosting;
|
|
using Age.Engine.Model;
|
|
using Age.Engine.Sys4;
|
|
using Age.Engine.Vm;
|
|
using Xunit;
|
|
|
|
public class MovieOpcodeTests
|
|
{
|
|
private sealed class FakeMovieDecoder : IMovieDecoder
|
|
{
|
|
public long? StopTimeMs { get; init; }
|
|
public long InitialPositionMs { get; init; }
|
|
public bool IsCompleted { get; set; }
|
|
public string? Failure { get; set; }
|
|
public bool Disposed { get; private set; }
|
|
public RgbaImage? Frame { get; set; }
|
|
|
|
public bool TryTakeFrame(out RgbaImage frame)
|
|
{
|
|
if (Frame == null) { frame = default!; return false; }
|
|
frame = Frame;
|
|
Frame = null;
|
|
return true;
|
|
}
|
|
|
|
public void Dispose() => Disposed = true;
|
|
}
|
|
|
|
private sealed class FakeMovieDecoderFactory(FakeMovieDecoder decoder) : IMovieDecoderFactory
|
|
{
|
|
public MoviePayload? OpenedPayload { get; private set; }
|
|
public long OpenedInitialPositionMs { get; private set; }
|
|
public long? OpenedPresentationDurationMs { get; private set; }
|
|
public IMovieDecoder Open(
|
|
MoviePayload movie, long initialPositionMs = 0, long? presentationDurationMs = null)
|
|
{
|
|
OpenedPayload = movie;
|
|
OpenedInitialPositionMs = initialPositionMs;
|
|
OpenedPresentationDurationMs = presentationDurationMs;
|
|
return decoder;
|
|
}
|
|
}
|
|
|
|
private sealed class FakeFfmpegFrameSource(FfmpegMovieInfo info,
|
|
params FfmpegVideoFrame[] frames) : IFfmpegFrameSource
|
|
{
|
|
private readonly Queue<FfmpegVideoFrame> _frames = new(frames);
|
|
private readonly Queue<FfmpegAudioChunk> _audio = new();
|
|
private int _decodeCalls;
|
|
public FfmpegMovieInfo Info { get; } = info;
|
|
public int FailOnDecodeCall { get; init; } = -1;
|
|
public int DecodeCalls => Volatile.Read(ref _decodeCalls);
|
|
public long? SeekPositionMs { get; private set; }
|
|
public bool Disposed { get; private set; }
|
|
|
|
public void Seek(long positionMs) => SeekPositionMs = positionMs;
|
|
|
|
public bool TryDecodeNextVideoFrame(out FfmpegVideoFrame frame)
|
|
{
|
|
int call = Interlocked.Increment(ref _decodeCalls) - 1;
|
|
if (call == FailOnDecodeCall)
|
|
throw new InvalidDataException("synthetic decode failure");
|
|
return _frames.TryDequeue(out frame!);
|
|
}
|
|
public void EnqueueAudio(params FfmpegAudioChunk[] chunks)
|
|
{
|
|
foreach (FfmpegAudioChunk chunk in chunks) _audio.Enqueue(chunk);
|
|
}
|
|
public bool TryDecodeNextAudioChunk(out FfmpegAudioChunk chunk)
|
|
=> _audio.TryDequeue(out chunk!);
|
|
|
|
public void Dispose() => Disposed = true;
|
|
}
|
|
|
|
private sealed class ManualMoviePacingClock : IMoviePacingClock, IDisposable
|
|
{
|
|
private readonly AutoResetEvent _advanced = new(false);
|
|
private long _now;
|
|
private long _waitingFor = -1;
|
|
|
|
public bool WaitUntil(long elapsedMilliseconds, WaitHandle cancellation)
|
|
{
|
|
Interlocked.Exchange(ref _waitingFor, elapsedMilliseconds);
|
|
while (Interlocked.Read(ref _now) < elapsedMilliseconds)
|
|
{
|
|
int signalled = WaitHandle.WaitAny(new[] { cancellation, _advanced });
|
|
if (signalled == 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void AdvanceTo(long elapsedMilliseconds)
|
|
{
|
|
Interlocked.Exchange(ref _now, elapsedMilliseconds);
|
|
_advanced.Set();
|
|
}
|
|
|
|
public bool WaitForDeadline(long elapsedMilliseconds) =>
|
|
SpinWait.SpinUntil(() => Interlocked.Read(ref _waitingFor) == elapsedMilliseconds, 1000);
|
|
|
|
public void Dispose() => _advanced.Dispose();
|
|
}
|
|
|
|
private static FfmpegVideoFrame SyntheticMovieFrame(byte value, long timestamp) =>
|
|
new(new RgbaImage(1, 1, new[] { value, value, value, (byte)255 }), timestamp);
|
|
|
|
[Fact]
|
|
public void MovieRuntimeUsesInjectedDecoderAndRetainsSynchronousMetadata()
|
|
{
|
|
var decoder = new FakeMovieDecoder
|
|
{
|
|
StopTimeMs = 1876,
|
|
Frame = new RgbaImage(1, 1, new byte[] { 1, 2, 3, 4 }),
|
|
};
|
|
var factory = new FakeMovieDecoderFactory(decoder);
|
|
var payload = new MoviePayload("TEST.AGF", new byte[] { 0, 0, 1, 0xba });
|
|
|
|
var runtime = MovieRuntime.Open("TEST.AGF", 7, 0x123, payload, factory);
|
|
|
|
Assert.Same(payload, factory.OpenedPayload);
|
|
Assert.Equal(0, factory.OpenedInitialPositionMs);
|
|
Assert.Same(decoder, runtime.Decoder);
|
|
Assert.Equal(0x123, runtime.ResourceId);
|
|
Assert.Equal(0, runtime.InitialPositionMs);
|
|
Assert.Equal(1876, runtime.Decoder.StopTimeMs);
|
|
Assert.Equal(5000, runtime.WatchdogMs);
|
|
Assert.True(runtime.Decoder.TryTakeFrame(out var frame));
|
|
Assert.Equal(new byte[] { 1, 2, 3, 4 }, frame.Pixels);
|
|
runtime.Decoder.Dispose();
|
|
Assert.True(decoder.Disposed);
|
|
}
|
|
|
|
[Fact]
|
|
public void MovieRuntimePassesInitialPositionAndBasesWatchdogOnRemainingDuration()
|
|
{
|
|
var decoder = new FakeMovieDecoder { StopTimeMs = 10000, InitialPositionMs = 9000 };
|
|
var factory = new FakeMovieDecoderFactory(decoder);
|
|
|
|
var runtime = MovieRuntime.Open("TEST.AGF", 7, 0x123,
|
|
new MoviePayload("TEST.AGF", new byte[] { 0, 0, 1, 0xba }),
|
|
factory, initialPositionMs: 9000);
|
|
|
|
Assert.Equal(9000, factory.OpenedInitialPositionMs);
|
|
Assert.Equal(9000, runtime.InitialPositionMs);
|
|
Assert.Equal(5000, runtime.WatchdogMs);
|
|
runtime.Decoder.Dispose();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null, 30000)]
|
|
[InlineData(-1L, 30000L)]
|
|
[InlineData(10000L, 12000L)]
|
|
[InlineData(500000L, 300000L)]
|
|
public void MovieRuntimeComputesBoundedWatchdogFromDecoderMetadata(long? stopTimeMs, long expected)
|
|
{
|
|
var decoder = new FakeMovieDecoder { StopTimeMs = stopTimeMs };
|
|
var runtime = MovieRuntime.Open("TEST.AGF", 7, 0x123,
|
|
new MoviePayload("TEST.AGF", new byte[] { 0, 0, 1, 0xba }),
|
|
new FakeMovieDecoderFactory(decoder));
|
|
|
|
Assert.Equal(expected, runtime.WatchdogMs);
|
|
runtime.Decoder.Dispose();
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegDecoderPublishesOnlyDueFramesAndCompletesAfterFinalInterval()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 100, 20, 1, false),
|
|
SyntheticMovieFrame(1, 0), SyntheticMovieFrame(2, 50));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
RgbaImage? first = null;
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
if (!decoder.TryTakeFrame(out var frame)) return false;
|
|
first = frame;
|
|
return true;
|
|
}, 1000));
|
|
Assert.Equal((byte)1, first!.Pixels[0]);
|
|
Assert.True(clock.WaitForDeadline(50));
|
|
Assert.False(decoder.TryTakeFrame(out _));
|
|
|
|
clock.AdvanceTo(49);
|
|
Assert.False(decoder.TryTakeFrame(out _));
|
|
clock.AdvanceTo(50);
|
|
RgbaImage? second = null;
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
if (!decoder.TryTakeFrame(out var frame)) return false;
|
|
second = frame;
|
|
return true;
|
|
}, 1000));
|
|
Assert.Equal((byte)2, second!.Pixels[0]);
|
|
|
|
Assert.True(clock.WaitForDeadline(100));
|
|
clock.AdvanceTo(99);
|
|
Assert.False(decoder.IsCompleted);
|
|
clock.AdvanceTo(100);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 1000));
|
|
Assert.Null(decoder.Failure);
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegDecoderRetimeUsesRequestedDurationAndHoldsTerminalFrameToEndpoint()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 1000, 30, 1, false),
|
|
SyntheticMovieFrame(1, 600), SyntheticMovieFrame(2, 900));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(
|
|
source, clock, presentationDurationMs: 500);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(clock.WaitForDeadline(150)); // (900 - 600) * 500 / 1000
|
|
clock.AdvanceTo(150);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(clock.WaitForDeadline(500));
|
|
clock.AdvanceTo(499);
|
|
Assert.False(decoder.IsCompleted);
|
|
clock.AdvanceTo(500);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 1000));
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegDecoderPublishesAndRetainsFirstDecodedFrameBeforePacing()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 700, 30, 1, true, 1000, 2, 50),
|
|
SyntheticMovieFrame(1, 600), SyntheticMovieFrame(2, 634));
|
|
using var clock = new ManualMoviePacingClock();
|
|
clock.AdvanceTo(1000);
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => source.DecodeCalls == 1, 1000));
|
|
Thread.Sleep(20);
|
|
Assert.Equal(1, source.DecodeCalls);
|
|
Assert.Equal(600, decoder.FirstFramePresentationTimeMs);
|
|
Assert.True(decoder.TryTakeFrame(out var first));
|
|
Assert.Equal((byte)1, first.Pixels[0]);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => source.DecodeCalls >= 2, 1000));
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegAudioBearingDecoderRebasesVideoPacingToFirstSourceTimestamp()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 700, 30, 1, true, 1000, 2, 50),
|
|
SyntheticMovieFrame(1, 600), SyntheticMovieFrame(2, 634));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(clock.WaitForDeadline(34));
|
|
clock.AdvanceTo(33);
|
|
Assert.False(decoder.TryTakeFrame(out _));
|
|
clock.AdvanceTo(34);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegVideoOnlyDecoderRebasesPacingToFirstSourceTimestamp()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 700, 30, 1, false),
|
|
SyntheticMovieFrame(1, 600), SyntheticMovieFrame(2, 634));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(clock.WaitForDeadline(34));
|
|
clock.AdvanceTo(33);
|
|
Assert.False(decoder.TryTakeFrame(out _));
|
|
clock.AdvanceTo(34);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
|
|
Assert.True(clock.WaitForDeadline(100));
|
|
clock.AdvanceTo(100);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 1000));
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegPositionedDecoderPublishesFrameActiveAtSeekThenContinuesPacing()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 120, 25, 1, false),
|
|
SyntheticMovieFrame(1, 0),
|
|
SyntheticMovieFrame(2, 40),
|
|
SyntheticMovieFrame(3, 80));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock, initialPositionMs: 60);
|
|
|
|
Assert.Equal(60, source.SeekPositionMs);
|
|
Assert.Equal(60, decoder.InitialPositionMs);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.Equal(40, decoder.FirstFramePresentationTimeMs);
|
|
Assert.True(clock.WaitForDeadline(40));
|
|
clock.AdvanceTo(39);
|
|
Assert.False(decoder.TryTakeFrame(out _));
|
|
clock.AdvanceTo(40);
|
|
RgbaImage? next = null;
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
if (!decoder.TryTakeFrame(out var frame)) return false;
|
|
next = frame;
|
|
return true;
|
|
}, 1000));
|
|
Assert.Equal((byte)3, next!.Pixels[0]);
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegPositionedDecoderRetainsTerminalFrameAtStopTimeMinusOne()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 120, 25, 1, false),
|
|
SyntheticMovieFrame(1, 0),
|
|
SyntheticMovieFrame(2, 40),
|
|
SyntheticMovieFrame(3, 80));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock, initialPositionMs: 119);
|
|
|
|
RgbaImage? terminal = null;
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
if (!decoder.TryTakeFrame(out var frame)) return false;
|
|
terminal = frame;
|
|
return true;
|
|
}, 1000));
|
|
|
|
Assert.Equal((byte)3, terminal!.Pixels[0]);
|
|
Assert.Equal(80, decoder.FirstFramePresentationTimeMs);
|
|
Assert.True(clock.WaitForDeadline(40));
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegPositionedDecoderClampsInitialPositionToGraphBounds()
|
|
{
|
|
var belowStart = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 120, 25, 1, false),
|
|
SyntheticMovieFrame(1, 0));
|
|
using (var decoder = new FfmpegMovieDecoder(belowStart, null, initialPositionMs: -50))
|
|
{
|
|
Assert.Equal(0, decoder.InitialPositionMs);
|
|
Assert.Null(belowStart.SeekPositionMs);
|
|
}
|
|
|
|
var beyondStop = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 120, 25, 1, false),
|
|
SyntheticMovieFrame(1, 80));
|
|
using (var decoder = new FfmpegMovieDecoder(beyondStop, null, initialPositionMs: 500))
|
|
{
|
|
Assert.Equal(119, decoder.InitialPositionMs);
|
|
Assert.Equal(119, beyondStop.SeekPositionMs);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegPositionedDecoderTrimsAndRebasesAudioAtTheSamePosition()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 150, 10, 1, true, 1000, 2, 50),
|
|
SyntheticMovieFrame(1, 0), SyntheticMovieFrame(2, 100));
|
|
source.EnqueueAudio(
|
|
new FfmpegAudioChunk(Enumerable.Range(0, 100).Select(value => (float)value).ToArray(),
|
|
50, 50),
|
|
new FfmpegAudioChunk(Enumerable.Repeat(0.25f, 100).ToArray(), 50, 100));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock, initialPositionMs: 75);
|
|
|
|
var chunks = new List<MovieAudioChunk>();
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
while (decoder.TryTakeAudioChunk(out var chunk)) chunks.Add(chunk);
|
|
return decoder.AudioDecodingCompleted && chunks.Count == 2;
|
|
}, 1000));
|
|
|
|
Assert.Equal(new[] { 25, 50 }, chunks.Select(chunk => chunk.FrameCount));
|
|
Assert.Equal(new long[] { 0, 25 }, chunks.Select(chunk => chunk.PresentationTimeMs));
|
|
Assert.Equal(50f, chunks[0].InterleavedStereo[0]);
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegDecoderDisposalInterruptsFutureFrameWait()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 60040, 25, 1, false),
|
|
SyntheticMovieFrame(1, 0), SyntheticMovieFrame(2, 60000));
|
|
using var clock = new ManualMoviePacingClock();
|
|
var decoder = new FfmpegMovieDecoder(source, clock);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(clock.WaitForDeadline(60000));
|
|
|
|
var elapsed = Stopwatch.StartNew();
|
|
decoder.Dispose();
|
|
|
|
Assert.True(elapsed.Elapsed < TimeSpan.FromSeconds(1));
|
|
Assert.True(source.Disposed);
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegDecoderFailureCompletesInsteadOfStrandingMovieWait()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 100, 20, 1, false), SyntheticMovieFrame(1, 0))
|
|
{
|
|
FailOnDecodeCall = 1,
|
|
};
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 1000));
|
|
Assert.Equal("synthetic decode failure", decoder.Failure);
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegAudioDecoderQueuesTimestampedPcmAndCompletesAfterSubmissionAndClock()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 100, 20, 1, true, 1000, 2, 50),
|
|
SyntheticMovieFrame(1, 0), SyntheticMovieFrame(2, 50));
|
|
source.EnqueueAudio(
|
|
new FfmpegAudioChunk(new float[100], 50, 0),
|
|
new FfmpegAudioChunk(Enumerable.Repeat(0.25f, 100).ToArray(), 50, 50));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
var chunks = new List<MovieAudioChunk>();
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
while (decoder.TryTakeAudioChunk(out var chunk)) chunks.Add(chunk);
|
|
return decoder.AudioDecodingCompleted && chunks.Count == 2;
|
|
}, 1000));
|
|
Assert.Equal(new long[] { 0, 50 }, chunks.Select(chunk => chunk.PresentationTimeMs));
|
|
Assert.Equal(100, chunks.Sum(chunk => chunk.FrameCount));
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
decoder.MarkAudioSubmitted();
|
|
clock.AdvanceTo(99);
|
|
Assert.False(decoder.IsCompleted);
|
|
clock.AdvanceTo(100);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 1000));
|
|
Assert.Null(decoder.Failure);
|
|
}
|
|
|
|
[Fact]
|
|
public void FfmpegAudioBearingDecoderHoldsTerminalFrameUntilGraphAudioEndpoint()
|
|
{
|
|
var source = new FakeFfmpegFrameSource(
|
|
new FfmpegMovieInfo(1, 1, 700, 30, 1, true, 1000, 2, 700),
|
|
SyntheticMovieFrame(1, 600), SyntheticMovieFrame(2, 634));
|
|
source.EnqueueAudio(new FfmpegAudioChunk(new float[1400], 700, 0));
|
|
using var clock = new ManualMoviePacingClock();
|
|
using var decoder = new FfmpegMovieDecoder(source, clock);
|
|
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeFrame(out _), 1000));
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.TryTakeAudioChunk(out _), 1000));
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.AudioDecodingCompleted, 1000));
|
|
decoder.MarkAudioSubmitted();
|
|
|
|
clock.AdvanceTo(699);
|
|
Assert.True(clock.WaitForDeadline(700));
|
|
Assert.False(decoder.IsCompleted);
|
|
clock.AdvanceTo(700);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 1000));
|
|
}
|
|
|
|
[Fact]
|
|
public void MovieAudioTimelineDoesNotSpliceContinuousMpegBlocksAtRoundedMillisecondTimestamps()
|
|
{
|
|
const int sampleRate = 44100;
|
|
const int blockFrames = 1152;
|
|
const int blockCount = 4093; // OP.AGF's installed MPEG audio block count
|
|
long submittedFrames = 0;
|
|
bool anchored = false;
|
|
|
|
for (int block = 0; block < blockCount; block++)
|
|
{
|
|
long exactStartFrame = block * (long)blockFrames;
|
|
long roundedDownTimestampMs = exactStartFrame * 1000 / sampleRate;
|
|
long targetFrame = MovieAudioTimeline.PresentationFrame(
|
|
roundedDownTimestampMs, sampleRate);
|
|
MovieAudioAdjustment adjustment = MovieAudioTimeline.Align(
|
|
submittedFrames, targetFrame, blockFrames, sampleRate, anchored);
|
|
|
|
Assert.Equal(default, adjustment);
|
|
submittedFrames += blockFrames;
|
|
anchored = true;
|
|
}
|
|
|
|
Assert.Equal(blockCount * (long)blockFrames, submittedFrames);
|
|
}
|
|
|
|
[Fact]
|
|
public void MovieAudioTimelineStillPreservesMaterialGapsAndOverlaps()
|
|
{
|
|
const int sampleRate = 44100;
|
|
|
|
var initialGap = MovieAudioTimeline.Align(
|
|
submittedFrames: 0,
|
|
targetFrame: MovieAudioTimeline.PresentationFrame(100, sampleRate),
|
|
chunkFrames: 1152,
|
|
sampleRate: sampleRate,
|
|
timelineAnchored: false);
|
|
Assert.Equal(new MovieAudioAdjustment(4410, 0), initialGap);
|
|
|
|
var laterGap = MovieAudioTimeline.Align(
|
|
submittedFrames: 2304,
|
|
targetFrame: MovieAudioTimeline.PresentationFrame(100, sampleRate),
|
|
chunkFrames: 1152,
|
|
sampleRate: sampleRate,
|
|
timelineAnchored: true);
|
|
Assert.Equal(new MovieAudioAdjustment(2106, 0), laterGap);
|
|
|
|
var overlap = MovieAudioTimeline.Align(
|
|
submittedFrames: 2304,
|
|
targetFrame: MovieAudioTimeline.PresentationFrame(40, sampleRate),
|
|
chunkFrames: 1152,
|
|
sampleRate: sampleRate,
|
|
timelineAnchored: true);
|
|
Assert.Equal(new MovieAudioAdjustment(0, 540), overlap);
|
|
}
|
|
|
|
[Fact]
|
|
public void InitialRootFlagStartsSetAndClearsWhenExitScriptRuns()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var root = ScriptAssembler.Assemble(table, "ROOT", new List<(int, Operand[])>
|
|
{
|
|
(0x130, new[] { new Operand(3, 0x100) }),
|
|
(0x9, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var reloadedRoot = ScriptAssembler.Assemble(table, "SYSTEM4", new List<(int, Operand[])>
|
|
{
|
|
(0x130, new[] { new Operand(3, 0x101) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost();
|
|
var vm = new VirtualMachine(root, table, host,
|
|
provider: new MapProvider(new Dictionary<long, Script> { [0] = reloadedRoot }));
|
|
|
|
vm.Run();
|
|
Assert.Equal(1, vm.Globals[0x100]);
|
|
Assert.Equal(0, vm.Globals[0x101]);
|
|
Assert.Equal(1, host.SceneContextResets);
|
|
}
|
|
|
|
[Fact]
|
|
public void ModalMovieDispatchesRawResourceSurfaceAndFlags()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "MODAL", new List<(int, Operand[])>
|
|
{
|
|
(0x1f8, new[] { new Operand(0, 42), new Operand(0, 800), new Operand(0, 600), new Operand(0, 0) }),
|
|
(0x20f, new[] { new Operand(0, 0x335f), new Operand(0, 42), new Operand(0, 4) }),
|
|
(0x55, new[] { new Operand(3, 0x1234), new Operand(0, 0x5678) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost();
|
|
var vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal(new[] { (0x335fL, 42, 4L) }, host.ModalMovies);
|
|
Assert.Equal(0x5678, vm.Globals[0x1234]);
|
|
vm.Gfx.BindDraw(1, 42, 0, 0, 1, 1, 0, 0);
|
|
var visible = vm.Gfx.SnapshotVisibleObjects().Single();
|
|
Assert.Equal(0, visible.SurfaceResId);
|
|
Assert.Equal(-1, visible.ColorKey);
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Workspace")]
|
|
public void Sc0000ResumesImmediatelyAfterMovieOpcodeAtBytecodeOffset13d1()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var provider = Sys4ScriptProvider.Load(table);
|
|
var session = new GameSession();
|
|
foreach (var name in new[] { "INITCONFIG.BIN", "INIT2.BIN", "INIT.BIN" })
|
|
session.RunScene(Sys4Loader.Load(Paths.Scripts()[name], table), table, new CaptureHost(), provider: provider);
|
|
var script = Sys4Loader.Load(Paths.Scripts()["SC0000.BIN"], table);
|
|
var host = new RecordingHost();
|
|
var trace = new RecordingTraceSink { TracingSteps = true };
|
|
var vm = new VirtualMachine(script, table, host, new VmOptions(MaxSteps: 20_000_000), provider, trace);
|
|
foreach (var kv in session.Globals) vm.Globals[kv.Key] = kv.Value;
|
|
foreach (var kv in session.GlobalStrings) vm.GlobalStrings[kv.Key] = kv.Value;
|
|
|
|
vm.Run();
|
|
|
|
int movieStep = trace.Events.FindIndex(e => e.Kind == TraceEventKind.Step && e.Opcode == 0x236);
|
|
Assert.True(movieStep >= 0);
|
|
var nextStep = trace.Events.Skip(movieStep + 1).First(e => e.Kind == TraceEventKind.Step);
|
|
Assert.Equal(0x13c8, trace.Events[movieStep].Ins!.Offset);
|
|
Assert.Equal(0x13d1, nextStep.Ins!.Offset);
|
|
Assert.Contains((0x33L, 0, 2L, 0L), host.Movies);
|
|
}
|
|
|
|
[Fact]
|
|
public void PlayMovieDispatchesExactOperandsAndResumesAtNextInstruction()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "MOVIE", new List<(int, Operand[])>
|
|
{
|
|
(0x236, new[] { new Operand(0, 0x33), new Operand(0, 5), new Operand(0, 2), new Operand(0, 0) }),
|
|
(0x55, new[] { new Operand(3, 0x1234), new Operand(0, 0x5678) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost();
|
|
var vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal("exit", vm.HaltReason);
|
|
Assert.Equal(0x5678, vm.Globals[0x1234]);
|
|
Assert.Equal(new[] { (0x33L, 5, 2L, 0L) }, host.Movies);
|
|
vm.Gfx.BindDraw(1, 5, 0, 0, 1, 1, 0, 0);
|
|
var visible = vm.Gfx.SnapshotVisibleObjects().Single();
|
|
Assert.Equal(0, visible.SurfaceResId);
|
|
Assert.Equal(-1, visible.ColorKey);
|
|
}
|
|
|
|
[Fact]
|
|
public void PositionedMovieDispatchesExactOperandsAndRetainsGraphStopTime()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "POSITIONED-MOVIE",
|
|
[
|
|
(0x241,
|
|
[
|
|
new Operand(0, 0x33), new Operand(0, 5), new Operand(0, 2),
|
|
new Operand(0, 0), new Operand(0, 1875),
|
|
]),
|
|
(0x23f, [new Operand(3, 0x1234), new Operand(0, 5)]),
|
|
(0x55, [new Operand(3, 0x1235), new Operand(0, 0x5678)]),
|
|
(0x2, Array.Empty<Operand>()),
|
|
], []);
|
|
var host = new RecordingHost { MovieStopTimeMs = 1876 };
|
|
var vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal("exit", vm.HaltReason);
|
|
Assert.Equal(new[] { (0x33L, 5, 2L, 0L, 1875L) }, host.PositionedMovies);
|
|
Assert.Empty(host.Movies);
|
|
Assert.Equal(1876, vm.Globals[0x1234]);
|
|
Assert.Equal(0x5678, vm.Globals[0x1235]);
|
|
}
|
|
|
|
[Fact]
|
|
public void MovieMaskTransitionDispatchesAllTwelveOperandsAndResumes()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "MOVIE-MASK",
|
|
[
|
|
(0x24d,
|
|
[
|
|
new Operand(0, 11), new Operand(0, 45),
|
|
new Operand(0, 10), new Operand(0, 1),
|
|
new Operand(0, unchecked((uint)-184)), new Operand(0, 0),
|
|
new Operand(0, 800), new Operand(0, 600),
|
|
new Operand(0, 0), new Operand(0, 0x325e),
|
|
new Operand(0, 0), new Operand(0, 1000),
|
|
]),
|
|
(0x55, [new Operand(3, 0x1234), new Operand(0, 0x5678)]),
|
|
(0x2, Array.Empty<Operand>()),
|
|
], []);
|
|
var host = new RecordingHost();
|
|
var vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal("exit", vm.HaltReason);
|
|
Assert.Equal(0x5678, vm.Globals[0x1234]);
|
|
Assert.Equal(new MovieMaskTransitionRequest(
|
|
11, 45, 10, 1, -184, 0, 800, 600, 0, 0x325e, 0, 1000),
|
|
host.MovieMaskTransitions.Single());
|
|
Assert.True(vm.Gfx.SnapshotMovieMaskTransitions().Single().Completed);
|
|
}
|
|
|
|
[Fact]
|
|
public void PlayMovieKeepsCreatedSurfaceBlankDuringSynchronousHostSetup()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "MOVIE-PREROLL", new List<(int, Operand[])>
|
|
{
|
|
(0x1f8, new[] { new Operand(0, 5), new Operand(0, 800), new Operand(0, 600), new Operand(0, 0) }),
|
|
(0x1fb, new[]
|
|
{
|
|
new Operand(0, 1), new Operand(0, 5), new Operand(0, 0), new Operand(0, 0),
|
|
new Operand(0, 800), new Operand(0, 600), new Operand(0, 0), new Operand(0, 0),
|
|
}),
|
|
(0x236, new[] { new Operand(0, 0x33), new Operand(0, 5), new Operand(0, 2), new Operand(0, 0) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost();
|
|
VirtualMachine? vm = null;
|
|
long resourceDuringSetup = -1;
|
|
host.OnPlayMovie = () => resourceDuringSetup = vm!.Gfx.SnapshotVisibleObjects().Single().SurfaceResId;
|
|
vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal(0, resourceDuringSetup);
|
|
var visible = vm.Gfx.SnapshotVisibleObjects().Single();
|
|
Assert.Equal(0, visible.SurfaceResId);
|
|
Assert.Equal(-1, visible.ColorKey);
|
|
}
|
|
|
|
[Fact]
|
|
public void QueryMovieStopTimeReturnsTheValueRetainedByPlayMovie()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "MOVIE-TIME", new List<(int, Operand[])>
|
|
{
|
|
(0x236, new[] { new Operand(0, 0x33), new Operand(0, 5), new Operand(0, 2), new Operand(0, 0) }),
|
|
(0x23f, new[] { new Operand(3, 0x1234), new Operand(0, 5) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost { MovieStopTimeMs = 1876 };
|
|
var vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal(1876, vm.Globals[0x1234]);
|
|
Assert.True(vm.Gfx.TryGetMovieStopTime(5, out long? retained));
|
|
Assert.Equal(1876, retained);
|
|
Assert.Empty(host.Warnings);
|
|
|
|
vm.Gfx.SetSurface(5, 0x34, 0); // replacing the native surface tears down its movie metadata
|
|
Assert.False(vm.Gfx.TryGetMovieStopTime(5, out _));
|
|
}
|
|
|
|
[Fact]
|
|
public void QueryMovieStopTimeReturnsMinusOneWithoutWarningForAnEmptyMovieSlot()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "EMPTY-MOVIE-TIME", new List<(int, Operand[])>
|
|
{
|
|
(0x23f, new[] { new Operand(3, 0x1234), new Operand(0, 5) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost();
|
|
var vm = new VirtualMachine(script, table, host);
|
|
vm.Gfx.GetOrCreate(5); // retained-object existence is unrelated to the native movie-object slot
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal(-1, vm.Globals[0x1234]);
|
|
Assert.Empty(host.Warnings);
|
|
}
|
|
|
|
[Fact]
|
|
public void LoadedMovieWithoutBackendMetadataUsesImmediateZeroDuration()
|
|
{
|
|
var table = OpcodeTableJson.Load(Paths.OpcodesJson);
|
|
var script = ScriptAssembler.Assemble(table, "MISSING-MOVIE-TIME", new List<(int, Operand[])>
|
|
{
|
|
(0x236, new[] { new Operand(0, 0x33), new Operand(0, 5), new Operand(0, 2), new Operand(0, 0) }),
|
|
(0x23f, new[] { new Operand(3, 0x1234), new Operand(0, 5) }),
|
|
(0x23a, new[] { new Operand(3, 0x1235), new Operand(0, 5) }),
|
|
(0x2, System.Array.Empty<Operand>()),
|
|
}, System.Array.Empty<string>());
|
|
var host = new RecordingHost();
|
|
var vm = new VirtualMachine(script, table, host);
|
|
|
|
vm.Run();
|
|
|
|
Assert.Equal(0, vm.Globals[0x1234]);
|
|
Assert.True(vm.Gfx.TryGetMovieStopTime(5, out long? retained));
|
|
Assert.Equal(0, retained);
|
|
Assert.Equal(0, vm.Globals[0x1235]);
|
|
Assert.Empty(host.Warnings);
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Workspace")]
|
|
public void Sc0000MoviePayloadReadsFromArchiveVfsAndIsMpegProgramStream()
|
|
{
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var entry = resources.ResolveMovie(0x33);
|
|
|
|
Assert.Equal("CHAPTER.AGF", entry?.Name);
|
|
var movie = resources.ReadMovie(entry!);
|
|
Assert.Equal(new byte[] { 0, 0, 1, 0xba }, movie.Bytes[..4]);
|
|
Assert.Equal(8_194_052, movie.Bytes.Length);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x335f, "LOGO.AGF")]
|
|
[InlineData(0x3364, "OP.AGF")]
|
|
[Trait("Category", "Workspace")]
|
|
public void ModalMoviePayloadResolvesFromUniversalPackedCatalog(int resourceId, string expectedName)
|
|
{
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var entry = resources.ResolveMovie(resourceId);
|
|
|
|
Assert.Equal(expectedName, entry?.Name);
|
|
var movie = resources.ReadMovie(entry!);
|
|
Assert.Equal(new byte[] { 0, 0, 1, 0xba }, movie.Bytes[..4]);
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Workspace")]
|
|
public void DebugTestMovieDecodesToExactGreenMaskDimensions()
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(0x325e)!);
|
|
|
|
using var movie = new FfmpegMovieSession(payload);
|
|
Assert.Equal("TEST.AGF", payload.Name);
|
|
Assert.Equal(800, movie.Info.Width);
|
|
Assert.Equal(600, movie.Info.Height);
|
|
Assert.Equal(1000, movie.Info.StopTimeMs);
|
|
Assert.False(movie.Info.HasAudio);
|
|
byte[]? mask = null;
|
|
for (int frameIndex = 0; frameIndex < 60 && movie.TryDecodeNextVideoFrame(out var frame); frameIndex++)
|
|
{
|
|
mask = MovieMaskSurface.ExtractGreen(frame.Image, 800, 600, 255);
|
|
Assert.Equal(800 * 600, mask.Length);
|
|
if (mask.Distinct().Skip(1).Any()) break;
|
|
}
|
|
Assert.NotNull(mask);
|
|
Assert.True(mask!.Distinct().Skip(1).Any(), "TEST.AGF should publish a nonuniform green mask");
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x335f, "LOGO.AGF")]
|
|
[InlineData(0x3364, "OP.AGF")]
|
|
[Trait("Category", "Workspace")]
|
|
public void ModalMovieOpeningFramesAreOpaqueAndHaveContinuousCadence(
|
|
int resourceId, string expectedName)
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(resourceId)!);
|
|
|
|
using var movie = new FfmpegMovieSession(payload);
|
|
Assert.Equal(expectedName, payload.Name);
|
|
long priorTimestamp = -1;
|
|
byte[]? firstPixels = null;
|
|
bool openingChanged = false;
|
|
for (int frameIndex = 0; frameIndex < 20; frameIndex++)
|
|
{
|
|
Assert.True(movie.TryDecodeNextVideoFrame(out var frame),
|
|
$"{expectedName} ended before opening frame {frameIndex}");
|
|
if (priorTimestamp >= 0)
|
|
Assert.InRange(frame.PresentationTimeMs - priorTimestamp, 33, 34);
|
|
else
|
|
Assert.Equal(0, frame.PresentationTimeMs);
|
|
priorTimestamp = frame.PresentationTimeMs;
|
|
firstPixels ??= frame.Image.Pixels;
|
|
openingChanged |= !firstPixels.AsSpan().SequenceEqual(frame.Image.Pixels);
|
|
for (int alpha = 3; alpha < frame.Image.Pixels.Length; alpha += 4)
|
|
Assert.Equal((byte)255, frame.Image.Pixels[alpha]);
|
|
}
|
|
Assert.True(openingChanged, $"{expectedName} should change within its first 20 decoded frames");
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x2be3, "MVB961.AGF", 280, 352, 500)]
|
|
[InlineData(0x2b94, "MVB238.AGF", 280, 352, 866)]
|
|
[InlineData(0x2bc2, "MVB908.AGF", 400, 400, 333)]
|
|
[InlineData(0x33, "CHAPTER.AGF", 800, 600, 12016)]
|
|
[Trait("Category", "Workspace")]
|
|
public void FfmpegShimDecodesRepresentativeVfsMovie(int resourceId, string expectedName,
|
|
int expectedWidth, int expectedHeight,
|
|
long expectedStopTimeMs)
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(resourceId)!);
|
|
|
|
using var movie = new FfmpegMovieSession(payload);
|
|
|
|
Assert.Equal(expectedName, payload.Name);
|
|
Assert.Equal(expectedWidth, movie.Info.Width);
|
|
Assert.Equal(expectedHeight, movie.Info.Height);
|
|
Assert.Equal(expectedStopTimeMs, movie.Info.StopTimeMs);
|
|
Assert.True(movie.TryDecodeNextVideoFrame(out var first));
|
|
Assert.Equal(expectedWidth * expectedHeight * 4, first.Image.Pixels.Length);
|
|
Assert.True(first.PresentationTimeMs >= 0);
|
|
bool changed = false;
|
|
long priorTimestamp = first.PresentationTimeMs;
|
|
for (int frameIndex = 0; frameIndex < 120 && movie.TryDecodeNextVideoFrame(out var later); frameIndex++)
|
|
{
|
|
Assert.True(later.PresentationTimeMs >= priorTimestamp);
|
|
priorTimestamp = later.PresentationTimeMs;
|
|
if (!first.Image.Pixels.AsSpan().SequenceEqual(later.Image.Pixels))
|
|
{
|
|
changed = true;
|
|
break;
|
|
}
|
|
}
|
|
Assert.True(changed, $"{expectedName} should deliver changing decoded frames");
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x33, "CHAPTER.AGF")]
|
|
[InlineData(0x2bf1, "MVS001.AGF")]
|
|
[InlineData(0x335f, "LOGO.AGF")]
|
|
[Trait("Category", "Workspace")]
|
|
public void FfmpegShimDecodesRepresentativeMpegAudio(int resourceId, string expectedName)
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(resourceId)!);
|
|
|
|
using var movie = new FfmpegMovieSession(payload);
|
|
|
|
Assert.Equal(expectedName, payload.Name);
|
|
Assert.True(movie.Info.HasAudio);
|
|
Assert.Equal(44100, movie.Info.AudioSampleRate);
|
|
Assert.Equal(2, movie.Info.AudioChannels);
|
|
Assert.True(movie.TryDecodeNextAudioChunk(out var first));
|
|
Assert.True(first.FrameCount > 0);
|
|
Assert.Equal(first.FrameCount * 2, first.InterleavedStereo.Length);
|
|
Assert.True(first.PresentationTimeMs >= 0);
|
|
Assert.All(first.InterleavedStereo, sample => Assert.True(float.IsFinite(sample)));
|
|
bool heardSignal = first.InterleavedStereo.Any(sample => Math.Abs(sample) > 0.00001f);
|
|
long priorTimestamp = first.PresentationTimeMs;
|
|
for (int block = 0; block < 500 && !heardSignal
|
|
&& movie.TryDecodeNextAudioChunk(out var later); block++)
|
|
{
|
|
Assert.True(later.PresentationTimeMs >= priorTimestamp);
|
|
Assert.All(later.InterleavedStereo, sample => Assert.True(float.IsFinite(sample)));
|
|
priorTimestamp = later.PresentationTimeMs;
|
|
heardSignal = later.InterleavedStereo.Any(sample => Math.Abs(sample) > 0.00001f);
|
|
}
|
|
Assert.True(heardSignal, $"{expectedName} should contain non-silent MPEG audio");
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Workspace")]
|
|
public void FfmpegShimSeeksBothVideoAndAudioNearRequestedPosition()
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(0x33)!); // CHAPTER.AGF
|
|
const long targetMs = 11000;
|
|
|
|
using var movie = new FfmpegMovieSession(payload);
|
|
movie.Seek(targetMs);
|
|
|
|
long videoTimestamp = -1;
|
|
for (int frame = 0; frame < 120 && videoTimestamp < targetMs; frame++)
|
|
{
|
|
Assert.True(movie.TryDecodeNextVideoFrame(out var decoded));
|
|
videoTimestamp = decoded.PresentationTimeMs;
|
|
}
|
|
Assert.InRange(videoTimestamp, targetMs, movie.Info.StopTimeMs);
|
|
|
|
long audioEndTimestamp = -1;
|
|
for (int chunk = 0; chunk < 100 && audioEndTimestamp < targetMs; chunk++)
|
|
{
|
|
Assert.True(movie.TryDecodeNextAudioChunk(out var decoded));
|
|
audioEndTimestamp = decoded.PresentationTimeMs
|
|
+ decoded.FrameCount * 1000L / movie.Info.AudioSampleRate;
|
|
}
|
|
Assert.InRange(audioEndTimestamp, targetMs, movie.Info.StopTimeMs + 100);
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Workspace")]
|
|
public void FfmpegShimRejectsTruncatedMovieWithBoundedDiagnostic()
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var payload = new MoviePayload("TRUNCATED.AGF", new byte[] { 0, 0, 1, 0xba, 0x21, 0, 1, 0 });
|
|
|
|
var error = Assert.Throws<InvalidDataException>(() => new FfmpegMovieSession(payload));
|
|
|
|
Assert.Contains("TRUNCATED.AGF", error.Message);
|
|
Assert.Contains("FFmpeg", error.Message);
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Workspace")]
|
|
public void FfmpegShimSupportsRepeatedOpenAndClose()
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(0x2bc2)!);
|
|
|
|
for (int iteration = 0; iteration < 10; iteration++)
|
|
{
|
|
using var movie = new FfmpegMovieSession(payload);
|
|
Assert.True(movie.TryDecodeNextVideoFrame(out _));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x2be3, 280, 500, 450)]
|
|
[InlineData(0x2bc2, 400, 333, 300)]
|
|
[Trait("Category", "Workspace")]
|
|
public void FfmpegPacedDecoderKeepsRealMovieAliveThroughItsStopTime(
|
|
int resourceId, int expectedWidth, long expectedStopTimeMs, long minimumElapsedMs)
|
|
{
|
|
if (!OperatingSystem.IsWindows()) return;
|
|
ConfigureFfmpegNativeProbe();
|
|
var catalog = Sys4AssetCatalog.Load(Paths.Sys4Ini);
|
|
var resources = new ResourceMap(catalog, new Sys4AssetStore(catalog, Paths.GameDir));
|
|
var payload = resources.ReadMovie(resources.ResolveMovie(resourceId)!);
|
|
var elapsed = Stopwatch.StartNew();
|
|
using var decoder = new FfmpegMovieDecoder(payload);
|
|
|
|
RgbaImage? first = null;
|
|
Assert.True(SpinWait.SpinUntil(() =>
|
|
{
|
|
if (!decoder.TryTakeFrame(out var frame)) return false;
|
|
first = frame;
|
|
return true;
|
|
}, 2000));
|
|
Assert.Equal(expectedWidth, first!.Width);
|
|
Assert.Equal(expectedStopTimeMs, decoder.StopTimeMs);
|
|
Assert.False(decoder.IsCompleted);
|
|
Assert.True(SpinWait.SpinUntil(() => decoder.IsCompleted, 2000));
|
|
Assert.True(elapsed.ElapsedMilliseconds >= minimumElapsedMs,
|
|
$"{expectedStopTimeMs} ms movie completed after only {elapsed.ElapsedMilliseconds} ms");
|
|
Assert.Null(decoder.Failure);
|
|
Assert.True(decoder.TryTakeFrame(out var final));
|
|
Assert.Equal(expectedWidth, final.Width);
|
|
}
|
|
|
|
private static void ConfigureFfmpegNativeProbe()
|
|
{
|
|
string nativeDirectory = Environment.GetEnvironmentVariable("AGE_FFMPEG_NATIVE_DIR")
|
|
?? Path.Combine(Paths.Build, "native", "win-x64");
|
|
Assert.True(File.Exists(Path.Combine(nativeDirectory, "age_movie_ffmpeg.dll")),
|
|
$"Build the FFmpeg shim first: native/age_movie_ffmpeg/build-win64.ps1 (expected {nativeDirectory})");
|
|
Environment.SetEnvironmentVariable("AGE_FFMPEG_NATIVE_DIR", nativeDirectory);
|
|
}
|
|
}
|