Allow to schedule multi param changes so they happen in sync

Signed-off-by: falkTX <falktx@falktx.com>

Author: falkTX

src/effects.c

@@ -611,6 +611,11 @@ typedef struct HMI_ADDRESSING_T {
 } hmi_addressing_t;
 #endif
 
+typedef struct SYNC_SCHEDULED_PARAM_T {
+    port_t *port;
+    float value;
+} sync_scheduled_param_t;
+
 typedef struct POSTPONED_PARAMETER_EVENT_T {
     int effect_id;
     const char* symbol;
@@ -725,6 +730,7 @@ typedef struct RAW_MIDI_PORT_ITEM {
 typedef struct CACHED_EFFECT_FLUSH_T {
     effect_t *effect;
     port_t **ports;
+    int num_ports;
 } cached_effect_flush_t;
 
 
@@ -861,6 +867,11 @@ static pthread_mutex_t g_midi_learning_mutex;
 static bool g_monitored_midi_controls[16];
 static bool g_monitored_midi_programs[16];
 
+/* Postponed port updates */
+static sync_scheduled_param_t g_sync_scheduled_params[MAX_SYNC_SCHEDULED_PARAMS];
+static pthread_mutex_t g_sync_scheduled_params_mutex;
+static unsigned int g_sync_scheduled_param_count;
+
 #ifdef HAVE_HYLIA
 static hylia_t* g_hylia_instance;
 static hylia_time_info_t g_hylia_timeinfo;
@@ -911,6 +922,7 @@ static void* PostPonedEventsThread(void* arg);
 #ifdef MOD_HMI_CONTROL_ENABLED
 static void* HMIClientThread(void* arg);
 #endif
+static void SyncScheduledParams(bool realtime);
 static void PreRunPlugin(effect_t *effect);
 static int ProcessPlugin(jack_nframes_t nframes, void *arg);
 static bool SetPortValue(port_t *port, float value, int effect_id, bool is_bypass, bool from_ui);
@@ -1901,6 +1913,33 @@ static void* HMIClientThread(void* arg)
 }
 #endif
 
+static void SyncScheduledParams(bool realtime)
+{
+    port_t *port;
+
+    if (realtime)
+    {
+        if (pthread_mutex_trylock(&g_sync_scheduled_params_mutex) != 0)
+            return;
+    }
+    else
+    {
+        pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+    }
+
+    for (unsigned int i = 0; i < g_sync_scheduled_param_count; i++)
+    {
+        port = g_sync_scheduled_params[i].port;
+        port->prev_value = *port->buffer = g_sync_scheduled_params[i].value;
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+        port->hints |= HINT_SHOULD_UPDATE;
+#endif
+    }
+
+    g_sync_scheduled_param_count = 0;
+    pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
+}
+
 static void PreRunPlugin(effect_t *effect)
 {
     if ((effect->hints & HINT_IS_LIVE) == 0 &&
@@ -3369,6 +3408,9 @@ static void JackTimebase(jack_transport_state_t state, jack_nframes_t nframes,
 
     pos->tick = (int32_t)(tick + 0.5);
     pos->tick_double = tick;
+
+    // (ab)use this early jack callback to change parameters in sync
+    SyncScheduledParams(true);
     return;
 
     UNUSED_PARAM(state);
@@ -4498,6 +4540,7 @@ int effects_init(void* client)
     pthread_mutex_init(&g_raw_midi_port_mutex, &mutex_atts);
     pthread_mutex_init(&g_audio_monitor_mutex, &mutex_atts);
     pthread_mutex_init(&g_midi_learning_mutex, &mutex_atts);
+    pthread_mutex_init(&g_sync_scheduled_params_mutex, &mutex_atts);
 #ifdef MOD_HMI_CONTROL_ENABLED
     pthread_mutex_init(&g_hmi_mutex, &mutex_atts);
 #endif
@@ -4644,7 +4687,7 @@ int effects_init(void* client)
 
     /* Set jack callbacks */
     jack_set_thread_init_callback(g_jack_global_client, JackThreadInit, NULL);
-    jack_set_timebase_callback(g_jack_global_client, 1, JackTimebase, NULL);
+    jack_set_timebase_callback(g_jack_global_client, 0, JackTimebase, NULL);
     jack_set_process_callback(g_jack_global_client, ProcessGlobalClient, NULL);
     jack_set_buffer_size_callback(g_jack_global_client, BufferSize, NULL);
     jack_set_port_registration_callback(g_jack_global_client, PortRegistration, NULL);
@@ -5084,6 +5127,7 @@ int effects_finish(int close_client)
     pthread_mutex_destroy(&g_raw_midi_port_mutex);
     pthread_mutex_destroy(&g_audio_monitor_mutex);
     pthread_mutex_destroy(&g_midi_learning_mutex);
+    pthread_mutex_destroy(&g_sync_scheduled_params_mutex);
 #ifdef MOD_HMI_CONTROL_ENABLED
     pthread_mutex_destroy(&g_hmi_mutex);
 #endif
@@ -6561,11 +6605,19 @@ int effects_remove(int effect_id)
 
         start = 0;
         end = MAX_PLUGIN_INSTANCES;
+
+        // clear all sync scheduled params if removing all plugins
+        pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+        g_sync_scheduled_param_count = 0;
+        pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
     }
     else
     {
         start = effect_id;
         end = start + 1;
+
+        // trigger sync scheduled params now for no dangling pointers
+        SyncScheduledParams(false);
     }
 
     // stop plugins processing
@@ -7000,17 +7052,36 @@ int effects_set_parameter_multi(const char *control_symbol, float value, int num
     }
 
     // the critical loop, must be as fast and small as possible
-    port_t *port;
-    for (int i = 0; i < num_ports; i++)
+    bool scheduled = true;
+    pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+    if (g_sync_scheduled_param_count + num_ports <= MAX_SYNC_SCHEDULED_PARAMS)
+    {
+        int p = g_sync_scheduled_param_count;
+        for (int i = 0; i < num_ports; i++, p++)
+        {
+            g_sync_scheduled_params[p].port = ports[i];
+            g_sync_scheduled_params[p].value = value;
+        }
+        g_sync_scheduled_param_count = p;
+    }
+    else
     {
-        port = ports[i];
-        port->prev_value = *port->buffer = value;
+        scheduled = false;
     }
+    pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
 
+    if (! scheduled)
+    {
+        // no space to schedule events, trigger param changes now
+        for (int i = 0; i < num_ports; i++)
+        {
+            port_t *port = ports[i];
+            port->prev_value = *port->buffer = value;
 #ifdef WITH_EXTERNAL_UI_SUPPORT
-    for (int i = 0; i < num_ports; i++)
-        ports[i]->hints |= HINT_SHOULD_UPDATE;
+            port->hints |= HINT_SHOULD_UPDATE;
 #endif
+        }
+    }
 
     free(ports);
 
@@ -7080,6 +7151,7 @@ int effects_flush_parameters_multi(int reset, int param_count, const flushed_par
     if (num_effects == 1)
         return effects_flush_parameters(*effects, reset, param_count, params);
 
+    cached_effect_flush_t *cached_effect;
     effect_t *effect;
     port_t *port;
 
@@ -7096,54 +7168,70 @@ int effects_flush_parameters_multi(int reset, int param_count, const flushed_par
         {
             effect = &(g_effects[effect_id]);
 
-            cached_effect_flush_t *cached_effect = &cached_effects[num_cached_effects++];
+            cached_effect = &cached_effects[num_cached_effects++];
             cached_effect->effect = effect;
             cached_effect->ports = malloc(sizeof(port_t*) * param_count);
+            cached_effect->num_ports = 0;
 
             for (int j = 0; j < param_count; j++)
-                cached_effect->ports[j] = FindEffectInputPortBySymbol(effect, params[j].symbol);
+            {
+                if ((cached_effect->ports[cached_effect->num_ports] = FindEffectInputPortBySymbol(effect, params[j].symbol)))
+                    ++cached_effect->num_ports;
+            }
         }
     }
 
-    for (int i = 0; i < num_cached_effects; i++)
+    // the critical loop, must be as fast and small as possible
+    bool scheduled = true;
+    const int resetb = reset != 0 ? 1 : 0;
+    pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+    if (g_sync_scheduled_param_count + (param_count + resetb) * num_cached_effects <= MAX_SYNC_SCHEDULED_PARAMS)
     {
-        effect = cached_effects[i].effect;
-        if (effect->reset_index >= 0 && reset != 0)
+        int p = g_sync_scheduled_param_count;
+        for (int i = 0; i < num_cached_effects; i++)
         {
-            port = effect->ports[effect->reset_index];
-            port->prev_value = *(port->buffer) = reset;
+            cached_effect = &cached_effects[i];
+            effect = cached_effect->effect;
+            for (int j = 0; j < cached_effect->num_ports; j++, p++)
+            {
+                g_sync_scheduled_params[p].port = cached_effect->ports[j];
+                g_sync_scheduled_params[p].value = params[j].value;
+            }
+            if (effect->reset_index >= 0 && reset != 0)
+            {
+                g_sync_scheduled_params[p].port = effect->ports[effect->reset_index];
+                g_sync_scheduled_params[p].value = reset;
+                ++p;
+            }
         }
+        g_sync_scheduled_param_count = p;
+    }
+    else
+    {
+        scheduled = false;
     }
+    pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
 
-    // the critical loop, must be as fast and small as possible
-    for (int j = 0; j < param_count; j++)
+    if (! scheduled)
     {
+        // no space to schedule events, trigger param changes now
         for (int i = 0; i < num_cached_effects; i++)
         {
-            if ((port = cached_effects[i].ports[j]))
+            cached_effect = &cached_effects[i];
+            effect = cached_effect->effect;
+            for (int j = 0; j < cached_effect->num_ports; j++)
+            {
+                port = cached_effect->ports[j];
                 port->prev_value = *(port->buffer) = params[j].value;
-        }
-    }
-
 #ifdef WITH_EXTERNAL_UI_SUPPORT
-    for (int i = 0; i < num_cached_effects; i++)
-    {
-        for (int j = 0; j < param_count; j++)
-        {
-            if ((port = cached_effects[i].ports[j]))
                 port->hints |= HINT_SHOULD_UPDATE;
-        }
-    }
 #endif
-
-    // reset a 2nd time in case plugin was processing while we changed parameters
-    for (int i = 0; i < num_cached_effects; i++)
-    {
-        effect = cached_effects[i].effect;
-        if (effect->reset_index >= 0 && reset != 0)
-        {
-            port = effect->ports[effect->reset_index];
-            port->prev_value = *(port->buffer) = reset;
+            }
+            if (effect->reset_index >= 0 && reset != 0)
+            {
+                port = effect->ports[effect->reset_index];
+                port->prev_value = *(port->buffer) = reset;
+            }
         }
     }
 

src/effects.h

@@ -97,6 +97,8 @@ typedef enum {
 #define MAX_POSTPONED_EVENTS    8192
 #define MAX_HMI_ADDRESSINGS     128
 
+#define MAX_SYNC_SCHEDULED_PARAMS 512
+
 // used for local stack variables
 #define MAX_CHAR_BUF_SIZE       255