279 lines
14 KiB
C#
279 lines
14 KiB
C#
using System.Text.Json;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Articulations;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Generation.Midi;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Articulations;
|
|
using Melanchall.DryWetMidi.Core;
|
|
using MusicalComposition = GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition.Composition;
|
|
|
|
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Midi;
|
|
|
|
public sealed class MidiFileBuilderTests
|
|
{
|
|
[Fact]
|
|
public void TypeOneResolutionNamedTracksMetadataAndTrailingRestRoundTrip()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
|
|
Assert.Equal(MidiFileFormat.MultiTrack, file.OriginalFormat);
|
|
Assert.Equal(960, Assert.IsType<TicksPerQuarterNoteTimeDivision>(file.TimeDivision).TicksPerQuarterNote);
|
|
var tracks = file.Chunks.Cast<TrackChunk>().ToArray();
|
|
Assert.Equal(new[] { "Conductor", "Lead" }, tracks.Select(t => Assert.Single(t.Events.OfType<SequenceTrackNameEvent>()).Text));
|
|
Assert.Equal(500_000, Assert.Single(tracks[0].Events.OfType<SetTempoEvent>()).MicrosecondsPerQuarterNote);
|
|
var meter = Assert.Single(tracks[0].Events.OfType<TimeSignatureEvent>());
|
|
Assert.Equal(4, meter.Numerator);
|
|
Assert.Equal(4, meter.Denominator);
|
|
Assert.All(MidiTestData.Absolute(tracks[0]).Where(e => e.Event is not EndOfTrackEvent), e => Assert.Equal(0, e.Tick));
|
|
Assert.All(tracks, t =>
|
|
{
|
|
Assert.Single(t.Events.OfType<EndOfTrackEvent>());
|
|
Assert.IsType<EndOfTrackEvent>(t.Events.Last());
|
|
Assert.Equal(15_360, MidiTestData.Absolute(t).Last().Tick);
|
|
});
|
|
Assert.Equal(960, MidiTestData.Absolute(tracks[1]).Single(e => e.Event is NoteOffEvent).Tick);
|
|
Assert.Equal(0, (int)Assert.Single(tracks[1].Events.OfType<NoteOffEvent>()).Velocity);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(120, 500000)]
|
|
[InlineData(123, 487805)]
|
|
[InlineData(128, 468750)]
|
|
[InlineData(256, 234375)]
|
|
[InlineData(512, 117188)]
|
|
[InlineData(60000000, 1)]
|
|
public void TempoUsesNearestIntegerMidpointAwayFromZero(double bpm, long expected)
|
|
{
|
|
var (original, plan) = MidiTestData.Arrangement();
|
|
var composition = new MusicalComposition(bpm, original.Meter, original.Key, original.Bars, original.Tracks);
|
|
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
|
|
Assert.Equal(expected, Assert.Single(file.Chunks.OfType<TrackChunk>().First().Events.OfType<SetTempoEvent>()).MicrosecondsPerQuarterNote);
|
|
}
|
|
|
|
[Fact]
|
|
public void LowerTempoBoundaryIsRepresentableWithoutClamping()
|
|
{
|
|
var (original, plan) = MidiTestData.Arrangement();
|
|
var composition = new MusicalComposition(60_000_000d / 0xFFFFFF, original.Meter, original.Key, original.Bars, original.Tracks);
|
|
Assert.Empty(CompositionValidator.Validate(composition));
|
|
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
|
|
Assert.Equal(0xFFFFFF, Assert.Single(file.Chunks.OfType<TrackChunk>().First().Events.OfType<SetTempoEvent>()).MicrosecondsPerQuarterNote);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0)]
|
|
[InlineData(-120)]
|
|
[InlineData(double.NaN)]
|
|
[InlineData(double.PositiveInfinity)]
|
|
[InlineData(double.NegativeInfinity)]
|
|
[InlineData(60000001)]
|
|
[InlineData(3)]
|
|
public void InvalidTempoFailsBeforeSerialization(double bpm)
|
|
{
|
|
var (original, plan) = MidiTestData.Arrangement();
|
|
var composition = new MusicalComposition(bpm, original.Meter, original.Key, original.Bars, original.Tracks);
|
|
Assert.Contains("tempoBpm", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(composition, plan)).Message);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0.75)]
|
|
[InlineData(16777215.25)]
|
|
public void RoundingDoesNotAdmitTemposOutsideExistingUnroundedCoreRange(double quotient)
|
|
{
|
|
var (original, plan) = MidiTestData.Arrangement();
|
|
var composition = new MusicalComposition(60_000_000d / quotient,
|
|
original.Meter, original.Key, original.Bars, original.Tracks);
|
|
Assert.Contains("tempoBpm", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(composition, plan)).Message);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(3, 8)]
|
|
[InlineData(7, 16)]
|
|
[InlineData(255, 1)]
|
|
[InlineData(4, 128)]
|
|
public void LibraryTakesActualDenominatorNotExponent(int numerator, int denominator)
|
|
{
|
|
var composition = new MusicalComposition(120, new(numerator, denominator), new(4, KeyMode.Minor), 1,
|
|
[new(TrackRole.Lead, [new(64, BeatFraction.Zero, new(4, denominator), 96, Articulation.Sustain)])]);
|
|
var plan = MidiTestData.Plan(composition);
|
|
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
|
|
var meter = Assert.Single(file.Chunks.OfType<TrackChunk>().First().Events.OfType<TimeSignatureEvent>());
|
|
Assert.Equal(numerator, (int)meter.Numerator);
|
|
Assert.Equal(denominator, (int)meter.Denominator);
|
|
Assert.All(file.Chunks.Cast<TrackChunk>(), t => Assert.Equal(composition.MusicalExtent.ToTicks(), MidiTestData.Absolute(t).Last().Tick));
|
|
}
|
|
|
|
[Fact]
|
|
public void CoreDenominator256FailsClearlyWithoutByteWrapOrCoreChange()
|
|
{
|
|
var composition = new MusicalComposition(120, new(4, 256), new(4, KeyMode.Minor), 1,
|
|
[new(TrackRole.Lead, [new(64, BeatFraction.Zero, new(1, 64), 96, Articulation.Sustain)])]);
|
|
Assert.Empty(CompositionValidator.Validate(composition));
|
|
var plan = MidiTestData.Plan(composition);
|
|
var error = Assert.Throws<NotSupportedException>(() => MidiFileBuilder.Build(composition, plan));
|
|
Assert.Contains("/256", error.Message);
|
|
Assert.Contains("1..128", error.Message);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0x0FFFFFFF, true)]
|
|
[InlineData(0x10000000, false)]
|
|
public void GlobalConductorEndGapEnforcesFourByteVlq(long endTick, bool accepted)
|
|
{
|
|
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note(articulation: Articulation.PalmMute));
|
|
var profile = SyntheticProfiles.Switched(advance: endTick - 15_360).Build();
|
|
var plan = MidiTestData.Plan(composition, profile);
|
|
Assert.Equal(endTick, plan.EndTick);
|
|
if (!accepted)
|
|
{
|
|
Assert.Contains("four-byte VLQ", Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.Build(composition, plan)).Message);
|
|
return;
|
|
}
|
|
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
|
|
Assert.All(file.Chunks.Cast<TrackChunk>(), t => Assert.Equal(endTick, MidiTestData.Absolute(t).Last().Tick));
|
|
Assert.Equal(endTick, file.Chunks.Cast<TrackChunk>().First().Events.Last().DeltaTime);
|
|
}
|
|
|
|
[Fact]
|
|
public void DeltaConversionIsCheckedAndRejectsBackwardTime()
|
|
{
|
|
Assert.Equal(0, MidiFileBuilder.DeltaTicks(long.MaxValue, long.MaxValue));
|
|
Assert.Equal(0x0FFFFFFF, MidiFileBuilder.DeltaTicks(long.MaxValue, long.MaxValue - 0x0FFFFFFF));
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.DeltaTicks(0, 1));
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.DeltaTicks(0x10000000, 0));
|
|
Assert.Throws<OverflowException>(() => MidiFileBuilder.DeltaTicks(long.MaxValue, -1));
|
|
}
|
|
|
|
[Fact]
|
|
public void NullInvalidAndMismatchedCompositionFailWithoutDefaults()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
Assert.Throws<ArgumentNullException>(() => MidiFileBuilder.Build(null!, plan));
|
|
Assert.Throws<ArgumentNullException>(() => MidiFileBuilder.Build(composition, null!));
|
|
Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(new(120, new(4, 4), composition.Key, 4, []), plan));
|
|
Assert.Contains("extent", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
|
|
new(120, composition.Meter, composition.Key, 5, composition.Tracks), plan)).Message);
|
|
Assert.Contains("roles", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
|
|
new(120, composition.Meter, composition.Key, 4, [new(TrackRole.Bass, composition.Tracks[0].Notes)]), plan)).Message);
|
|
Assert.Contains("disagree", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
|
|
SyntheticProfiles.Model(SyntheticProfiles.Note(pitch: 65)), plan)).Message);
|
|
Assert.Contains("disagree", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
|
|
SyntheticProfiles.Model(SyntheticProfiles.Note(start: 1)), plan)).Message);
|
|
Assert.Throws<OperationCanceledException>(() => MidiFileBuilder.Build(composition, plan, new CancellationToken(true)));
|
|
}
|
|
|
|
[Fact]
|
|
public void SameTickMomentaryReleaseResetNewStateAndNotesKeepStableOrder()
|
|
{
|
|
var composition = SyntheticProfiles.Model(
|
|
SyntheticProfiles.Note(0, 1, articulation: Articulation.PalmMute),
|
|
SyntheticProfiles.Note(1, 1, articulation: Articulation.PalmMute));
|
|
var profile = SyntheticProfiles.Switched(StateBehavior.Momentary, advance: 0, duration: 30, cc: true).Build();
|
|
var plan = MidiTestData.Plan(composition, profile);
|
|
var track = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan)).Chunks.Cast<TrackChunk>().Last();
|
|
var boundary = MidiTestData.Absolute(track).Where(e => e.Tick == 960).Select(e => e.Event).ToArray();
|
|
Assert.Collection(boundary,
|
|
e => Assert.Equal(11, (int)Assert.IsType<NoteOffEvent>(e).NoteNumber),
|
|
e => Assert.Equal(64, (int)Assert.IsType<NoteOffEvent>(e).NoteNumber),
|
|
e => Assert.Equal(0, (int)Assert.IsType<ControlChangeEvent>(e).ControlValue),
|
|
e => Assert.Equal(100, (int)Assert.IsType<ControlChangeEvent>(e).ControlValue),
|
|
e => Assert.Equal(11, (int)Assert.IsType<NoteOnEvent>(e).NoteNumber),
|
|
e => Assert.Equal(64, (int)Assert.IsType<NoteOnEvent>(e).NoteNumber));
|
|
}
|
|
|
|
[Fact]
|
|
public void ExactRationalTripletsRetainTheirPlannedTicksAfterReadBack()
|
|
{
|
|
var composition = SyntheticProfiles.Model(Enumerable.Range(0, 12)
|
|
.Select(i => new MusicalNote(64, new(i, 3), new(1, 3), 96, Articulation.Sustain)).ToArray());
|
|
var plan = MidiTestData.Plan(composition);
|
|
var track = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan)).Chunks.Cast<TrackChunk>().Last();
|
|
var events = MidiTestData.Absolute(track);
|
|
Assert.Equal(Enumerable.Range(0, 12).Select(i => i * 320L),
|
|
events.Where(e => e.Event is NoteOnEvent).Select(e => e.Tick));
|
|
Assert.Equal(Enumerable.Range(1, 12).Select(i => i * 320L),
|
|
events.Where(e => e.Event is NoteOffEvent).Select(e => e.Tick));
|
|
}
|
|
|
|
[Fact]
|
|
public void FinalResetPulseTailExtendsEveryTrackWithoutSourceMutation()
|
|
{
|
|
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note(0, 16, articulation: Articulation.PalmMute));
|
|
var data = SyntheticProfiles.Switched(advance: 120, duration: 30, cc: true) with
|
|
{
|
|
Reset = Articulation.Sustain,
|
|
FinalControllers = [new(20, 0)]
|
|
};
|
|
var plan = MidiTestData.Plan(composition, data.Build());
|
|
Assert.Equal(15_480, plan.MusicalEndTick);
|
|
Assert.Equal(15_510, plan.EndTick);
|
|
var before = JsonSerializer.Serialize(new { composition, plan });
|
|
var first = MidiFileBuilder.Build(composition, plan);
|
|
var second = MidiFileBuilder.Build(composition, plan);
|
|
Assert.Equal(before, JsonSerializer.Serialize(new { composition, plan }));
|
|
Assert.Equal(MidiTestData.Bytes(first), MidiTestData.Bytes(second));
|
|
var file = MidiTestData.RoundTrip(first);
|
|
Assert.All(file.Chunks.Cast<TrackChunk>(), t => Assert.Equal(15_510, MidiTestData.Absolute(t).Last().Tick));
|
|
var tail = MidiTestData.Absolute(file.Chunks.Cast<TrackChunk>().Last()).Where(e => e.Tick >= 15_480).ToArray();
|
|
Assert.Collection(tail,
|
|
e => Assert.IsType<NoteOffEvent>(e.Event),
|
|
e => Assert.Equal(0, (int)Assert.IsType<ControlChangeEvent>(e.Event).ControlValue),
|
|
e => Assert.Equal(10, (int)Assert.IsType<NoteOnEvent>(e.Event).NoteNumber),
|
|
e => Assert.Equal(10, (int)Assert.IsType<NoteOffEvent>(e.Event).NoteNumber),
|
|
e => Assert.IsType<EndOfTrackEvent>(e.Event));
|
|
}
|
|
|
|
[Fact]
|
|
public void PinnedLibraryDoesNotEnforceSmfVlqLimitItself()
|
|
{
|
|
Assert.Equal(new Version(8, 0, 3, 0), typeof(MidiFile).Assembly.GetName().Version);
|
|
Assert.Empty(typeof(EndOfTrackEvent).GetConstructors());
|
|
Assert.Equal(typeof(byte), typeof(TimeSignatureEvent).GetProperty(nameof(TimeSignatureEvent.Denominator))!.PropertyType);
|
|
var file = new MidiFile(new TrackChunk(new ControlChangeEvent { DeltaTime = 0x10000000 }));
|
|
using var stream = new MemoryStream();
|
|
file.Write(stream, MidiFileFormat.MultiTrack);
|
|
Assert.True(stream.Length > 0);
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.DeltaTicks(0x10000000, 0));
|
|
}
|
|
}
|
|
|
|
internal static class MidiTestData
|
|
{
|
|
internal static (MusicalComposition Composition, MidiEventPlan Plan) Arrangement()
|
|
{
|
|
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note());
|
|
return (composition, Plan(composition));
|
|
}
|
|
|
|
internal static MidiEventPlan Plan(MusicalComposition composition, InstrumentProfile? profile = null)
|
|
{
|
|
var result = ArticulationPlanner.Plan(composition, [profile ?? new SyntheticProfiles.Data().Build()], allowSynthetic: true);
|
|
Assert.True(result.Success, string.Join("; ", result.Diagnostics));
|
|
return result.Plan!;
|
|
}
|
|
|
|
internal static byte[] Bytes(MidiFile file)
|
|
{
|
|
using var stream = new MemoryStream();
|
|
file.Write(stream, MidiFileFormat.MultiTrack);
|
|
return stream.ToArray();
|
|
}
|
|
|
|
internal static MidiFile RoundTrip(MidiFile file)
|
|
{
|
|
using var stream = new MemoryStream(Bytes(file));
|
|
return Read(stream);
|
|
}
|
|
|
|
internal static MidiFile Read(Stream stream) => MidiFile.Read(stream, new ReadingSettings
|
|
{
|
|
EndOfTrackStoringPolicy = EndOfTrackStoringPolicy.Store,
|
|
MissedEndOfTrackPolicy = MissedEndOfTrackPolicy.Abort
|
|
});
|
|
|
|
internal static (long Tick, MidiEvent Event)[] Absolute(TrackChunk track)
|
|
{
|
|
long tick = 0;
|
|
return track.Events.Select(e => (Tick: tick = checked(tick + e.DeltaTime), Event: e)).ToArray();
|
|
}
|
|
}
|