Apps to manipulate release velocity?

[AnotherScott]

I'd like to use an external board to trigger the sounds in a keyboard whose sounds employ release velocity. My external board doesn't do release (note off) velocity... it's always 64. What I'm thinking is to do some MIDI remapping such that all the Note Off velocities are converted from 64 to whatever the Note On velocity for that note was, figuring that's likely to almost always give me a better result than "64" (in that softly struck notes will have a lower than 64 release velocity, and strongly struck notes will have a higher. which I think is likely to be the preferred case much more often than not).

 

Does anyone know of apps that will do this, on any platform? MidiFire? Bome MIDI Translator Pro? Any of the general MIDI "control center" apps like Gig Performer, Camelot Pro, Keystage, etc.?

[DeltaJockey]

I frequently use the  midi modifier plugin in Logic for several other functions but not that combo. Interestingly, it has release velocity as an input with velocity as an output, but not the other way around. Is there some way you can modify the sound engine you're wanting to control, to some other type of input control? Then do some sort of other conversion?

[Deskew Tech]

10 hours ago, AnotherScott said:

Any of the general MIDI "control center" apps like Gig Performer, Camelot Pro, Keystage, etc.?

In Gig Performer, you could certainly create a simple scriplet plugin between your MIDI In block and your synth that would detect Note Off messages and change the release value to whatever you want

[Reezekeys]

Plogue Bidule should be able to do this. The current demo will run unrestricted until June 5. 

[Reezekeys]

I’m sure that with both Gig Performer or Bidule, almost any way you’d want to affect release velocity could be implemented. Thinking off the top of my head, you could assign a slider, knob, expression pedal, or the mod wheel on your controller to set or bias the release velocity.

[AnotherScott]

3 hours ago, Reezekeys said:

I’m sure that with both Gig Performer or Bidule, almost any way you’d want to affect release velocity could be implemented. Thinking off the top of my head, you could assign a slider, knob, expression pedal, or the mod wheel on your controller to set or bias the release velocity.

The trick is that I'm not merely trying add release velocity control, but that the control would be based on an input variable (the same key's preceding Note On velocity). So this does not call for a manual control (slider/knob/pedal/wheel), but rather an automatic but constantly varying value based on a previously occurring event. Merely "biasing" the release velocity won't do it, unless the amount of bias can be determined on-the-fly from that previously occurring variable. (Since the starting value is always 64, a fixed bias would make it always something else, which still isn't what I want... I want a high value for strongly struck notes, and a low value for quietly struck ones, varying in real-time as I play.)

 

3 hours ago, Deskew Tech said:

In Gig Performer, you could certainly create a simple scriplet plugin between your MIDI In block and your synth that would detect Note Off messages and change the release value to whatever you want

 So picking up from that, yes, it would need to "detect Note Off messages and change the release value to whatever you want" except that, specifically, the"whatever I want" is not something I could specify either as a fixed number or even as some number relative to the input value (which, as I said, is pointless since the input is always 64, so would only change one wrong fixed value to some other wrong fixed value)... rather, the release velocity value the Note Off message needs to be changed to the value that corresponds to the prior Note On velocity value for that same key. Can this be done?

[stoken6]

You need a scripting framework that allows you to persist ("remember") the note-on velocity, and apply it to the corresponding note-off. I don't know squat about these scripting tools, but that's your challenge right there.

 

Cheers, Mike

[K K]

You must have a very specific goal to achieve, since attack/on velocity and release/off velocity are events that often have no link at all. One can strike three notes with completely different strengths and release them all very fast or very slowly. Just like one can strike a triad with similar strength and then release each note a different way.

[AnotherScott]

1 hour ago, K K said:

You must have a very specific goal to achieve, since attack/on velocity and release/off velocity are events that often have no link at all. One can strike three notes with completely different strengths and release them all very fast or very slowly. Just like one can strike a triad with similar strength and then release each note a different way.

It's not perfect, but I'm figuring that, in general, a note that is played softly will also be released softly (i.e. should not have a loud release noise), whereas a note that is struck at high velocity is very likely to correspond with a release that should have a louder release noise (for those sounds that use velocity based release sounds, e.g. Rhodes). 

[Ibarch]

This should be possible to do in Ableton using a MaxForLive device. Somebody may have already written one to do something similar. If not, it wouldn't be the most difficult thing to do. 

 

MaxForLive requires an Ableton studio license. Unfortunately I only have standard or I would have been tempted to give it a go. 

[Reezekeys]

I just posted about this on the Plogue Bidule forum. Those folk are always helpful, and I expect I'll see some answers pretty quick. This is indeed a more complicated issue because you'd need to keep track of the open notes. I've never had to do anything like this in Bidule.

[JustPassin]

MidiFire Streambyter

 

if mt == 90

ass lm1 = m2

end

if mt == 80

ass m2 = lm1

end

[Reezekeys]

That SB script won't do exactly what I think Scott wants, though I use Streambyter on iOS and find it very powerful and essential to making my iOS rig work. It will apply the velocity value of only the last note-on received to every note-off sent before the next note-on comes in. So, it will work fine for single-note lines but be unpredictable for chords. E.g. play and hold a C major triad, then release each key individually; the note-off velocity value will be the same for all three notes, regardless of their note-on velocity values. Of course this may be good enough for Scott. I'm still working on a solution using Bidule though it's proving to be tougher than I thought!

[AnotherScott]

That's an interesting wrinkle, but I think that may actually be sufficient, I'd have to try it to be sure.

[JustPassin]

No, it remembers the velocity value of each incoming note separately and applies it as the release value to that same note.

[Reezekeys]

I'm here for my serving of crow! Looking at that Streambyter code I was sure it would act the way I said. That was not the case, as I found out after trying it. I don't understand exactly how it works, but it sure does! Another plug for this great app. Thanks for setting me straight. I'm abandoning my efforts on Bidule.

 

Six short lines of code, done. Scott, this is the app to get. To be fair, it helps if you've had some programming experience to get the most out of it. Mine ended with GFA Basic on the Atari ST in the 1990s, but with the help of a few newbie-tolerant folk in the Audeonic forum I've been able to duplicate my very involved AWB Bidule setup on my old iPhone. This app can do amost anything you can imagine with midi.

[JustPassin]

The trick is the LM1 - this uses the note number in M1 to index into the L array to store and retrieve the velocity value per note
 

Will work on all channels but if same note overlaps on multiple channels off velocity will indeed be that of most recent note on for that specific note. Unlikely on a live instrument. Solution would be to index into the W array with channel+note - left as an exercise!

[Reezekeys]

Thanks. I went back to the doc to read up on the different arrays. I appreciate the explanation!