As Ed said, this sounds like a bug on Logic’s side.
That being said, the begin and end gesture calls are not designed to be called that frequently, that is on every value change.
Personally, if a slider is controlled with MIDI, I would still try to get a decent approximation of the gesture using a timer.
For example, when you receive a first parameter change from MIDI:
- start a countdown of, let’s say, 1sec.
- if you receive changes before the countdown is elapsed, simply apply them without calling gesture methods, and reset the countdown to always be 1sec after the last received message
- after 1sec without receiving any message, call
Of course this not perfect, it makes assumptions about MIDI messages timing, and you’ll need to play around with the countdown to find what works best, but in my opinion it is better that calling gesture functions on each parameter change.
This is sounds like a possible workaround and it does make sense, thank you Dimbouche for the suggestion. Will give it a try although i don’t know how it will affect other hosts.
But if we are not suppose to call gesture calls that often, it would be good to have a well designed juce method for midi control.
Well sadly I don’t think Juce can do anything. By definition, you cannot know when a MIDI device gesture starts and ends because there is no such thing as knowing when the user starts or stops touching a knob.
Regarding other hosts, I think it should only make things better. When a host receives a gesture start, it will open a new automation recording, or a new parameter mapping, for example. By spamming gesture calls you just increase the amount of work: instead of recording 1 automation with N values, it will record N automations with 1 value each and merge them together. Things like that.
Yes, of course there is way to predict user interaction, what i am suggesting is, instead of the developer having to make such a workaround which would require experimentation with values etc, this could be handled by juce if there was a method for midi control.
I understand that this was not an issue up to now, but if sending all these gestures via midi is considered a bad programming practice, then there could be a mechanism to handle this better.
Afterall, sending values to the DAW from a midi device is a fundamental function that has been done for many years and should work in an optimal way straight out of the box.
If we are doing it wrong, then also Apple may say that they don’t need to fix it because of this.
This workaround/method could be offered by juce perhaps with some variables to tweak (like a threshold).
I think that the Logic new update, 10.7.1, fixed the issue.
Thanks for letting us know, i wasn’t aware. I’ll give it a try later on today. Nevertheless, the point about flooding with gesture messages is valid and we should look into it further.
This will never, and should not, be handled by Juce.
The reason is that there is no way for a computer to reliably know when a MIDI device gesture begins and ends. Juce will not implement what I suggested because it is “hacky”, makes assumptions, and will fail under some conditions (since there is no guarantee on the MIDI messages income time).
We just have to accept that it is a MIDI hardware design limitation (or should I say “shortcoming” when it comes to interaction with plugins) and that we can just implement workarounds if we want to.
I guess if Logic already fixed the issue, you can just keep that idea somewhere and use complete gestures on each message for now
Just tested with 10.7.1
I think if someone were to guess what the outcome of this update is, they would never get it right
So here it is.
In LP 10.7.1 the juce sliders in our plugins are working properly, however the automation parameter in Logic is still lagging.
The fun part is that now when under Rosetta is much faster (but still lagging) than when ran natively on M1. On M1 is jumpy and slow like it was under Rosetta using 10.7
I had to test that a couple of times cause i could not believe what i was seeing.
LOL. I’m hoping the M2 will be a better processor. (and here we go again)
We have tried the timer trick and it has solved the problem of slow automation control response in Logic.
It actually works really well without any strange behavior.
Thanks Dimbouche for the suggestion!
There is no need for action since Logic 10.7.1 has fixed the issue and the midi control for automation issue can be solved using a timer to send much fewer gesture requests to the DAW.
That’s great news, glad it works as expected!