bl00mbox: upstream updates

- sequencer value mode fixes
- better rms

components/bl00mbox/bl00mbox_audio.c

@@ -280,12 +280,13 @@ static bool bl00mbox_audio_channel_render(bl00mbox_channel_t * chan, int16_t * o
         }
     }
     if(chan->compute_mean_square){
-        uint32_t decay = 1000000UL;
         for(uint16_t i = 0; i < full_buffer_len; i++){
             int32_t sq = acc[i];
-            sq *= sq;
-            chan->mean_square = (((uint64_t) chan->mean_square) * (UINT32_MAX-decay-1)) >> 32;
-            chan->mean_square += (((uint64_t) sq)*decay) >> 32;
+            sq = (sq * sq) - chan->mean_square;
+            // always round down with negative sq so that decay always works.
+            // bitshift instead of div does that for us nicely.
+            // cannot underflow as ((-a) >> 11) can never be less than -a.
+            chan->mean_square += sq >> 11;
         }
     }
     return true;

components/bl00mbox/radspa/standard_plugin_lib/sequencer.c

@@ -55,7 +55,7 @@ void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_p
 
     int16_t s1 = radspa_signal_get_value(end_step_sig, 0, render_pass_id);
     int16_t s2 = data->track_step_len - 1;
-    data->step_end = s1 > 0 ? (s1 > s2 ? s2 : s1) : 1;
+    data->step_end = s1 > 0 ? (s1 > s2 ? s2 : s1) : 0;
     data->step_start = radspa_signal_get_value(start_step_sig, 0, render_pass_id);
 
     int16_t bpm = radspa_signal_get_value(bpm_sig, 0, render_pass_id);
@@ -63,7 +63,6 @@ void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_p
 
     if((bpm != data->bpm_prev) || (beat_div != data->beat_div_prev)){
         data->counter_target = target(data->track_step_len, bpm, beat_div);
-        data->is_stopped = data->counter_target ? false : true;
         data->bpm_prev = bpm;
         data->beat_div_prev = beat_div;
     }
@@ -71,23 +70,43 @@ void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_p
     for(uint16_t i = 0; i < num_samples; i++){
         int16_t sync_in = radspa_trigger_get(radspa_signal_get_value(sync_in_sig, i, render_pass_id),
                 &(data->sync_in_hist));
-        if(sync_in > 0){
+        if(sync_in){
             data->counter = 0;
             data->step = data->step_start;
-            data->sync_out_start = true;
-            data->sync_out_stop = false;
-        } else if(sync_in < 0){
-            data->is_stopped = true; // stop signal
-            data->sync_out_start = false;
-            data->sync_out_stop = true;
+            bool start = sync_in > 0;
+            data->is_stopped = !start;
+            data->sync_out_start = start;
+            data->sync_out_stop = !start;
+            if(!start){
+                for(uint8_t j = 0; j < data->num_tracks; j++){
+                    int16_t type = table[j * (data->track_step_len + 1)];
+                    int16_t stage_val = table[data->step + 1 + (1 + data->track_step_len) * j];
+                    if(type == -32767) stage_val = -1;
+                    if((!tracks[j].changed) && (tracks[j].stage_val_prev != stage_val)){
+                        tracks[j].changed = true;
+                        tracks[j].stage_val_prev = stage_val;
+                        for(uint16_t k = 0; k < i; k++){
+                            radspa_signal_set_value(track_sigs[j], k, tracks[j].track_fill);
+                        }
+                    }
+                    if(type == 32767){
+                        tracks[j].track_fill = stage_val;
+                    } else if(type == -32767){
+                        if(stage_val > 0){
+                            radspa_trigger_start(stage_val, &(tracks[j].track_fill));
+                        } else if(stage_val < 0){
+                            radspa_trigger_stop(&(tracks[j].track_fill));
+                        }
+                    }
+                    tracks[j].stage_val_prev = stage_val;
+                }
+            }
         } else {
             data->sync_out_start = false;
             data->sync_out_stop = false;
         }
 
-        if(!data->is_stopped){
-            data->counter++;
-
+        if(!data->is_stopped && data->counter_target){
             if(data->counter >= data->counter_target){
                 data->counter = 0;
                 data->step++;
@@ -96,7 +115,6 @@ void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_p
                     data->sync_out_start = true;
                 }
             }
-
             if(!data->counter){ //event just happened
                 for(uint8_t j = 0; j < data->num_tracks; j++){
                     int16_t type = table[j * (data->track_step_len + 1)];
@@ -120,6 +138,7 @@ void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_p
                     tracks[j].stage_val_prev = stage_val;
                 }
             }
+            data->counter++;
         }
 
         for(uint8_t j = 0; j < data->num_tracks; j++){
@@ -136,6 +155,11 @@ void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_p
     }
     for(uint8_t j = 0; j < data->num_tracks; j++){
         if(!tracks[j].changed){
+            int16_t type = table[j * (data->track_step_len + 1)];
+            if(type == 32767){
+                tracks[j].track_fill = table[data->step + 1 + (1 + data->track_step_len) * j];
+                tracks[j].stage_val_prev = tracks[j].track_fill;
+            }
             radspa_signal_set_const_value(track_sigs[j], tracks[j].track_fill);
         } else {
             tracks[j].changed = false;
@@ -170,7 +194,7 @@ radspa_t * sequencer_create(uint32_t init_var){
     data->counter_target = target(data->track_step_len, data->bpm_prev, data->beat_div_prev);
     radspa_signal_set(sequencer, SEQUENCER_STEP, "step", RADSPA_SIGNAL_HINT_OUTPUT, 0);
     radspa_signal_set(sequencer, SEQUENCER_SYNC_OUT, "sync_out", RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(sequencer, SEQUENCER_SYNC_IN, "sync_in", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
+    radspa_signal_set(sequencer, SEQUENCER_SYNC_IN, "sync_in", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 32767);
     radspa_signal_set(sequencer, SEQUENCER_START_STEP, "step_start", RADSPA_SIGNAL_HINT_INPUT, 0);
     radspa_signal_set(sequencer, SEQUENCER_END_STEP, "step_end", RADSPA_SIGNAL_HINT_INPUT, num_steps-1);
     radspa_signal_set(sequencer, SEQUENCER_BPM, "bpm", RADSPA_SIGNAL_HINT_INPUT, data->bpm_prev);
@@ -183,7 +207,7 @@ radspa_t * sequencer_create(uint32_t init_var){
     data->sync_out_hist = 0;
     data->sync_out_start = false;
     data->sync_out_stop = false;
-    data->is_stopped = false;
+    data->is_stopped = true;
     sequencer_track_data_t * tracks = (void *) (&data[1]);
     for(uint8_t j = 0; j < data->num_tracks; j++){
         tracks[j].changed = false;