MSGS-style Drum Note Cut

[defensem3ch]

FluidSynth does not currently emulate a feature of Microsoft Wavetable GS MIDI synthesizer (MSGS) to cut a note in a drum kit (ignoring any release, if it has one) when a following note is played of the same pitch in the same MIDI channel. (A use case for this is gating a snare, e.g. by playing D2 velocity 100 followed quickly by velocity 1.) Thus it's not possible to render MIDI files using gm.dls and achieve the same result since this technique is not applied. I have attached a MIDI file as well as mp3s containing the results of rendering with MSGS (via Fruity LSD) vs FluidSynth. It would be wonderful if such behavior could be implemented and applied per user discretion.
notecut.zip

[derselbst]

The MIDI file you have provided simply uses overlapping notes. Neither the MIDI standard nor the SF2 spec specify how overlapping notes should be treated. Thus you cannot expect that every synth handles it in the same way. This is not even a "technique"; it's rather always an error.

I see the use-case for snare, hi-hats and other percussion, though. I can think of several ways how to implement this, but I don't know how to make a decision here. Ideally, you could point me to a specification or standard which describes the implementation of such a behavior, particularly "(A use case for this is gating a snare, e.g. by playing D2 velocity 100 followed quickly by velocity 1.)" - What does "quickly" mean here? Why does your MIDI file not use velocity 1, but rather mostly 3 and 2?

[defensem3ch]

How are the notes overlapping? The following note begins after the first note ends.

In this case I apologize - velocity 1 was only used as an example but the technique works for any drastic lowering in volume.
"Quickly" in this case means prior to the end of the release envelope. In the case of this particular snare drum, the duration of the sample is about 0.2 seconds. So 0.2 seconds or less in this particular instance.

[derselbst]

How are the notes overlapping? The following note begins after the first note ends.

Your MIDI application (whatever it is) seems to compensate the overlapping notes. Try rosegarden or MidiEditor.

"Quickly" in this case means prior to the end of the release envelope.

So, you're suggesting to only ignore / skip the release phase if there is a "drastic lowering in volume" done quickly? Or should the release phase always be skipped if NoteOns come in "too quickly"? And should this only be done for drum channels or also for melodic channels? And what use-cases would break if release phase of percussion instruments would be skipped that way? And again: Is there any standard / specification / recommendation that describes such a behavior?

[defensem3ch]

OK. I have attached a new MIDI file generated from Sekaiju, as well as two renderings via MSGS and FluidSynth. Unfortunately since MSGS has no technical documentation, I can't speak to any formal standard that might have been implemented regarding the intended behavior.

I am only suggesting to ignore the release when a new voice is instantiated by a proper MIDI note-on following a note-off,, assuming the sample has not reached the end of its duration by the time of note-off. I included a use case mentioning the detail about velocity merely to audibly illustrate one intended effect of this behavior.

This would be done for both drum channels as well as melodic channels, per my testing. It does not seem that there are any exceptions here - the example MIDI and mp3's are using Violin (program 40) as well as GM Standard drum kit.

I don't intend on breaking existing use cases where note release is intentionally held intact (technically allowing multiple instances of the same voice), but rather I request that this be implemented optionally per render or instance if user specifies note cut behavior to emulate MSGS.
MIDInotecut.zip

[derselbst]

I request that this be implemented optionally per render or instance if user specifies note cut behavior to emulate MSGS.

Here is the core-logic we use for a simple MIDI NoteOn:

fluidsynth/src/synth/fluid_synth_monopoly.c

Lines 652 to 717 in 3cf3f44

	int fluid_synth_noteon_monopoly_legato(fluid_synth_t *synth, int chan,
	int fromkey, int tokey, int vel)
	{
	fluid_channel_t *channel = synth->channel[chan];
	enum fluid_channel_legato_mode legatomode = channel->legatomode;
	fluid_voice_t *voice;
	int i ;
	/* Gets possible 'fromkey portamento' and possible 'fromkey legato' note */
	fromkey = fluid_synth_get_fromkey_portamento_legato(channel, fromkey);
	if(fluid_channel_is_valid_note(fromkey))
	{
	for(i = 0; i < synth->polyphony; i++)
	{
	/* searching fromkey voices: only those who don't have 'note off' */
	voice = synth->voice[i];
	if(fluid_voice_is_on(voice) &&
	fluid_voice_get_channel(voice) == chan &&
	fluid_voice_get_key(voice) == fromkey)
	{
	fluid_zone_range_t *zone_range = voice->zone_range;
	/* Ignores voice when there is no instrument zone (i.e no zone_range). Otherwise
	checks if tokey is inside the range of the running voice */
	if(zone_range && fluid_zone_inside_range(zone_range, tokey, vel))
	{
	switch(legatomode)
	{
	case FLUID_CHANNEL_LEGATO_MODE_RETRIGGER: /* mode 0 */
	fluid_voice_release(voice); /* normal release */
	break;
	case FLUID_CHANNEL_LEGATO_MODE_MULTI_RETRIGGER: /* mode 1 */
	/* Skip in attack section */
	fluid_voice_update_multi_retrigger_attack(voice, tokey, vel);
	/* Starts portamento if enabled */
	if(fluid_channel_is_valid_note(synth->fromkey_portamento))
	{
	/* Sends portamento parameters to the voice dsp */
	fluid_voice_update_portamento(voice,
	synth->fromkey_portamento,
	tokey);
	}
	/* The voice is now used to play tokey in legato manner */
	/* Marks this Instrument Zone to be ignored during next
	fluid_preset_noteon() */
	zone_range->ignore = TRUE;
	break;
	default: /* Invalid mode: this should never happen */
	FLUID_LOG(FLUID_WARN, "Failed to execute legato mode: %d",
	legatomode);
	return FLUID_FAILED;
	}
	}
	else
	{
	/* tokey note is outside the voice range, so the voice is released */
	fluid_voice_release(voice);
	}
	}
	}
	}

I hardly understand myself what's going on between all the legato, portamento and voice zones. That's why I would really like to avoid adding yet another optional setting into the deepest abyss of fluidsynth. Once I see that this causes trouble, I may reconsider that.

I included a use case mentioning the detail about velocity merely to audibly illustrate one intended effect of this behavior.

Ok, if it's solely for demonstration purposes this helps me shaping an implementation idea. Pls. let me know if this "skip-release-phase" behavior should also be applied when the sustain or sostenuto pedals of the MIDI channels are depressed (i.e. CC64 or CC66 set to 127).

[defensem3ch]

Pls. let me know if this "skip-release-phase" behavior should also be applied when the sustain or sostenuto pedals of the MIDI channels are depressed (i.e. CC64 or CC66 set to 127).

Yes, per my testing this behavior should also be applied both when sustain/CC64 and sostenuto/CC66 are set to 127.

[derselbst]

Yes, per my testing this behavior should also be applied both when sustain/CC64 and sostenuto/CC66 are set to 127.

Hm, ok. I managed to come up with a surprisingly simple idea and made an implementation proposal. Since you seem to be on Windows, you can grab the binaries from here:
https://dev.azure.com/tommbrt/tommbrt/_build/results?buildId=8681&view=artifacts&pathAsName=false&type=publishedArtifacts

I have applied this note-cut behavior only to drum channels. That's because after further digging I found that in #905 we require to properly release notes on melodic channels so that instruments (like esp. piano) sound naturally when hammering them multiple times.

Pls. have a test and let me know what you think about it.

[defensem3ch]

Thank you so much! I've given it one test so far and it's behaving as expected!

[derselbst]

Ok, great! I have opened a PR for this change, let's see what other users think about this: #1199

[defensem3ch]

I realized that it is possible to configure this behavior in the software SynthFont and have provided a screenshot of the implementation.