Looping a drum pattern

[infojunkie]

I need some ideas to correctly loop a MIDI drum track, to avoid missing the last beat(s).

Here's a basic drum file. If you load that into SpessaSynth, the last beat will end abruptly, right after the last voice has played, but before the actual end of the bar.

I understand that MIDI does not have the concept of bars, but my question is: How to convince a player (SpessaSynth specifically, but preferably any MIDI player) to "wait" until the end of the last bar before looping?

In my own MIDI player (that I'm hoping to deprecate in favour of SpessaSynth), I artificially ensured that the MIDI End Of Track meta message would occur at the end of the last bar. I then instructed the MIDI player to keep playing until it encounters that message.

[spessasus]

By default, spessasynth sets the loop to first note on and end on last voice event. End of track is ignored.

In the file you provided, the end of track doesn't seem to be offset like you mentioned:

You can override loop end with the last event tick. Here's a complete example using the 4.0 API:

import Speaker from "speaker";
import fs from "fs/promises";
import {
    BasicMIDI,
    SoundBankLoader,
    SpessaSynthProcessor,
    SpessaSynthSequencer
} from "../src";
import { Readable } from "node:stream";

const midiFile = await fs.readFile("./basic-baião-2-4.mid");
const sfFile = await fs.readFile(
    "/home/spessasus/htdocs/SpessaSynth/soundfonts/gm.dls"
);

const synth = new SpessaSynthProcessor(48000);
synth.soundBankManager.addSoundBank(
    SoundBankLoader.fromArrayBuffer(sfFile.buffer as ArrayBuffer),
    "main"
);
const seq = new SpessaSynthSequencer(synth);
// Enable loop
seq.loopCount = Infinity;

const midi = BasicMIDI.fromArrayBuffer(midiFile.buffer as ArrayBuffer);

// Find last event tick
midi.loop.end = Math.max(
    ...midi.tracks.map((t) => t.events[t.events.length - 1].ticks)
);

seq.loadNewSongList([midi]);
seq.play();

// Play the midi via speaker
const bufSize = 128;
const audioStream = new Readable({
    read() {
        const left = new Float32Array(bufSize);
        const right = new Float32Array(bufSize);
        const arr = [left, right];
        seq.processTick();
        synth.renderAudio(arr, [], []);

        const interleaved = new Float32Array(left.length * 2);
        for (let i = 0; i < left.length; i++) {
            interleaved[i * 2] = left[i];
            interleaved[i * 2 + 1] = right[i];
        }

        const buffer = Buffer.alloc(interleaved.length * 4);
        for (let i = 0; i < interleaved.length; i++) {
            buffer.writeFloatLE(interleaved[i], i * 4);
        }
        this.push(buffer);
    }
});

const speaker = new Speaker({
    sampleRate: 44100,
    channels: 2,
    bitDepth: 32,
    // @ts-expect-error badly typed package
    float: true
});
audioStream.pipe(speaker);

Note that this doesn't work with the provided file as its EndOfTrack doesn't occur at the end of the bar, but if you adjust the file then it should work.

Another alternative is replacing endOfTrack with something like controller change that does nothing. Then it will work straight away.

PS: MIDI Files can have bars :-)

[infojunkie]

In the file you provided, the end of track doesn't seem to be offset like you mentioned

Yes, sorry, I should have clarified that I move the End Of Track message in real time when I read the file.

You can override loop end with the last event tick. Here's a complete example using the 4.0 API

Thanks! Just to make sure I understand: The actual place to set the loop time is midi.loop.end, correct?

Another alternative is replacing endOfTrack with something like controller change that does nothing. Then it will work straight away.

Thanks! I will try that as it sounds much more seamless.

PS: MIDI Files can have bars :-)

Please, say more :-)

[spessasus]

Just to make sure I understand: The actual place to set the loop time is midi.loop.end, correct?

Yes! Keep in mind that doing .flush() will overwrite it though. Though I could take the opportunity since I'm changing the API for 4.0 release to add an option to honor endOfTrack as loop end. But I'm not sure where to put it. Hmm, what do you think?

Please, say more :-)

https://karajam.org/ is a website based on an old version of spessasynth which I was commissioned to create. It includes some cool things like musical notation and chord detection. I'm considering adding musical notation to SpessaSynth itself.

[infojunkie]

Hmm, what do you think?

Seems to me it would be a Sequencer option, like autoPlay and preservePlaybackState.

https://karajam.org/ is a website based on an old version of spessasynth which I was commissioned to create. It includes some cool things like musical notation and chord detection. I'm considering adding musical notation to SpessaSynth itself.

Yes, cool stuff. I'm sure you'll do a good job with musical notation, I would just urge to make sure it's a decoupled module to allow other consumers to use the core synth only.

[infojunkie]

I'm considering adding musical notation to SpessaSynth itself.

From what I'm seeing on KaraJam, it looks like you are converting the MIDI to some sort of logical music format. My understanding is that the biggest challenge is to infer the correct note onsets and durations, especially when given human MIDI input. Some sort of quantization is needed, along with the inevitable loss of fidelity.

I've done a bit of work in this domain, enough to reach the really tricky parts :-D Here's a brief description of it: https://blog.karimratib.me/2024/10/01/music-grimoire-progress-report.html#groove-to-musicxml

[infojunkie]

Another alternative is replacing endOfTrack with something like controller change that does nothing. Then it will work straight away.

I implemented this (on v3.x) and it's working great. Thanks again!

Here's the code gist:

    const midi = new MIDI(incoming_midi_buffer);
    const duration = official_duration_as_calculated_outside_of_midi; 
    midi.tracks[0].push({
        ticks: Math.round(duration / (60000 / midi.tempoChanges[0].tempo / midi.timeDivision)),
        messageStatusByte: 185,
        messageData: new Uint16Array([50, 0]),
    });
    midi.flush();

[infojunkie]

With the release of v4.0.0, it's no longer possible to push an event to BasicMIDI.tracks[n].events (without casting events to an array that does not omit push).

On the other hand, MIDIBuilder (which does have an addEvent method) starts a MIDI file from scratch.

Is there a non-hacky way to add an event to an existing BasicMIDI object?

[infojunkie]

Answering my own question: MIDITrack.addEvent :-)

The code snippet above becomes:

    const midi = BasicMIDI.fromArrayBuffer(incoming_midi_buffer);
    const duration = official_duration_as_calculated_outside_of_midi; 
    midi.tracks[0].addEvent({
      ticks: Math.round(duration / (60000 / midi.tempoChanges[0].tempo / midi.timeDivision)),
      statusByte: midiMessageTypes.controllerChange,
      data: new Uint8Array([50, 0]),
    }, -1);
    midi.flush();

[spessasus]

Yes, I precisely removed .push() from events for addEvent instead which does a verification of a validity of the MIDI event.

PS:
spessasynth_core wiki contains more info about BasicMIDI itself. Lib's docs don't contain this because it's just a wrapper for core.

[infojunkie]

Actually, the above snippet broke the modified MIDI. A warning message said:

Unexpected EndOfTrack. Removing!

but the code seems to remove the event before EOT, resulting in MIDI data loss.

The snippet that's working for me now is:

    const midi = BasicMIDI.fromArrayBuffer(incoming_midi_buffer);
    const duration = official_duration_as_calculated_outside_of_midi;
    const ticks = Math.round(duration / (60000 / midi.tempoChanges[0].tempo / midi.timeDivision));
    midi.tracks[0].deleteEvent(-1);
    midi.tracks[0].pushEvent({
      ticks,
      statusByte: midiMessageTypes.controllerChange,
      data: new Uint8Array([50, 0]),
    });
    midi.tracks[0].pushEvent({
      ticks,
      statusByte: midiMessageTypes.endOfTrack,
      data: new Uint8Array(),
    });
    midi.flush();

where I first remove the existing EOT, then append the dummy CC followed by a new EOT at the same tick.

[infojunkie]

oh, npm run build:fast seems to work. Proceeding.

[infojunkie]

Yes, I confirm that switching the 2 lines fixes the issue. The previous event is not removed, and my initial snippet at #176 (comment) works now.

I do notice that an EOT event is added to the end, and not by me. I assume you expect that.

[spessasus]

Thanks! spessasynth_core 4.0.5 now includes the fix. Make sure to update!

And also thanks for the heads-up regarding building when you don't have examples installed. This is now fixed too!

[spessasus]

I do notice that an EOT event is added to the end, and not by me. I assume you expect that.

Hm. The only place where EOT is added is in the MIDI writer, at the end of each track:

https://github.com/spessasus/spessasynth_core/blob/f15654cd859558d5f7b46c9383993159f381503f/src/midi/midi_tools/midi_writer.ts#L70-L75

This is why .flus() filters out all EOT events. It gets added only when writing an SMF file. It's not needed for spessasynth to operate.

[infojunkie]

Hm. The only place where EOT is added is in the MIDI writer, at the end of each track:

Yes, this agrees with my scenario: In order to examine the MIDI file after I added the dummy CC, I call writeMIDI() to download the ArrayBuffer.