bl00mbox: shoegaze audio performance++/moar gfx

components/bl00mbox/CMakeLists.txt

@@ -15,6 +15,7 @@ idf_component_register(
         plugins/flanger.c
         plugins/sequencer.c
         plugins/noise.c
+        plugins/noise_burst.c
         plugins/distortion.c
         plugins/lowpass.c
         plugins/mixer.c

components/bl00mbox/bl00mbox_plugin_registry.c

@@ -96,6 +96,7 @@ radspa_descriptor_t * bl00mbox_plugin_registry_get_id_from_index(uint32_t index)
 #include "sampler.h"
 #include "flanger.h"
 #include "noise.h"
+#include "noise_burst.h"
 #include "distortion.h"
 #include "mixer.h"
 #include "slew_rate_limiter.h"
@@ -111,6 +112,7 @@ void bl00mbox_plugin_registry_init(void){
     plugin_add(&sampler_desc);
     plugin_add(&flanger_desc);
     plugin_add(&noise_desc);
+    plugin_add(&noise_burst_desc);
     plugin_add(&distortion_desc);
     plugin_add(&mixer_desc);
     plugin_add(&slew_rate_limiter_desc);

components/bl00mbox/plugins/noise_burst.c

+#include "noise_burst.h"
+
+radspa_descriptor_t noise_burst_desc = {
+    .name = "noise_burst",
+    .id = 7,
+    .description = "outputs flat noise upon trigger input for an amount of milliseconds",
+    .create_plugin_instance = noise_burst_create,
+    .destroy_plugin_instance = radspa_standard_plugin_destroy
+};
+
+#define NOISE_BURST_NUM_SIGNALS 3
+#define NOISE_BURST_OUTPUT 0
+#define NOISE_BURST_TRIGGER 1
+#define NOISE_BURST_LENGTH_MS 2
+
+radspa_t * noise_burst_create(uint32_t init_var){
+    radspa_t * noise_burst = radspa_standard_plugin_create(&noise_burst_desc, NOISE_BURST_NUM_SIGNALS, sizeof(noise_burst_data_t),0);
+    noise_burst->render = noise_burst_run;
+    radspa_signal_set(noise_burst, NOISE_BURST_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(noise_burst, NOISE_BURST_TRIGGER, "trigger", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
+    radspa_signal_set(noise_burst, NOISE_BURST_LENGTH_MS, "length", RADSPA_SIGNAL_HINT_INPUT, 100);
+    radspa_signal_get_by_index(noise_burst, NOISE_BURST_LENGTH_MS)->unit = "ms";
+
+    noise_burst_data_t * data = noise_burst->plugin_data;
+    data->counter = 15;
+    data->limit = 15;
+
+    return noise_burst;
+}
+
+#define SAMPLE_RATE_SORRY 48000
+
+
+void noise_burst_run(radspa_t * noise_burst, uint16_t num_samples, uint32_t render_pass_id){
+    noise_burst_data_t * plugin_data = noise_burst->plugin_data;
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(noise_burst, NOISE_BURST_OUTPUT);
+    if(output_sig->buffer == NULL) return;
+    radspa_signal_t * trigger_sig = radspa_signal_get_by_index(noise_burst, NOISE_BURST_TRIGGER);
+    radspa_signal_t * length_ms_sig = radspa_signal_get_by_index(noise_burst, NOISE_BURST_LENGTH_MS);
+
+    int16_t ret = output_sig->value;
+
+    for(uint16_t i = 0; i < num_samples; i++){
+
+        int16_t trigger = trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id);
+        int16_t vel = radspa_trigger_get(trigger, &(plugin_data->trigger_prev));
+
+        if(vel < 0){ // stop
+            plugin_data->counter = plugin_data->limit;
+        } else if(vel > 0 ){ // start
+            plugin_data->counter = 0;
+            int32_t length_ms = trigger_sig->get_value(length_ms_sig, i, num_samples, render_pass_id);
+            plugin_data->limit = length_ms * 48;
+        }
+        if(plugin_data->counter < plugin_data->limit){
+            ret = radspa_random();
+            plugin_data->counter++;
+        } else {
+            ret = 0;
+        }
+        if(output_sig->buffer != NULL) (output_sig->buffer)[i] = ret;
+    }
+    output_sig->value = ret;
+}

components/bl00mbox/plugins/noise_burst.h

+#pragma once
+#include "radspa.h"
+#include "radspa_helpers.h"
+
+typedef struct {
+    int32_t counter;
+    int32_t limit;
+    int16_t trigger_prev;    
+} noise_burst_data_t;
+
+extern radspa_descriptor_t noise_burst_desc;
+radspa_t * noise_burst_create(uint32_t init_var);
+void noise_burst_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
+

python_payload/apps/shoegaze/__init__.py

@@ -10,6 +10,7 @@ import bl00mbox
 
 import leds
 import hardware
+import random
 
 chords = [
     [-5, -5, 2, 7, 10],
@@ -88,6 +89,11 @@ class ShoegazeApp(Application):
         self._git_string_tuning = [0] * 4
         self._button_prev = 0
         self._update_connections()
+        self._spinny = -0.5
+        self._gaze_counter = 0
+        self._rand_counter = 0
+        self._rand_limit = 16
+        self._rand_rot = 0.0
 
     def _update_connections(self) -> None:
         if self.fuzz_on:
@@ -124,7 +130,7 @@ class ShoegazeApp(Application):
         self._update_connections()
 
     def _set_chord(self, i: int) -> None:
-        hue = int(72 * (i + 0.5)) % 360
+        hue = int(54 * (i + 0.5)) % 360
         if i != self.chord_index:
             self.chord_index = i
             for j in range(40):
@@ -134,31 +140,55 @@ class ShoegazeApp(Application):
 
     def draw(self, ctx: Context) -> None:
         ctx.text_align = ctx.CENTER
-        ctx.font = ctx.get_font_name(5)
-        ctx.font_size = 30
+        self._rand_counter += 1
+        if self._rand_counter > self._rand_limit:
+            self._rand_counter = 0
+            self._rand_rot = 0.01 * float(random.getrandbits(3))
+        if self._rand_counter == 1:
+            self._rand_limit = 2 + random.getrandbits(3)
 
         ctx.rgb(0, 0, 0).rectangle(-120, -120, 240, 240).fill()
-
-        ctx.move_to(60, 60)
+        ctx.font = ctx.get_font_name(5)
+        ctx.font_size = 35
+
+        ctx.move_to(0, -112)
+        ctx.rgb(0.2, 0, 0.2)
+        ctx.text("bass")
+
+        rot = self._spinny  # + self._detune_prev
+        ctx.rgb(0, 0.5, 0.5)
+        ctx.rotate(rot + self._rand_rot)
+        ctx.move_to(0, -10)
+        ctx.text("shoegazeshoegazeshoe")
+        ctx.move_to(0, 10)
+        ctx.text("gazeshoegazeshoegaze")
+        ctx.rotate(-2.2 * (rot + self._rand_rot) - 0.5)
+
+        ctx.move_to(40, 40)
         if self.delay_on:
-            ctx.rgb(0, 255, 0)
+            ctx.rgb(0, 0.8, 0)
             ctx.text("delay ON!")
         else:
-            ctx.rgb(255, 0, 0)
+            ctx.rgb(0, 0.6, 0)
             ctx.text("delay off")
 
+        ctx.rotate(0.2 + self._rand_rot)
+
         ctx.move_to(50, -50)
         detune = "detune: " + str(int(self._detune_prev * 100))
-        ctx.rgb(0, 255, 0)
-        ctx.text(detune).rotate(-10)
+        ctx.rgb(0, 0.8, 0)
+        ctx.text(detune)
+
+        ctx.rotate(-2.5 * (rot + 4 * self._rand_rot))
 
         ctx.move_to(-50, 50)
         if self.fuzz_on:
-            ctx.rgb(0, 255, 0)
+            ctx.rgb(0, 0.8, 0)
             ctx.text("fuzz ON!")
         else:
-            ctx.rgb(255, 0, 0)
+            ctx.rgb(0, 0.6, 0)
             ctx.text("fuzz off")
+
         ctx.restore()
 
     def think(self, ins: InputState, delta_ms: int) -> None:

python_payload/bl00mbox/_patches.py

@@ -281,30 +281,21 @@ class karplus_strong(_Patch):
     def __init__(self, chan):
         self.buds = _PatchBudList()
         self.signals = _PatchSignalList()
-        self.buds.noise = chan.new_bud(bl00mbox.plugins.noise)
+
+        self.buds.noise = chan.new_bud(bl00mbox.plugins.noise_burst)
+        self.buds.noise.signals.length = 25
+
         self.buds.flanger = chan.new_bud(bl00mbox.plugins.flanger)
-        self.buds.amp = chan.new_bud(bl00mbox.plugins.ampliverter)
-        self.buds.env = chan.new_bud(bl00mbox.plugins.env_adsr)
-        # self.buds.slew = chan.new_bud(bl00mbox.plugins.slew_rate_limiter)
 
         self.buds.flanger.signals.resonance = 32500
         self.buds.flanger.signals.manual.tone = "A2"
 
-        self.buds.env.signals.sustain = 0
-        self.buds.env.signals.decay = 20
-        self.buds.env.signals.attack = 5
+        self.buds.flanger.signals.input = self.buds.noise.signals.output
 
-        self.buds.amp.signals.output = self.buds.flanger.signals.input
-        self.buds.amp.signals.input = self.buds.noise.signals.output
-        # self.buds.amp.signals.input = self.buds.slew.signals.output
-        # self.buds.slew.signals.input = self.buds.noise.signals.output
-        # self.buds.slew.signals.slew_rate = 10000
-        self.buds.amp.signals.gain = self.buds.env.signals.output
-
-        self.signals.trigger = self.buds.env.signals.trigger
+        self.signals.trigger = self.buds.noise.signals.trigger
         self.signals.pitch = self.buds.flanger.signals.manual
         self.signals.output = self.buds.flanger.signals.output
-        # self.signals.slew_rate = self.buds.slew.signals.slew_rate
+
         self.signals.level = self.buds.flanger.signals.level
         self.decay = 1000