diff --git a/components/bl00mbox/bl00mbox.c b/components/bl00mbox/bl00mbox.c index ade8e30295642a7b1d6ad5bc34a333924b62683b..a31700e299c7c67e0d8bf84f79a81c81e13f3801 100644 --- a/components/bl00mbox/bl00mbox.c +++ b/components/bl00mbox/bl00mbox.c @@ -1,10 +1,10 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #include "bl00mbox.h" -#include "bl00mbox_audio.h" #include "bl00mbox_plugin_registry.h" +#include "bl00mbox_audio.h" #include "st3m_audio.h" -void bl00mbox_init() { +void bl00mbox_init(){ bl00mbox_plugin_registry_init(); st3m_audio_set_player_function(bl00mbox_audio_render); bl00mbox_channels_init(); diff --git a/components/bl00mbox/bl00mbox_audio.c b/components/bl00mbox/bl00mbox_audio.c index ba19f3d2186e23b738ef1f6d69381ec8ef38b1d4..deaca35dba952234438adb1dc22c52787f457e03 100644 --- a/components/bl00mbox/bl00mbox_audio.c +++ b/components/bl00mbox/bl00mbox_audio.c @@ -1,10 +1,10 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #include "bl00mbox_audio.h" static bool is_initialized = false; static bool bl00mbox_audio_run = true; -void bl00mbox_audio_enable() { bl00mbox_audio_run = true; } -void bl00mbox_audio_disable() { bl00mbox_audio_run = false; } +void bl00mbox_audio_enable(){ bl00mbox_audio_run = true; } +void bl00mbox_audio_disable(){ bl00mbox_audio_run = false; } static uint32_t render_pass_id; @@ -15,14 +15,11 @@ static int8_t last_chan_event = 0; // note: regardless of settings the system channel 0 is always rendered static uint8_t bl00mbox_channel_foreground = 0; // channels may request being active while not being in foreground -static bool bl00mbox_channel_background_mute_override[BL00MBOX_CHANNELS] = { - false, -}; +static bool bl00mbox_channel_background_mute_override[BL00MBOX_CHANNELS] = {false,}; -bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, - bool enable) { +bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, bool enable){ #ifdef BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE - if (channel_index >= BL00MBOX_CHANNELS) return false; + if(channel_index >= BL00MBOX_CHANNELS) return false; bl00mbox_channel_background_mute_override[channel_index] = enable; return true; #else @@ -30,39 +27,38 @@ bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, #endif } -bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index) { - if (channel_index >= BL00MBOX_CHANNELS) return false; +bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index){ + if(channel_index >= BL00MBOX_CHANNELS) return false; return bl00mbox_channel_background_mute_override[channel_index]; } -static void** ptr_to_be_set_by_audio_task = NULL; -static void* ptr_to_be_set_by_audio_task_target = NULL; +static void ** ptr_to_be_set_by_audio_task = NULL; +static void * ptr_to_be_set_by_audio_task_target = NULL; // TODO: multicore thread safety on this boi static volatile bool ptr_set_request_pending = false; static uint64_t bl00mbox_audio_waitfor_timeout = 0ULL; -bool bl00mbox_audio_waitfor_pointer_change(void** ptr, void* new_val) { - if (!is_initialized) return false; +bool bl00mbox_audio_waitfor_pointer_change(void ** ptr, void * new_val){ /// takes pointer to pointer that is to be set null + if(!is_initialized) return false; ptr_to_be_set_by_audio_task = ptr; ptr_to_be_set_by_audio_task_target = new_val; ptr_set_request_pending = true; - volatile uint64_t timeout = 0; // cute - while (ptr_set_request_pending) { + volatile uint64_t timeout = 0; // cute + while(ptr_set_request_pending){ timeout++; // TODO: nop - if (bl00mbox_audio_waitfor_timeout && - (timeout = bl00mbox_audio_waitfor_timeout)) { + if(bl00mbox_audio_waitfor_timeout && (timeout = bl00mbox_audio_waitfor_timeout)){ return false; } } return true; } -bool bl00mbox_audio_do_pointer_change() { - if (ptr_set_request_pending) { - (*ptr_to_be_set_by_audio_task) = ptr_to_be_set_by_audio_task_target; +bool bl00mbox_audio_do_pointer_change(){ + if(ptr_set_request_pending){ + (* ptr_to_be_set_by_audio_task) = ptr_to_be_set_by_audio_task_target; ptr_to_be_set_by_audio_task_target = NULL; ptr_to_be_set_by_audio_task = NULL; ptr_set_request_pending = false; @@ -71,26 +67,28 @@ bool bl00mbox_audio_do_pointer_change() { return false; } -void bl00mbox_channel_event(uint8_t chan) { last_chan_event = chan; } +void bl00mbox_channel_event(uint8_t chan){ + last_chan_event = chan; +} -bl00mbox_channel_t* bl00mbox_get_channel(uint8_t index) { - if (index >= BL00MBOX_CHANNELS) return NULL; +bl00mbox_channel_t * bl00mbox_get_channel(uint8_t index){ + if(index >= BL00MBOX_CHANNELS) return NULL; return &(channels[index]); } -uint8_t bl00mbox_channel_get_foreground_index() { +uint8_t bl00mbox_channel_get_foreground_index(){ return bl00mbox_channel_foreground; } -void bl00mbox_channel_set_foreground_index(uint8_t index) { - if (index >= BL00MBOX_CHANNELS) return; +void bl00mbox_channel_set_foreground_index(uint8_t index){ + if(index >= BL00MBOX_CHANNELS) return; bl00mbox_channel_foreground = index; } -uint8_t bl00mbox_channel_get_free_index() { +uint8_t bl00mbox_channel_get_free_index(){ uint8_t ret = 1; - for (; ret < BL00MBOX_CHANNELS; ret++) { - if (bl00mbox_get_channel(ret)->is_free) { + for(; ret < BL00MBOX_CHANNELS; ret++){ + if(bl00mbox_get_channel(ret)->is_free){ bl00mbox_get_channel(ret)->is_free = false; break; } @@ -99,9 +97,9 @@ uint8_t bl00mbox_channel_get_free_index() { return ret; } -void bl00mbox_channels_init() { - for (uint8_t i = 0; i < BL00MBOX_CHANNELS; i++) { - bl00mbox_channel_t* chan = bl00mbox_get_channel(i); +void bl00mbox_channels_init(){ + for(uint8_t i = 0; i < BL00MBOX_CHANNELS; i++){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(i); chan->volume = BL00MBOX_DEFAULT_CHANNEL_VOLUME; chan->root_list = NULL; chan->buds = NULL; @@ -112,69 +110,66 @@ void bl00mbox_channels_init() { is_initialized = true; } -void bl00mbox_channel_enable(uint8_t chan) { - if (chan >= (BL00MBOX_CHANNELS)) return; - bl00mbox_channel_t* ch = bl00mbox_get_channel(chan); +void bl00mbox_channel_enable(uint8_t chan){ + if(chan >= (BL00MBOX_CHANNELS)) return; + bl00mbox_channel_t * ch = bl00mbox_get_channel(chan); ch->is_active = true; } -void bl00mbox_channel_disable(uint8_t chan) { - if (chan >= (BL00MBOX_CHANNELS)) return; - bl00mbox_channel_t* ch = bl00mbox_get_channel(chan); +void bl00mbox_channel_disable(uint8_t chan){ + if(chan >= (BL00MBOX_CHANNELS)) return; + bl00mbox_channel_t * ch = bl00mbox_get_channel(chan); ch->is_active = false; } -void bl00mbox_channel_set_volume(uint8_t chan, uint16_t volume) { - if (chan >= (BL00MBOX_CHANNELS)) return; - bl00mbox_channel_t* ch = bl00mbox_get_channel(chan); +void bl00mbox_channel_set_volume(uint8_t chan, uint16_t volume){ + if(chan >= (BL00MBOX_CHANNELS)) return; + bl00mbox_channel_t * ch = bl00mbox_get_channel(chan); ch->volume = volume < 32767 ? volume : 32767; } -int16_t bl00mbox_channel_get_volume(uint8_t chan) { - if (chan >= (BL00MBOX_CHANNELS)) return 0; - bl00mbox_channel_t* ch = bl00mbox_get_channel(chan); +int16_t bl00mbox_channel_get_volume(uint8_t chan){ + if(chan >= (BL00MBOX_CHANNELS)) return 0; + bl00mbox_channel_t * ch = bl00mbox_get_channel(chan); return ch->volume; } -void bl00mbox_audio_bud_render(bl00mbox_bud_t* bud, uint16_t num_samples) { - if (bud->render_pass_id == render_pass_id) return; +void bl00mbox_audio_bud_render(bl00mbox_bud_t * bud, uint16_t num_samples){ + if(bud->render_pass_id == render_pass_id) return; bud->plugin->render(bud->plugin, num_samples, render_pass_id); bud->render_pass_id = render_pass_id; } -static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan, - int16_t* out, uint16_t len, - bool adding) { - if (adding) { +static void bl00mbox_audio_channel_render(bl00mbox_channel_t * chan, int16_t * out, uint16_t len, bool adding){ + if(adding){ // ^ to make clang-tidy happy - if (render_pass_id == chan->render_pass_id) return; + // only to pass flow3r ci, omit before compliling + if(render_pass_id == chan->render_pass_id) return; } chan->render_pass_id = render_pass_id; - bl00mbox_channel_root_t* root = chan->root_list; + bl00mbox_channel_root_t * root = chan->root_list; // early exit when no sources: - if ((root == NULL) || (!chan->is_active)) { - if (adding) return; // nothing to do - memset(out, 0, len * sizeof(int16_t)); // mute + if((root == NULL) || (!chan->is_active)){ + if(adding) return; // nothing to do + memset(out, 0, len*sizeof(int16_t)); // mute return; } - if (root == NULL) return; // clang garbage, undo asap + if(root == NULL) return; // more clang garbage, undo before compliling int32_t acc[256]; bool first = true; - while (root != NULL) { + while(root != NULL){ bl00mbox_audio_bud_render(root->con->source_bud, len); - if (first) { - for (uint16_t i = 0; i < len; i++) { + if(first){ + for(uint16_t i = 0; i < len; i++){ acc[i] = root->con->buffer[i]; } } else { - for (uint16_t i = 0; i < len; - i++) { // replace this with proper ladspa-style adding - // function someday + for(uint16_t i = 0; i < len; i++){ // replace this with proper ladspa-style adding function someday acc[i] += root->con->buffer[i]; } } @@ -182,59 +177,56 @@ static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan, root = root->next; } - for (uint16_t i = 0; i < len; i++) { - if (adding) { - out[i] = - radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]); + for(uint16_t i = 0; i < len; i++){ + if(adding){ + out[i] = radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]); } else { out[i] = radspa_mult_shift(acc[i], chan->volume); } } } -void bl00mbox_audio_render(int16_t* rx, int16_t* tx, uint16_t len) { - if (!is_initialized) { - memset(tx, 0, len * sizeof(int16_t)); // mute +void bl00mbox_audio_render(int16_t * rx, int16_t * tx, uint16_t len){ + if(!is_initialized){ + memset(tx, 0, len*sizeof(int16_t)); // mute return; } bl00mbox_audio_do_pointer_change(); bl00mbox_channel_foreground = last_chan_event; - if (!bl00mbox_audio_run) { - memset(tx, 0, len * sizeof(int16_t)); // mute + if(!bl00mbox_audio_run){ + memset(tx, 0, len*sizeof(int16_t)); // mute return; } - render_pass_id++; // fresh pass, all relevant sources must be recomputed - uint16_t mono_len = len / 2; + render_pass_id++; // fresh pass, all relevant sources must be recomputed + uint16_t mono_len = len/2; int16_t acc[mono_len]; // system channel always runs non-adding bl00mbox_audio_channel_render(&(channels[0]), acc, mono_len, 0); - // re-rendering channels is ok, if render_pass_id didn't change it will just - // exit - bl00mbox_audio_channel_render(&(channels[bl00mbox_channel_foreground]), acc, - mono_len, 1); + // re-rendering channels is ok, if render_pass_id didn't change it will just exit + bl00mbox_audio_channel_render(&(channels[bl00mbox_channel_foreground]), acc, mono_len, 1); // TODO: scales poorly if there's many channels #ifdef BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE - for (uint8_t i = 1; i < (BL00MBOX_CHANNELS); i++) { - if (bl00mbox_channel_background_mute_override[i]) { + for(uint8_t i = 1; i < (BL00MBOX_CHANNELS); i++){ + if(bl00mbox_channel_background_mute_override[i]){ bl00mbox_audio_channel_render(&(channels[i]), acc, mono_len, 1); } } #endif - for (uint16_t i = 0; i < mono_len; i++) { - st3m_scope_write((acc[i]) >> 4); + for(uint16_t i = 0; i < mono_len; i++){ + st3m_scope_write((acc[i])>>4); - tx[2 * i] = acc[i]; - tx[2 * i + 1] = acc[i]; + tx[2*i] = acc[i]; + tx[2*i+1] = acc[i]; } } // TEMP -void bl00mbox_player_function(int16_t* rx, int16_t* tx, uint16_t len) { +void bl00mbox_player_function(int16_t * rx, int16_t * tx, uint16_t len){ bl00mbox_audio_render(rx, tx, len); } diff --git a/components/bl00mbox/bl00mbox_plugin_registry.c b/components/bl00mbox/bl00mbox_plugin_registry.c index f0e0734572c2664142c7def4283dcb806bef5b90..66d4dd4ce81aa766b5ea4598b871037432073c6d 100644 --- a/components/bl00mbox/bl00mbox_plugin_registry.c +++ b/components/bl00mbox/bl00mbox_plugin_registry.c @@ -1,64 +1,57 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #include "bl00mbox_plugin_registry.h" -bl00mbox_plugin_registry_t* bl00mbox_plugin_registry = NULL; +bl00mbox_plugin_registry_t * bl00mbox_plugin_registry = NULL; uint16_t bl00mbox_plugin_registry_len = 0; bool bl00mbox_plugin_registry_is_initialized = false; -static void plugin_add(radspa_descriptor_t* descriptor) { - if (bl00mbox_plugin_registry_len == 65535) { +static void plugin_add(radspa_descriptor_t * descriptor){ + if(bl00mbox_plugin_registry_len == 65535){ printf("too many plugins registered"); abort(); } // create plugin registry entry - bl00mbox_plugin_registry_t* p = malloc(sizeof(bl00mbox_plugin_registry_t)); - if (p == NULL) { - printf("bl00mbox: no memory for plugin list"); - abort(); - } + bl00mbox_plugin_registry_t * p = malloc(sizeof(bl00mbox_plugin_registry_t)); + if(p == NULL){ printf("bl00mbox: no memory for plugin list"); abort(); } p->descriptor = descriptor; p->next = NULL; // go to end of list - bl00mbox_plugin_registry_t* plast = bl00mbox_plugin_registry; - if (plast == NULL) { + bl00mbox_plugin_registry_t * plast = bl00mbox_plugin_registry; + if(plast == NULL){ bl00mbox_plugin_registry = p; } else { - while (plast->next != NULL) { - plast = plast->next; - } + while(plast->next != NULL){ plast = plast->next; } plast->next = p; } bl00mbox_plugin_registry_len++; } -uint16_t bl00mbox_plugin_registry_get_plugin_num(void) { +uint16_t bl00mbox_plugin_registry_get_plugin_num(void){ return bl00mbox_plugin_registry_len; } -radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_id( - uint32_t id) { +radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_id(uint32_t id){ /// searches plugin registry for first descriptor with given id number /// and returns pointer to it. returns NULL if no match is found. - bl00mbox_plugin_registry_t* p = bl00mbox_plugin_registry; - while (p != NULL) { - if (p->descriptor->id == id) break; + bl00mbox_plugin_registry_t * p = bl00mbox_plugin_registry; + while(p != NULL){ + if(p->descriptor->id == id) break; p = p->next; } - if (p != NULL) return p->descriptor; + if(p != NULL) return p->descriptor; return NULL; } -radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_index( - uint32_t index) { +radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_index(uint32_t index){ /// returns pointer to descriptor of registry entry at given index. /// returns NULL if out of range. - if (index >= bl00mbox_plugin_registry_len) return NULL; - bl00mbox_plugin_registry_t* p = bl00mbox_plugin_registry; - for (uint16_t i = 0; i < index; i++) { + if(index >= bl00mbox_plugin_registry_len) return NULL; + bl00mbox_plugin_registry_t * p = bl00mbox_plugin_registry; + for(uint16_t i = 0; i < index; i++){ p = p->next; - if (p == NULL) { + if(p == NULL){ printf("bl00mbox: plugin list length error"); abort(); } @@ -66,15 +59,14 @@ radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_index( return p->descriptor; } -radspa_descriptor_t* bl00mbox_plugin_registry_get_id_from_index( - uint32_t index) { +radspa_descriptor_t * bl00mbox_plugin_registry_get_id_from_index(uint32_t index){ /// returns pointer to descriptor of registry entry at given index. /// returns NULL if out of range. - if (index >= bl00mbox_plugin_registry_len) return NULL; - bl00mbox_plugin_registry_t* p = bl00mbox_plugin_registry; - for (uint16_t i = 0; i < index; i++) { + if(index >= bl00mbox_plugin_registry_len) return NULL; + bl00mbox_plugin_registry_t * p = bl00mbox_plugin_registry; + for(uint16_t i = 0; i < index; i++){ p = p->next; - if (p == NULL) { + if(p == NULL){ printf("bl00mbox: plugin list length error"); abort(); } @@ -95,21 +87,21 @@ radspa_descriptor_t* bl00mbox_plugin_registry_get_id_from_index( * removing plugins from the registry at runtime is not intended. */ +#include "trad_synth.h" #include "ampliverter.h" #include "delay.h" -#include "trad_synth.h" -// #include "filter.h" -// #include "sequence_timer.h" -#include "sampler.h" +//#include "filter.h" +//#include "sequence_timer.h" #include "sequencer.h" -void bl00mbox_plugin_registry_init(void) { - if (bl00mbox_plugin_registry_is_initialized) return; +#include "sampler.h" +void bl00mbox_plugin_registry_init(void){ + if(bl00mbox_plugin_registry_is_initialized) return; plugin_add(&trad_osc_desc); plugin_add(&liverter_desc); - plugin_add(&trad_env_desc); - plugin_add(&delay_desc); - // plugin_add(&filter_desc); - // plugin_add(&sequence_timer_desc); + plugin_add(&trad_env_desc); + plugin_add(&delay_desc); +// plugin_add(&filter_desc); +// plugin_add(&sequence_timer_desc); plugin_add(&sequencer_desc); plugin_add(&sampler_desc); } diff --git a/components/bl00mbox/bl00mbox_radspa_requirements.c b/components/bl00mbox/bl00mbox_radspa_requirements.c index 5a931e4949877e1ebcfe579f3f5cdfffd7d827c7..e24e9f6a650b2a4ff49be4980257e321e123c3fc 100644 --- a/components/bl00mbox/bl00mbox_radspa_requirements.c +++ b/components/bl00mbox/bl00mbox_radspa_requirements.c @@ -1,8 +1,8 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #include "bl00mbox_radspa_requirements.h" -bool radspa_host_request_buffer_render(int16_t *buf, uint16_t num_samples) { - bl00mbox_bud_t *bud = ((bl00mbox_connection_t *)buf)->source_bud; +bool radspa_host_request_buffer_render(int16_t * buf, uint16_t num_samples){ + bl00mbox_bud_t * bud = ((bl00mbox_connection_t *) buf)->source_bud; bl00mbox_audio_bud_render(bud, num_samples); return 1; } @@ -10,85 +10,86 @@ bool radspa_host_request_buffer_render(int16_t *buf, uint16_t num_samples) { // py: bigtable = [int(22/200*(2**(14-5+8+x*4096/2400/64))) for x in range(64)] // for 48kHz main sample rate static const uint16_t bigtable[64] = { - 14417, 14686, 14960, 15240, 15524, 15813, 16108, 16409, 16715, 17027, 17345, - 17668, 17998, 18334, 18676, 19024, 19379, 19741, 20109, 20484, 20866, 21255, - 21652, 22056, 22467, 22887, 23313, 23748, 24191, 24643, 25103, 25571, 26048, - 26534, 27029, 27533, 28047, 28570, 29103, 29646, 30199, 30763, 31336, 31921, - 32517, 33123, 33741, 34371, 35012, 35665, 36330, 37008, 37699, 38402, 39118, - 39848, 40592, 41349, 42120, 42906, 43706, 44522, 45352, 46199 + 14417, 14686, 14960, 15240, 15524, 15813, 16108, 16409, + 16715, 17027, 17345, 17668, 17998, 18334, 18676, 19024, + 19379, 19741, 20109, 20484, 20866, 21255, 21652, 22056, + 22467, 22887, 23313, 23748, 24191, 24643, 25103, 25571, + 26048, 26534, 27029, 27533, 28047, 28570, 29103, 29646, + 30199, 30763, 31336, 31921, 32517, 33123, 33741, 34371, + 35012, 35665, 36330, 37008, 37699, 38402, 39118, 39848, + 40592, 41349, 42120, 42906, 43706, 44522, 45352, 46199 }; -// py: smoltable = [int(22/240*(2**(15-5+9+x*4096/2400/64/64))) for x in -// range(64)] for 48kHz main sample rate +// py: smoltable = [int(22/240*(2**(15-5+9+x*4096/2400/64/64))) for x in range(64)] +// for 48kHz main sample rate static const uint16_t smoltable[64] = { - 48059, 48073, 48087, 48101, 48115, 48129, 48143, 48156, 48170, 48184, 48198, - 48212, 48226, 48240, 48254, 48268, 48282, 48296, 48310, 48324, 48338, 48352, - 48366, 48380, 48394, 48407, 48421, 48435, 48449, 48463, 48477, 48491, 48505, - 48519, 48533, 48548, 48562, 48576, 48590, 48604, 48618, 48632, 48646, 48660, - 48674, 48688, 48702, 48716, 48730, 48744, 48758, 48772, 48786, 48801, 48815, - 48829, 48843, 48857, 48871, 48885, 48899, 48913, 48928, 48942, + 48059, 48073, 48087, 48101, 48115, 48129, 48143, 48156, + 48170, 48184, 48198, 48212, 48226, 48240, 48254, 48268, + 48282, 48296, 48310, 48324, 48338, 48352, 48366, 48380, + 48394, 48407, 48421, 48435, 48449, 48463, 48477, 48491, + 48505, 48519, 48533, 48548, 48562, 48576, 48590, 48604, + 48618, 48632, 48646, 48660, 48674, 48688, 48702, 48716, + 48730, 48744, 48758, 48772, 48786, 48801, 48815, 48829, + 48843, 48857, 48871, 48885, 48899, 48913, 48928, 48942, }; -uint32_t radspa_sct_to_rel_freq(int16_t sct, int16_t undersample_pow) { - /// returns approx. proportional to 2**((sct/2400) + undersample_pow) so - /// that a uint32_t accumulator overflows at 440Hz with sct = INT16_MAX - - /// 6*2400 when sampled at (48>>undersample_pow)kHz +uint32_t radspa_sct_to_rel_freq(int16_t sct, int16_t undersample_pow){ + /// returns approx. proportional to 2**((sct/2400) + undersample_pow) so that + /// a uint32_t accumulator overflows at 440Hz with sct = INT16_MAX - 6*2400 + /// when sampled at (48>>undersample_pow)kHz // compiler explorer says this is 33 instructions with O2. might be alright? uint32_t a = sct; - a = sct + 28 * 2400 - 32767 - 330; - // at O2 u get free division for each modulo. still slow, 10 instructions or - // so. + a = sct + 28*2400 - 32767 - 330; + // at O2 u get free division for each modulo. still slow, 10 instructions or so. int16_t octa = a / 2400; a = a % 2400; uint8_t bigindex = a / 64; uint8_t smolindex = a % 64; - - uint32_t ret = 2; // weird but trust us + + uint32_t ret = 2; //weird but trust us ret *= bigtable[bigindex]; ret *= smoltable[smolindex]; int16_t shift = 27 - octa - undersample_pow; - if (shift > 0) { + if(shift > 0){ ret = ret >> shift; } return ret; } -int16_t radspa_clip(int32_t a) { - if (a > 32767) { - return 32767; - } else if (a < -32767) { - return -32767; +int16_t radspa_clip(int32_t a){ + if(a > 32767){ + return 32767; + } else if(a < -32767){ + return -32767; } return a; } -int16_t radspa_add_sat(int32_t a, int32_t b) { return radspa_clip(a + b); } -int16_t radspa_mult_shift(int32_t a, int32_t b) { - return radspa_clip((a * b) >> 15); -} +int16_t radspa_add_sat(int32_t a, int32_t b){ return radspa_clip(a+b); } +int16_t radspa_mult_shift(int32_t a, int32_t b){ return radspa_clip((a*b)>>15); } -int16_t radspa_trigger_start(int16_t velocity, int16_t *hist) { - int16_t ret = ((*hist) > 0) ? -velocity : velocity; - (*hist) = ret; +int16_t radspa_trigger_start(int16_t velocity, int16_t * hist){ + int16_t ret = ((* hist) > 0) ? -velocity : velocity; + (* hist) = ret; return ret; } -int16_t radspa_trigger_stop(int16_t *hist) { - (*hist) = 0; +int16_t radspa_trigger_stop(int16_t * hist){ + (* hist) = 0; return 0; } -int16_t radspa_trigger_get(int16_t trigger_signal, int16_t *hist) { +int16_t radspa_trigger_get(int16_t trigger_signal, int16_t * hist){ int16_t ret = 0; - if ((!trigger_signal) && (*hist)) { // stop + if((!trigger_signal) && (* hist)){ //stop ret = -1; - } else if (trigger_signal > 0) { - if ((*hist) <= 0) ret = trigger_signal; - } else if (trigger_signal < 0) { - if ((*hist) >= 0) ret = -trigger_signal; + } else if(trigger_signal > 0 ){ + if((* hist) <= 0) ret = trigger_signal; + } else if(trigger_signal < 0 ){ + if((* hist) >= 0) ret = -trigger_signal; } - (*hist) = trigger_signal; + (* hist) = trigger_signal; return ret; } diff --git a/components/bl00mbox/bl00mbox_user.c b/components/bl00mbox/bl00mbox_user.c index 2e7afb9d894cec2be3ee491f3136c2fbb3c537e0..cf237406d04d35429ac92844c9daedd5f82055d4 100644 --- a/components/bl00mbox/bl00mbox_user.c +++ b/components/bl00mbox/bl00mbox_user.c @@ -1,224 +1,206 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #include "bl00mbox_user.h" static uint64_t bl00mbox_bud_index = 1; -bl00mbox_bud_t *bl00mbox_channel_get_bud_by_index(uint8_t channel, - uint32_t index); +bl00mbox_bud_t * bl00mbox_channel_get_bud_by_index(uint8_t channel, uint32_t index); -uint16_t bl00mbox_channel_buds_num(uint8_t channel) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +uint16_t bl00mbox_channel_buds_num(uint8_t channel){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); uint16_t ret = 0; - if (chan->buds != NULL) { - bl00mbox_bud_t *last = chan->buds; + if(chan->buds != NULL){ + bl00mbox_bud_t * last = chan->buds; ret++; - while (last->chan_next != NULL) { + while(last->chan_next != NULL){ last = last->chan_next; ret++; - } + } } return ret; } -uint64_t bl00mbox_channel_get_bud_by_list_pos(uint8_t channel, uint32_t pos) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +uint64_t bl00mbox_channel_get_bud_by_list_pos(uint8_t channel, uint32_t pos){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); uint16_t ret = 0; - if (chan->buds != NULL) { - bl00mbox_bud_t *last = chan->buds; - if (pos == ret) return last->index; + if(chan->buds != NULL){ + bl00mbox_bud_t * last = chan->buds; + if(pos == ret) return last->index; ret++; - while (last->chan_next != NULL) { + while(last->chan_next != NULL){ last = last->chan_next; - if (pos == ret) return last->index; + if(pos == ret) return last->index; ret++; - } + } } return 0; } -uint16_t bl00mbox_channel_conns_num(uint8_t channel) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +uint16_t bl00mbox_channel_conns_num(uint8_t channel){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); uint16_t ret = 0; - if (chan->connections != NULL) { - bl00mbox_connection_t *last = chan->connections; + if(chan->connections != NULL){ + bl00mbox_connection_t * last = chan->connections; ret++; - while (last->chan_next != NULL) { + while(last->chan_next != NULL){ last = last->chan_next; ret++; - } + } } return ret; } -uint16_t bl00mbox_channel_mixer_num(uint8_t channel) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +uint16_t bl00mbox_channel_mixer_num(uint8_t channel){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); uint16_t ret = 0; - if (chan->root_list != NULL) { - bl00mbox_channel_root_t *last = chan->root_list; + if(chan->root_list != NULL){ + bl00mbox_channel_root_t * last = chan->root_list; ret++; - while (last->next != NULL) { + while(last->next != NULL){ last = last->next; ret++; - } + } } return ret; } -uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel, - uint32_t pos) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel, uint32_t pos){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); uint16_t ret = 0; - if (chan->buds != NULL) { - bl00mbox_channel_root_t *last = chan->root_list; - if (pos == ret) return last->con->source_bud->index; + if(chan->buds != NULL){ + bl00mbox_channel_root_t * last = chan->root_list; + if(pos == ret) return last->con->source_bud->index; ret++; - while (last->next != NULL) { + while(last->next != NULL){ last = last->next; - if (pos == ret) return last->con->source_bud->index; + if(pos == ret) return last->con->source_bud->index; ret++; - } + } } return 0; } -uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel, - uint32_t pos) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel, uint32_t pos){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); uint16_t ret = 0; - if (chan->buds != NULL) { - bl00mbox_channel_root_t *last = chan->root_list; - if (pos == ret) return last->con->signal_index; + if(chan->buds != NULL){ + bl00mbox_channel_root_t * last = chan->root_list; + if(pos == ret) return last->con->signal_index; ret++; - while (last->next != NULL) { + while(last->next != NULL){ last = last->next; - if (pos == ret) return last->con->signal_index; + if(pos == ret) return last->con->signal_index; ret++; - } + } } return 0; } -uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index, - uint16_t signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return 0; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return 0; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, signal_index); - if (sig == NULL) return 0; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)sig->buffer; // buffer sits on top of struct - if (conn == NULL) return 0; +uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index, uint16_t signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return 0; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return 0; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index); + if(sig == NULL) return 0; + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct + if(conn == NULL) return 0; uint16_t ret = 0; - if (conn->subs != NULL) { - bl00mbox_connection_subscriber_t *last = conn->subs; + if(conn->subs != NULL){ + bl00mbox_connection_subscriber_t * last = conn->subs; ret++; - while (last->next != NULL) { + while(last->next != NULL){ last = last->next; ret++; - } + } } return ret; } -uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel, - uint64_t bud_index, - uint16_t signal_index, - uint8_t pos) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return 0; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return 0; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, signal_index); - if (sig == NULL) return 0; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)sig->buffer; // buffer sits on top of struct - if (conn == NULL) return 0; +uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index, + uint16_t signal_index, uint8_t pos){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return 0; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return 0; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index); + if(sig == NULL) return 0; + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct + if(conn == NULL) return 0; uint16_t ret = 0; - if (conn->subs != NULL) { - bl00mbox_connection_subscriber_t *last = conn->subs; - if (pos == ret) return (last->type == 0) ? last->bud_index : 0; + if(conn->subs != NULL){ + bl00mbox_connection_subscriber_t * last = conn->subs; + if(pos == ret) return (last->type == 0) ? last->bud_index : 0; ret++; - while (last->next != NULL) { + while(last->next != NULL){ last = last->next; - if (pos == ret) return (last->type == 0) ? last->bud_index : 0; + if(pos == ret) return (last->type == 0) ? last->bud_index : 0; ret++; - } + } } return 0; } -int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos( - uint8_t channel, uint64_t bud_index, uint16_t signal_index, uint8_t pos) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return 0; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return 0; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, signal_index); - if (sig == NULL) return 0; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)sig->buffer; // buffer sits on top of struct - if (conn == NULL) return 0; +int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index, + uint16_t signal_index, uint8_t pos){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return 0; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return 0; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index); + if(sig == NULL) return 0; + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct + if(conn == NULL) return 0; uint16_t ret = 0; - if (conn->subs != NULL) { - bl00mbox_connection_subscriber_t *last = conn->subs; - if (pos == ret) return (last->type == 0) ? last->signal_index : -1; + if(conn->subs != NULL){ + bl00mbox_connection_subscriber_t * last = conn->subs; + if(pos == ret) return (last->type == 0) ? last->signal_index : -1; ret++; - while (last->next != NULL) { + while(last->next != NULL){ last = last->next; - if (pos == ret) return (last->type == 0) ? last->signal_index : -1; + if(pos == ret) return (last->type == 0) ? last->signal_index : -1; ret++; - } + } } return 0; } -uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index, - uint16_t signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return 0; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return 0; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, signal_index); - if (sig == NULL) return 0; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)sig->buffer; // buffer sits on top of struct - if (conn == NULL) return 0; +uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index, uint16_t signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return 0; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return 0; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index); + if(sig == NULL) return 0; + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct + if(conn == NULL) return 0; return conn->source_bud->index; } -uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index, - uint16_t signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return 0; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return 0; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, signal_index); - if (sig == NULL) return 0; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)sig->buffer; // buffer sits on top of struct - if (conn == NULL) return 0; +uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index, uint16_t signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return 0; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return 0; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index); + if(sig == NULL) return 0; + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct + if(conn == NULL) return 0; return conn->signal_index; } -static bl00mbox_connection_t *create_connection(uint8_t channel) { - bl00mbox_connection_t *ret = malloc(sizeof(bl00mbox_connection_t)); - if (ret == NULL) return NULL; - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); +static bl00mbox_connection_t * create_connection(uint8_t channel){ + bl00mbox_connection_t * ret = malloc(sizeof(bl00mbox_connection_t)); + if(ret == NULL) return NULL; + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); ret->chan_next = NULL; ret->subs = NULL; ret->channel = channel; - if (chan->connections != NULL) { - bl00mbox_connection_t *last = chan->connections; - while (last->chan_next != NULL) { + if(chan->connections != NULL){ + bl00mbox_connection_t * last = chan->connections; + while(last->chan_next != NULL){ last = last->chan_next; } last->chan_next = ret; @@ -228,36 +210,32 @@ static bl00mbox_connection_t *create_connection(uint8_t channel) { return ret; } -static bool weak_delete_connection(bl00mbox_connection_t *conn) { - if (conn->subs != NULL) return false; +static bool weak_delete_connection(bl00mbox_connection_t * conn){ + if(conn->subs != NULL) return false; // nullify source bud connection; - bl00mbox_bud_t *bud = conn->source_bud; - if (bud != NULL) { - radspa_signal_t *tx = - radspa_signal_get_by_index(bud->plugin, conn->signal_index); - if (tx != NULL) { + bl00mbox_bud_t * bud = conn->source_bud; + if(bud != NULL){ + radspa_signal_t * tx = radspa_signal_get_by_index(bud->plugin, conn->signal_index); + if(tx != NULL){ bl00mbox_audio_waitfor_pointer_change(&(tx->buffer), NULL); } } // pop from channel list - bl00mbox_channel_t *chan = bl00mbox_get_channel(conn->channel); - if (chan->connections != NULL) { - if (chan->connections != conn) { - bl00mbox_connection_t *prev = chan->connections; - while (prev->chan_next != conn) { + bl00mbox_channel_t * chan = bl00mbox_get_channel(conn->channel); + if(chan->connections != NULL){ + if(chan->connections != conn){ + bl00mbox_connection_t * prev = chan->connections; + while(prev->chan_next != conn){ prev = prev->chan_next; - if (prev->chan_next == NULL) { + if(prev->chan_next == NULL){ break; } } - if (prev->chan_next != NULL) - bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next), - conn->chan_next); + if(prev->chan_next != NULL) bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next), conn->chan_next); } else { - bl00mbox_audio_waitfor_pointer_change(&(chan->connections), - conn->chan_next); + bl00mbox_audio_waitfor_pointer_change(&(chan->connections), conn->chan_next); } } @@ -265,138 +243,120 @@ static bool weak_delete_connection(bl00mbox_connection_t *conn) { return true; } -bl00mbox_bud_t *bl00mbox_channel_get_bud_by_index(uint8_t channel, - uint32_t index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return NULL; - if (chan->buds == NULL) return NULL; - bl00mbox_bud_t *bud = chan->buds; - while (true) { - if (bud->index == index) break; +bl00mbox_bud_t * bl00mbox_channel_get_bud_by_index(uint8_t channel, uint32_t index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return NULL; + if(chan->buds == NULL) return NULL; + bl00mbox_bud_t * bud = chan->buds; + while(true){ + if(bud->index == index) break; bud = bud->chan_next; - if (bud == NULL) break; + if(bud == NULL) break; } return bud; } -bl00mbox_bud_t *bl00mbox_channel_new_bud(uint8_t channel, uint32_t id, - uint32_t init_var) { - /// creates a new bud instance of the plugin with descriptor id "id" and the - /// initialization variable "init_var" and appends it to the plugin list of - /// the corresponding channel. returns pointer to the bud if successfull, - /// else NULL. - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return NULL; - radspa_descriptor_t *desc = - bl00mbox_plugin_registry_get_descriptor_from_id(id); - if (desc == NULL) return NULL; - bl00mbox_bud_t *bud = malloc(sizeof(bl00mbox_bud_t)); - if (bud == NULL) return NULL; - radspa_t *plugin = desc->create_plugin_instance(init_var); - if (plugin == NULL) { - free(bud); - return NULL; - } +bl00mbox_bud_t * bl00mbox_channel_new_bud(uint8_t channel, uint32_t id, uint32_t init_var){ + /// creates a new bud instance of the plugin with descriptor id "id" and the initialization variable + /// "init_var" and appends it to the plugin list of the corresponding channel. returns pointer to + /// the bud if successfull, else NULL. + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return NULL; + radspa_descriptor_t * desc = bl00mbox_plugin_registry_get_descriptor_from_id(id); + if(desc == NULL) return NULL; + bl00mbox_bud_t * bud = malloc(sizeof(bl00mbox_bud_t)); + if(bud == NULL) return NULL; + radspa_t * plugin = desc->create_plugin_instance(init_var); + if(plugin == NULL){ free(bud); return NULL; } bud->plugin = plugin; bud->channel = channel; - // TODO: look for empty indices + //TODO: look for empty indices bud->index = bl00mbox_bud_index; bl00mbox_bud_index++; bud->chan_next = NULL; // append to channel bud list - if (chan->buds == NULL) { + if(chan->buds == NULL){ chan->buds = bud; } else { - bl00mbox_bud_t *last = chan->buds; - while (last->chan_next != NULL) { - last = last->chan_next; - } + bl00mbox_bud_t * last = chan->buds; + while(last->chan_next != NULL){ last = last->chan_next; } last->chan_next = bud; } bl00mbox_channel_event(channel); return bud; } -bool bl00mbox_channel_delete_bud(uint8_t channel, uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; +bool bl00mbox_channel_delete_bud(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; // disconnect all signals - uint16_t num_signals = - bl00mbox_channel_bud_get_num_signals(channel, bud_index); - for (uint16_t i = 0; i < num_signals; i++) { + uint16_t num_signals = bl00mbox_channel_bud_get_num_signals(channel, bud_index); + for(uint16_t i = 0; i < num_signals; i++){ bl00mbox_channel_disconnect_signal(channel, bud_index, i); } // pop from channel bud list - bl00mbox_bud_t *seek = chan->buds; + bl00mbox_bud_t * seek = chan->buds; bool free_later = false; - if (chan->buds != NULL) { - bl00mbox_bud_t *prev = NULL; - while (seek != NULL) { - if (seek->index == bud_index) { + if(chan->buds != NULL){ + bl00mbox_bud_t * prev = NULL; + while(seek != NULL){ + if(seek->index == bud_index){ break; } prev = seek; seek = seek->chan_next; } - if (seek != NULL) { - if (prev != NULL) { - bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next), - seek->chan_next); + if(seek != NULL){ + if(prev != NULL){ + bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next), seek->chan_next); } else { - bl00mbox_audio_waitfor_pointer_change(&(chan->buds), - seek->chan_next); + bl00mbox_audio_waitfor_pointer_change(&(chan->buds), seek->chan_next); } free_later = true; } } bud->plugin->descriptor->destroy_plugin_instance(bud->plugin); - if (free_later) free(seek); + if(free_later) free(seek); return true; } -bool bl00mbox_channel_clear(uint8_t channel) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = chan->buds; - while (bud != NULL) { - bl00mbox_bud_t *bud_next = bud->chan_next; +bool bl00mbox_channel_clear(uint8_t channel){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = chan->buds; + while(bud != NULL){ + bl00mbox_bud_t * bud_next = bud->chan_next; bl00mbox_channel_delete_bud(channel, bud->index); bud = bud_next; } return true; } -bool bl00mbox_channel_connect_signal_to_output_mixer( - uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *tx = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (tx == NULL) return false; - if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; - - bl00mbox_channel_root_t *root = malloc(sizeof(bl00mbox_channel_root_t)); - if (root == NULL) return false; - bl00mbox_connection_subscriber_t *sub = - malloc(sizeof(bl00mbox_connection_subscriber_t)); - if (sub == NULL) { - free(root); - return false; - } +bool bl00mbox_channel_connect_signal_to_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * tx = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(tx == NULL) return false; + if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; + + bl00mbox_channel_root_t * root = malloc(sizeof(bl00mbox_channel_root_t)); + if(root == NULL) return false; + bl00mbox_connection_subscriber_t * sub = malloc(sizeof(bl00mbox_connection_subscriber_t)); + if(sub == NULL){ free(root); return false; } - bl00mbox_connection_t *conn; - if (tx->buffer == NULL) { // doesn't feed a buffer yet + bl00mbox_connection_t * conn; + if(tx->buffer == NULL){ // doesn't feed a buffer yet conn = create_connection(channel); - if (conn == NULL) { + if(conn == NULL){ free(sub); free(root); return false; @@ -406,12 +366,11 @@ bool bl00mbox_channel_connect_signal_to_output_mixer( conn->source_bud = bud; tx->buffer = conn->buffer; } else { - conn = (bl00mbox_connection_t *) - tx->buffer; // buffer sits on top of struct - if (conn->subs != NULL) { - bl00mbox_connection_subscriber_t *seek = conn->subs; - while (seek != NULL) { - if (seek->type == 1) { + conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct + if(conn->subs != NULL){ + bl00mbox_connection_subscriber_t * seek = conn->subs; + while(seek != NULL){ + if(seek->type == 1){ free(root); free(sub); return false; // already connected @@ -425,26 +384,22 @@ bool bl00mbox_channel_connect_signal_to_output_mixer( sub->bud_index = bud_index; sub->signal_index = bud_signal_index; sub->next = NULL; - if (conn->subs == NULL) { + if(conn->subs == NULL){ conn->subs = sub; } else { - bl00mbox_connection_subscriber_t *seek = conn->subs; - while (seek->next != NULL) { - seek = seek->next; - } + bl00mbox_connection_subscriber_t * seek = conn->subs; + while(seek->next != NULL){ seek = seek->next; } seek->next = sub; } root->con = conn; root->next = NULL; - if (chan->root_list == NULL) { + if(chan->root_list == NULL){ chan->root_list = root; } else { - bl00mbox_channel_root_t *last_root = chan->root_list; - while (last_root->next != NULL) { - last_root = last_root->next; - } + bl00mbox_channel_root_t * last_root = chan->root_list; + while(last_root->next != NULL){ last_root = last_root->next; } last_root->next = root; } @@ -452,33 +407,30 @@ bool bl00mbox_channel_connect_signal_to_output_mixer( return true; } -bool bl00mbox_channel_disconnect_signal_from_output_mixer( - uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index) { - // TODO - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *tx = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (tx == NULL) return false; - if (tx->buffer == NULL) return false; - if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; - - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)tx->buffer; // buffer sits on top of struct - if (conn == NULL) return false; // not connected - - bl00mbox_channel_root_t *rt = chan->root_list; - bl00mbox_channel_root_t *rt_prev = NULL; - - while (rt != NULL) { - if (rt->con == conn) break; +bool bl00mbox_channel_disconnect_signal_from_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + //TODO + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * tx = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(tx == NULL) return false; + if(tx->buffer == NULL) return false; + if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; + + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct + if(conn == NULL) return false; //not connected + + bl00mbox_channel_root_t * rt = chan->root_list; + bl00mbox_channel_root_t * rt_prev = NULL; + + while(rt != NULL){ + if(rt->con == conn) break; rt_prev = rt; rt = rt->next; } - if (rt != NULL) { - if (rt_prev == NULL) { + if(rt != NULL){ + if(rt_prev == NULL){ bl00mbox_audio_waitfor_pointer_change(&(chan->root_list), rt->next); } else { bl00mbox_audio_waitfor_pointer_change(&(rt_prev->next), rt->next); @@ -486,23 +438,21 @@ bool bl00mbox_channel_disconnect_signal_from_output_mixer( free(rt); } - if (conn->subs != NULL) { - bl00mbox_connection_subscriber_t *seek = conn->subs; - bl00mbox_connection_subscriber_t *prev = NULL; - while (seek != NULL) { - if (seek->type == 1) { + if(conn->subs != NULL){ + bl00mbox_connection_subscriber_t * seek = conn->subs; + bl00mbox_connection_subscriber_t * prev = NULL; + while(seek != NULL){ + if(seek->type == 1){ break; } prev = seek; seek = seek->next; } - if (seek != NULL) { - if (prev != NULL) { - bl00mbox_audio_waitfor_pointer_change(&(prev->next), - seek->next); + if(seek != NULL){ + if(prev != NULL){ + bl00mbox_audio_waitfor_pointer_change(&(prev->next), seek->next); } else { - bl00mbox_audio_waitfor_pointer_change(&(conn->subs), - seek->next); + bl00mbox_audio_waitfor_pointer_change(&(conn->subs), seek->next); } free(seek); } @@ -513,49 +463,42 @@ bool bl00mbox_channel_disconnect_signal_from_output_mixer( return true; } -bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, - uint32_t bud_rx_index, - uint32_t bud_rx_signal_index) { - bl00mbox_bud_t *bud_rx = - bl00mbox_channel_get_bud_by_index(channel, bud_rx_index); - if (bud_rx == NULL) return false; // bud index doesn't exist +bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index){ + bl00mbox_bud_t * bud_rx = bl00mbox_channel_get_bud_by_index(channel, bud_rx_index); + if(bud_rx == NULL) return false; // bud index doesn't exist - radspa_signal_t *rx = - radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index); - if (rx == NULL) return false; // signal index doesn't exist - if (rx->buffer == NULL) return false; - if (!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false; + radspa_signal_t * rx = radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index); + if(rx == NULL) return false; // signal index doesn't exist + if(rx->buffer == NULL) return false; + if(!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)rx->buffer; // buffer sits on top of struct - if (conn == NULL) return false; // not connected + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) rx->buffer; // buffer sits on top of struct + if(conn == NULL) return false; //not connected - bl00mbox_bud_t *bud_tx = conn->source_bud; - if (bud_tx == NULL) return false; // bud index doesn't exist - radspa_signal_t *tx = - radspa_signal_get_by_index(bud_tx->plugin, conn->signal_index); - if (tx == NULL) return false; // signal index doesn't exist + bl00mbox_bud_t * bud_tx = conn->source_bud; + if(bud_tx == NULL) return false; // bud index doesn't exist + radspa_signal_t * tx = radspa_signal_get_by_index(bud_tx->plugin, conn->signal_index); + if(tx == NULL) return false; // signal index doesn't exist bl00mbox_audio_waitfor_pointer_change(&(rx->buffer), NULL); - if (conn->subs != NULL) { - bl00mbox_connection_subscriber_t *seek = conn->subs; - bl00mbox_connection_subscriber_t *prev = NULL; - while (seek != NULL) { - if ((seek->signal_index == bud_rx_signal_index) && - (seek->bud_index == bud_rx_index) && (seek->type == 0)) { + if(conn->subs != NULL){ + bl00mbox_connection_subscriber_t * seek = conn->subs; + bl00mbox_connection_subscriber_t * prev = NULL; + while(seek != NULL){ + if( (seek->signal_index == bud_rx_signal_index) && + (seek->bud_index == bud_rx_index) && + (seek->type == 0)){ break; } prev = seek; seek = seek->next; } - if (seek != NULL) { - if (prev != NULL) { - bl00mbox_audio_waitfor_pointer_change(&(prev->next), - seek->next); + if(seek != NULL){ + if(prev != NULL){ + bl00mbox_audio_waitfor_pointer_change(&(prev->next), seek->next); } else { - bl00mbox_audio_waitfor_pointer_change(&(conn->subs), - seek->next); + bl00mbox_audio_waitfor_pointer_change(&(conn->subs), seek->next); } free(seek); } @@ -566,32 +509,25 @@ bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, return true; } -bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, - uint32_t bud_tx_index, - uint32_t bud_tx_signal_index) { - bl00mbox_bud_t *bud_tx = - bl00mbox_channel_get_bud_by_index(channel, bud_tx_index); - if (bud_tx == NULL) return false; // bud index doesn't exist +bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, uint32_t bud_tx_index, uint32_t bud_tx_signal_index){ + bl00mbox_bud_t * bud_tx = bl00mbox_channel_get_bud_by_index(channel, bud_tx_index); + if(bud_tx == NULL) return false; // bud index doesn't exist - radspa_signal_t *tx = - radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index); - if (tx == NULL) return false; // signal index doesn't exist - if (tx->buffer == NULL) return false; - if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; + radspa_signal_t * tx = radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index); + if(tx == NULL) return false; // signal index doesn't exist + if(tx->buffer == NULL) return false; + if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; - bl00mbox_connection_t *conn = - (bl00mbox_connection_t *)tx->buffer; // buffer sits on top of struct - if (conn == NULL) return false; // not connected + bl00mbox_connection_t * conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct + if(conn == NULL) return false; //not connected - while (conn->subs != NULL) { - switch (conn->subs->type) { + while(conn->subs != NULL){ + switch(conn->subs->type){ case 0: - bl00mbox_channel_disconnect_signal_rx( - channel, conn->subs->bud_index, conn->subs->signal_index); + bl00mbox_channel_disconnect_signal_rx(channel, conn->subs->bud_index, conn->subs->signal_index); break; case 1: - bl00mbox_channel_disconnect_signal_from_output_mixer( - channel, conn->subs->bud_index, conn->subs->signal_index); + bl00mbox_channel_disconnect_signal_from_output_mixer(channel, conn->subs->bud_index, conn->subs->signal_index); break; } } @@ -599,62 +535,50 @@ bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, return true; } -bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_index, - uint32_t signal_index) { - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; // bud index doesn't exist - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, signal_index); - if (sig == NULL) return false; // signal index doesn't exist - if (sig->buffer == NULL) return false; +bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_index, uint32_t signal_index){ + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; // bud index doesn't exist + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index); + if(sig == NULL) return false; // signal index doesn't exist + if(sig->buffer == NULL) return false; bl00mbox_channel_disconnect_signal_rx(channel, bud_index, signal_index); bl00mbox_channel_disconnect_signal_tx(channel, bud_index, signal_index); - bl00mbox_channel_disconnect_signal_from_output_mixer(channel, bud_index, - signal_index); - if (sig->buffer == NULL) return true; + bl00mbox_channel_disconnect_signal_from_output_mixer(channel, bud_index, signal_index); + if(sig->buffer == NULL) return true; return false; } -bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, - uint32_t bud_rx_signal_index, - uint32_t bud_tx_index, - uint32_t bud_tx_signal_index) { - bl00mbox_bud_t *bud_rx = - bl00mbox_channel_get_bud_by_index(channel, bud_rx_index); - bl00mbox_bud_t *bud_tx = - bl00mbox_channel_get_bud_by_index(channel, bud_tx_index); - if (bud_tx == NULL || bud_rx == NULL) - return false; // bud index doesn't exist - - radspa_signal_t *rx = - radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index); - radspa_signal_t *tx = - radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index); - if (tx == NULL || rx == NULL) return false; // signal index doesn't exist - if (!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false; - if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; - - bl00mbox_connection_t *conn; - bl00mbox_connection_subscriber_t *sub; - if (tx->buffer == NULL) { // doesn't feed a buffer yet +bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index, + uint32_t bud_tx_index, uint32_t bud_tx_signal_index){ + bl00mbox_bud_t * bud_rx = bl00mbox_channel_get_bud_by_index(channel, bud_rx_index); + bl00mbox_bud_t * bud_tx = bl00mbox_channel_get_bud_by_index(channel, bud_tx_index); + if(bud_tx == NULL || bud_rx == NULL) return false; // bud index doesn't exist + + radspa_signal_t * rx = radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index); + radspa_signal_t * tx = radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index); + if(tx == NULL || rx == NULL) return false; // signal index doesn't exist + if(!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false; + if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false; + + bl00mbox_connection_t * conn; + bl00mbox_connection_subscriber_t * sub; + if(tx->buffer == NULL){ // doesn't feed a buffer yet conn = create_connection(channel); - if (conn == NULL) return false; // no ram for connection + if(conn == NULL) return false; // no ram for connection // set up new connection conn->signal_index = bud_tx_signal_index; conn->source_bud = bud_tx; tx->buffer = conn->buffer; } else { - if (rx->buffer == tx->buffer) return false; // already connected - conn = (bl00mbox_connection_t *) - tx->buffer; // buffer sits on top of struct + if(rx->buffer == tx->buffer) return false; // already connected + conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct } - bl00mbox_channel_disconnect_signal_rx(channel, bud_rx_index, - bud_rx_signal_index); + bl00mbox_channel_disconnect_signal_rx(channel, bud_rx_index, bud_rx_signal_index); sub = malloc(sizeof(bl00mbox_connection_subscriber_t)); - if (sub == NULL) { + if(sub == NULL){ weak_delete_connection(conn); return false; } @@ -662,11 +586,11 @@ bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, sub->bud_index = bud_rx_index; sub->signal_index = bud_rx_signal_index; sub->next = NULL; - if (conn->subs == NULL) { + if(conn->subs == NULL){ conn->subs = sub; } else { - bl00mbox_connection_subscriber_t *seek = conn->subs; - while (seek->next != NULL) { + bl00mbox_connection_subscriber_t * seek = conn->subs; + while(seek->next != NULL){ seek = seek->next; } seek->next = sub; @@ -677,163 +601,140 @@ bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, return true; } -bool bl00mbox_channel_bud_exists(uint8_t channel, uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) { +bool bl00mbox_channel_bud_exists(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL){ return false; } else { return true; } } -char *bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; +char * bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; return bud->plugin->descriptor->name; } -char *bl00mbox_channel_bud_get_description(uint8_t channel, - uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; +char * bl00mbox_channel_bud_get_description(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; return bud->plugin->descriptor->description; } -uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel, - uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; +uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; return bud->plugin->descriptor->id; } -uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel, - uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; +uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; return bud->plugin->len_signals; } -char *bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index, - uint32_t bud_signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (sig == NULL) return false; +char * bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(sig == NULL) return false; return sig->name; } -char *bl00mbox_channel_bud_get_signal_description(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (sig == NULL) return false; +char * bl00mbox_channel_bud_get_signal_description(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(sig == NULL) return false; return sig->description; } -char *bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index, - uint32_t bud_signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (sig == NULL) return false; +char * bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(sig == NULL) return false; return sig->unit; } -bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index, - uint32_t bud_signal_index, - int16_t value) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (sig == NULL) return false; +bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index, int16_t value){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(sig == NULL) return false; sig->value = value; bl00mbox_channel_event(channel); return true; } -int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (sig == NULL) return false; +int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(sig == NULL) return false; return sig->value; } -uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - radspa_signal_t *sig = - radspa_signal_get_by_index(bud->plugin, bud_signal_index); - if (sig == NULL) return false; +uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index); + if(sig == NULL) return false; return sig->hints; } -bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index, - uint32_t table_index, int16_t value) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - if (bud->plugin->plugin_table == NULL) return false; - if (table_index >= bud->plugin->plugin_table_len) return false; +bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index, int16_t value){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + if(bud->plugin->plugin_table == NULL) return false; + if(table_index >= bud->plugin->plugin_table_len) return false; bud->plugin->plugin_table[table_index] = value; bl00mbox_channel_event(channel); return true; } -int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel, - uint32_t bud_index, - uint32_t table_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; - if (bud->plugin->plugin_table == NULL) return false; - if (table_index >= bud->plugin->plugin_table_len) return false; +int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; + if(bud->plugin->plugin_table == NULL) return false; + if(table_index >= bud->plugin->plugin_table_len) return false; return bud->plugin->plugin_table[table_index]; } -int16_t bl00mbox_channel_bud_get_table_len(uint8_t channel, - uint32_t bud_index) { - bl00mbox_channel_t *chan = bl00mbox_get_channel(channel); - if (chan == NULL) return false; - bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); - if (bud == NULL) return false; +int16_t bl00mbox_channel_bud_get_table_len(uint8_t channel, uint32_t bud_index){ + bl00mbox_channel_t * chan = bl00mbox_get_channel(channel); + if(chan == NULL) return false; + bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index); + if(bud == NULL) return false; return bud->plugin->plugin_table_len; } diff --git a/components/bl00mbox/include/bl00mbox.h b/components/bl00mbox/include/bl00mbox.h index f73bf7c3d1498acd9edbe3438476fc137ab3a09e..9dd3f1c1ae442ad30f5ca9798f3c51d41b3d681e 100644 --- a/components/bl00mbox/include/bl00mbox.h +++ b/components/bl00mbox/include/bl00mbox.h @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #pragma once #include <stdbool.h> #include <stdint.h> @@ -8,9 +8,9 @@ uint16_t bl00mbox_sources_count(); uint16_t bl00mbox_source_add(void* render_data, void* render_function); void bl00mbox_source_remove(uint16_t index); -void bl00mbox_audio_render(int16_t* rx, int16_t* tx, uint16_t len); +void bl00mbox_audio_render(int16_t * rx, int16_t * tx, uint16_t len); // TEMP -void bl00mbox_player_function(int16_t* rx, int16_t* tx, uint16_t len); +void bl00mbox_player_function(int16_t * rx, int16_t * tx, uint16_t len); void bl00mbox_init(void); diff --git a/components/bl00mbox/include/bl00mbox_audio.h b/components/bl00mbox/include/bl00mbox_audio.h index 4fc5fbeadff5335d1b2e0746636eec38d8e8ea5a..2ac014280b01a1c41c9ff08656f41f3e0cce6eb1 100644 --- a/components/bl00mbox/include/bl00mbox_audio.h +++ b/components/bl00mbox/include/bl00mbox_audio.h @@ -1,18 +1,18 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #pragma once -// TODO: move this to kconfig someday +//TODO: move this to kconfig someday #define BL00MBOX_MAX_BUFFER_LEN 256 #define BL00MBOX_DEFAULT_CHANNEL_VOLUME 3000 #define BL00MBOX_CHANNELS 32 #define BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE -// TODO: remove st3m scope dependency +//TODO: remove st3m scope dependency #include "st3m_audio.h" #include "st3m_scope.h" -#include <math.h> #include <stdio.h> +#include <math.h> #include <string.h> #include "radspa.h" @@ -21,53 +21,47 @@ struct _bl00mbox_connection_source_t; struct _bl00mbox_channel_root_t; struct _bl00mbox_channel_t; -typedef struct _bl00mbox_bud_t { - radspa_t* plugin; // plugin - uint64_t index; // unique index number for bud - uint32_t render_pass_id; // may be used by host to determine whether - // recomputation is necessary - uint8_t channel; // index of channel that owns the plugin - struct _bl00mbox_bud_t* chan_next; // for linked list in bl00mbox_channel_t +typedef struct _bl00mbox_bud_t{ + radspa_t * plugin; // plugin + uint64_t index; // unique index number for bud + uint32_t render_pass_id; // may be used by host to determine whether recomputation is necessary + uint8_t channel; // index of channel that owns the plugin + struct _bl00mbox_bud_t * chan_next; //for linked list in bl00mbox_channel_t } bl00mbox_bud_t; -typedef struct _bl00mbox_connection_subscriber_t { - uint8_t type; // 0: standard signal input, 1: output mixer +typedef struct _bl00mbox_connection_subscriber_t{ + uint8_t type; // 0: standard signal input, 1: output mixer uint8_t channel; uint64_t bud_index; uint32_t signal_index; - struct _bl00mbox_connection_subscriber_t* next; + struct _bl00mbox_connection_subscriber_t * next; } bl00mbox_connection_subscriber_t; -typedef struct _bl00mbox_connection_t { // child of bl00mbox_ll_t - int16_t buffer[BL00MBOX_MAX_BUFFER_LEN]; // MUST stay on top of struct bc - // type casting! - struct _bl00mbox_bud_t* source_bud; - uint32_t signal_index; // signal of source_bud that renders to buffer - struct _bl00mbox_connection_subscriber_t* subs; +typedef struct _bl00mbox_connection_t{ //child of bl00mbox_ll_t + int16_t buffer[BL00MBOX_MAX_BUFFER_LEN]; // MUST stay on top of struct bc type casting! + struct _bl00mbox_bud_t * source_bud; + uint32_t signal_index; // signal of source_bud that renders to buffer + struct _bl00mbox_connection_subscriber_t * subs; uint8_t channel; - struct _bl00mbox_connection_t* - chan_next; // for linked list in bl00mbox_channel_t; + struct _bl00mbox_connection_t * chan_next; //for linked list in bl00mbox_channel_t; } bl00mbox_connection_t; -typedef struct _bl00mbox_channel_root_t { - struct _bl00mbox_connection_t* con; - struct _bl00mbox_channel_root_t* next; +typedef struct _bl00mbox_channel_root_t{ + struct _bl00mbox_connection_t * con; + struct _bl00mbox_channel_root_t * next; } bl00mbox_channel_root_t; -typedef struct { - bool is_active; // rendering can be skipped if false +typedef struct{ + bool is_active; // rendering can be skipped if false bool is_free; int32_t volume; - struct _bl00mbox_channel_root_t* - root_list; // list of all roots associated with channels - uint32_t render_pass_id; // may be used by host to determine whether - // recomputation is necessary - struct _bl00mbox_bud_t* buds; // linked list with all channel buds - struct _bl00mbox_connection_t* - connections; // linked list with all channel connections + struct _bl00mbox_channel_root_t * root_list; // list of all roots associated with channels + uint32_t render_pass_id; // may be used by host to determine whether recomputation is necessary + struct _bl00mbox_bud_t * buds; // linked list with all channel buds + struct _bl00mbox_connection_t * connections; // linked list with all channel connections } bl00mbox_channel_t; -bl00mbox_channel_t* bl00mbox_get_channel(uint8_t chan); +bl00mbox_channel_t * bl00mbox_get_channel(uint8_t chan); void bl00mbox_channel_enable(uint8_t chan); void bl00mbox_channel_enable(uint8_t chan); @@ -81,8 +75,7 @@ uint8_t bl00mbox_channel_get_foreground_index(); void bl00mbox_channel_set_foreground_index(uint8_t index); bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index); -bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, - bool enable); +bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, bool enable); -bool bl00mbox_audio_waitfor_pointer_change(void** ptr, void* new_val); -void bl00mbox_audio_bud_render(bl00mbox_bud_t* bud, uint16_t num_samples); +bool bl00mbox_audio_waitfor_pointer_change(void ** ptr, void * new_val); +void bl00mbox_audio_bud_render(bl00mbox_bud_t * bud, uint16_t num_samples); diff --git a/components/bl00mbox/include/bl00mbox_plugin_registry.h b/components/bl00mbox/include/bl00mbox_plugin_registry.h index 44141d5a1e7728a272b64986935bbc48c0f11dcc..077af6785752119e1b0f992fdce1e0d1c76e7a9a 100644 --- a/components/bl00mbox/include/bl00mbox_plugin_registry.h +++ b/components/bl00mbox/include/bl00mbox_plugin_registry.h @@ -1,16 +1,15 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #pragma once -#include "radspa.h" #include "stdio.h" +#include "radspa.h" -typedef struct _bl00mbox_plugin_registry_t { - radspa_descriptor_t* descriptor; - struct _bl00mbox_plugin_registry_t* next; +typedef struct _bl00mbox_plugin_registry_t{ + radspa_descriptor_t * descriptor; + struct _bl00mbox_plugin_registry_t * next; } bl00mbox_plugin_registry_t; -radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_id( - uint32_t id); -radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_index( - uint32_t index); +radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_id(uint32_t id); +radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_index(uint32_t index); void bl00mbox_plugin_registry_init(void); uint16_t bl00mbox_plugin_registry_get_plugin_num(void); + diff --git a/components/bl00mbox/include/bl00mbox_radspa_requirements.h b/components/bl00mbox/include/bl00mbox_radspa_requirements.h index 39813840438b0ddc26fce564de5a0c623c6652ac..142810dd5c07e7a1116b3208980117e2252df763 100644 --- a/components/bl00mbox/include/bl00mbox_radspa_requirements.h +++ b/components/bl00mbox/include/bl00mbox_radspa_requirements.h @@ -1,5 +1,6 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #pragma once #include "bl00mbox_audio.h" #include "radspa.h" #include "radspa_helpers.h" + diff --git a/components/bl00mbox/include/bl00mbox_user.h b/components/bl00mbox/include/bl00mbox_user.h index 447e55c907b29dad13018757bb4353847c6677a4..9e5fe3fb039b602846d8e1d1a6867399f39eabf8 100644 --- a/components/bl00mbox/include/bl00mbox_user.h +++ b/components/bl00mbox/include/bl00mbox_user.h @@ -1,86 +1,54 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #pragma once -#include <math.h> #include <stdio.h> +#include <math.h> #include <string.h> +#include "bl00mbox_plugin_registry.h" +#include "bl00mbox_audio.h" #include <stdint.h> #include "bl00mbox_audio.h" -#include "bl00mbox_plugin_registry.h" #include "radspa_helpers.h" uint16_t bl00mbox_channel_buds_num(uint8_t channel); uint64_t bl00mbox_channel_get_bud_by_list_pos(uint8_t channel, uint32_t pos); uint16_t bl00mbox_channel_conns_num(uint8_t channel); uint16_t bl00mbox_channel_mixer_num(uint8_t channel); -uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel, - uint32_t pos); -uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel, - uint32_t pos); +uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel, uint32_t pos); +uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel, uint32_t pos); bool bl00mbox_channel_clear(uint8_t channel); -bool bl00mbox_channel_connect_signal_to_output_mixer(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index); -bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, - uint32_t bud_rx_signal_index, - uint32_t bud_tx_index, - uint32_t bud_tx_signal_index); -bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, - uint32_t bud_rx_index, - uint32_t bud_rx_signal_index); -bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, - uint32_t bud_tx_index, - uint32_t bud_tx_signal_index); -bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_tx_index, - uint32_t bud_tx_signal_index); -bool bl00mbox_channel_disconnect_signal_from_output_mixer( - uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +bool bl00mbox_channel_connect_signal_to_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index, + uint32_t bud_tx_index, uint32_t bud_tx_signal_index); +bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index); +bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, uint32_t bud_tx_index, uint32_t bud_tx_signal_index); +bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_tx_index, uint32_t bud_tx_signal_index); +bool bl00mbox_channel_disconnect_signal_from_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); -bl00mbox_bud_t* bl00mbox_channel_new_bud(uint8_t channel, uint32_t id, - uint32_t init_var); +bl00mbox_bud_t * bl00mbox_channel_new_bud(uint8_t channel, uint32_t id, uint32_t init_var); bool bl00mbox_channel_delete_bud(uint8_t channel, uint32_t bud_index); bool bl00mbox_channel_bud_exists(uint8_t channel, uint32_t bud_index); -char* bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index); -char* bl00mbox_channel_bud_get_description(uint8_t channel, uint32_t bud_index); -uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel, - uint32_t bud_index); -uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel, - uint32_t bud_index); +char * bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index); +char * bl00mbox_channel_bud_get_description(uint8_t channel, uint32_t bud_index); +uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel, uint32_t bud_index); +uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel, uint32_t bud_index); -char* bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index, - uint32_t bud_signal_index); -char* bl00mbox_channel_bud_get_signal_description(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index); -char* bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index, - uint32_t bud_signal_index); -bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index, - uint32_t bud_signal_index, - int16_t value); -int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index); -uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel, - uint32_t bud_index, - uint32_t bud_signal_index); -uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index, - uint16_t signal_index); -uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel, - uint64_t bud_index, - uint16_t signal_index, - uint8_t pos); -int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos( - uint8_t channel, uint64_t bud_index, uint16_t signal_index, uint8_t pos); -uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index, - uint16_t signal_index); -uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index, - uint16_t signal_index); +char * bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +char * bl00mbox_channel_bud_get_signal_description(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +char * bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index, int16_t value); +int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index); +uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index, uint16_t signal_index); +uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index, + uint16_t signal_index, uint8_t pos); +int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index, + uint16_t signal_index, uint8_t pos); +uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index, uint16_t signal_index); +uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index, uint16_t signal_index); -bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index, - uint32_t table_index, int16_t value); -int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel, - uint32_t bud_index, - uint32_t table_index); +bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index, int16_t value); +int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index); int16_t bl00mbox_channel_bud_get_table_len(uint8_t channel, uint32_t bud_index); diff --git a/components/bl00mbox/plugins/ampliverter.c b/components/bl00mbox/plugins/ampliverter.c index e55685bd1ea1f9b31c70c0ffac54aa32cd6ea441..4dfdaf564fc68f7479b22c506fb401f979facc0e 100644 --- a/components/bl00mbox/plugins/ampliverter.c +++ b/components/bl00mbox/plugins/ampliverter.c @@ -2,16 +2,16 @@ // we're defining a prototype for the create function because it has a circular // dependency with the descriptor -radspa_t* ampliverter_create(uint32_t init_var); +radspa_t * ampliverter_create(uint32_t init_var); radspa_descriptor_t ampliverter_desc = { .name = "ampliverter", .id = 69, .description = "saturating multiplication and addition", .create_plugin_instance = ampliverter_create, - // with this we can only use radspa_standard_plugin_create to allocate - // memory. this restricts data layout flexibility for large buffers, but in - // return it offers offers a bit of protection from double free/memory leak - // issues and makes plugins easier to write. + // with this we can only use radspa_standard_plugin_create to allocate memory. + // this restricts data layout flexibility for large buffers, but in return it offers + // offers a bit of protection from double free/memory leak issues and makes plugins + // easier to write. .destroy_plugin_instance = radspa_standard_plugin_destroy }; @@ -21,73 +21,59 @@ radspa_descriptor_t ampliverter_desc = { #define AMPLIVERTER_GAIN 2 #define AMPLIVERTER_BIAS 3 -void ampliverter_run(radspa_t* ampliverter, uint16_t num_samples, - uint32_t render_pass_id) { - // step 1: get signal pointers. since these are stored in a linked list this - // is a rather slow operation and should ideally be only be done once per - // call. if no signals with output hint are being read the run function may - // exit early. - radspa_signal_t* output_sig = - radspa_signal_get_by_index(ampliverter, AMPLIVERTER_OUTPUT); - if (output_sig->buffer == NULL) return; - radspa_signal_t* input_sig = - radspa_signal_get_by_index(ampliverter, AMPLIVERTER_INPUT); - radspa_signal_t* gain_sig = - radspa_signal_get_by_index(ampliverter, AMPLIVERTER_GAIN); - radspa_signal_t* bias_sig = - radspa_signal_get_by_index(ampliverter, AMPLIVERTER_BIAS); +void ampliverter_run(radspa_t * ampliverter, uint16_t num_samples, uint32_t render_pass_id){ + // step 1: get signal pointers. since these are stored in a linked list this is a rather + // slow operation and should ideally be only be done once per call. + // if no signals with output hint are being read the run function may exit early. + radspa_signal_t * output_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_OUTPUT); + if(output_sig->buffer == NULL) return; + radspa_signal_t * input_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_INPUT); + radspa_signal_t * gain_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_GAIN); + radspa_signal_t * bias_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_BIAS); + static int16_t ret = 0; - for (uint16_t i = 0; i < num_samples; i++) { - // step 2: render the outputs. most of the time a simple for loop will - // be fine. using {*radspa_signal_t}->get_value is required to - // automatically switch between static values and streamed data at - // various sample rates, don't access the data directly - int16_t bias = - bias_sig->get_value(bias_sig, i, num_samples, render_pass_id); - int16_t gain = - gain_sig->get_value(gain_sig, i, num_samples, render_pass_id); - if (gain == 0) { + for(uint16_t i = 0; i < num_samples; i++){ + // step 2: render the outputs. most of the time a simple for loop will be fine. + // using {*radspa_signal_t}->get_value is required to automatically switch between + // static values and streamed data at various sample rates, don't access the data directly + int16_t bias = bias_sig->get_value(bias_sig, i, num_samples, render_pass_id); + int16_t gain = gain_sig->get_value(gain_sig, i, num_samples, render_pass_id); + if(gain == 0){ // make sure that the output buffer exists by comparing to NULL! // (here done earlier outside of the loop) ret = bias; } else { - ret = - input_sig->get_value(input_sig, i, num_samples, render_pass_id); - // the helper functions make sure that potential future float - // versions behave as intended + ret = input_sig->get_value(input_sig, i, num_samples, render_pass_id); + // the helper functions make sure that potential future float versions behave + // as intended ret = radspa_mult_shift(ret, gain); ret = radspa_add_sat(ret, bias); } (output_sig->buffer)[i] = ret; + } output_sig->value = ret; } -radspa_t* ampliverter_create(uint32_t init_var) { +radspa_t * ampliverter_create(uint32_t init_var){ // init_var is not used in this example - // step 1: try to allocate enough memory for a standard plugin with the - // given amount of signals and plugin data. there is no plugin data in this - // case, but sizeof(void) is invalid sooo we're taking the next smallest - // thing (char) ig? we're not good at C. providing the descriptor address is - // required to make sure it is not forgotten. - radspa_t* ampliverter = radspa_standard_plugin_create( - &liverter_desc, AMPLIVERTER_NUM_SIGNALS, sizeof(char), 0); - if (ampliverter == NULL) return NULL; + // step 1: try to allocate enough memory for a standard plugin with the given amount of signals + // and plugin data. there is no plugin data in this case, but sizeof(void) is invalid sooo we're + // taking the next smallest thing (char) ig? we're not good at C. + // providing the descriptor address is required to make sure it is not forgotten. + radspa_t * ampliverter = radspa_standard_plugin_create(&liverter_desc, AMPLIVERTER_NUM_SIGNALS, sizeof(char), 0); + if(ampliverter == NULL) return NULL; // step 2: define run function ampliverter->render = ampliverter_run; - - // step 3: standard_plugin_create has already created dummy signals for us, - // we just need to fill them - radspa_signal_set(ampliverter, AMPLIVERTER_OUTPUT, "output", - RADSPA_SIGNAL_HINT_OUTPUT, 0); - radspa_signal_set(ampliverter, AMPLIVERTER_INPUT, "input", - RADSPA_SIGNAL_HINT_INPUT, 0); - radspa_signal_set(ampliverter, AMPLIVERTER_GAIN, "gain", - RADSPA_SIGNAL_HINT_INPUT, 32767); - radspa_signal_set(ampliverter, AMPLIVERTER_BIAS, "bias", - RADSPA_SIGNAL_HINT_INPUT, 0); + + // step 3: standard_plugin_create has already created dummy signals for us, we just need to + // fill them + radspa_signal_set(ampliverter, AMPLIVERTER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(ampliverter, AMPLIVERTER_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 0); + radspa_signal_set(ampliverter, AMPLIVERTER_GAIN, "gain", RADSPA_SIGNAL_HINT_INPUT, 32767); + radspa_signal_set(ampliverter, AMPLIVERTER_BIAS, "bias", RADSPA_SIGNAL_HINT_INPUT, 0); return ampliverter; } diff --git a/components/bl00mbox/plugins/ampliverter.h b/components/bl00mbox/plugins/ampliverter.h index 990c36a49e42895eae7dbbbecc3f58abbe532701..4056316a25f9be994c20ebeb9ffd423ee3c03597 100644 --- a/components/bl00mbox/plugins/ampliverter.h +++ b/components/bl00mbox/plugins/ampliverter.h @@ -3,6 +3,6 @@ #include <radspa_helpers.h> extern radspa_descriptor_t ampliverter_desc; -radspa_t* ampliverter_create(uint32_t init_var); -void ampliverter_run(radspa_t* osc, uint16_t num_samples, - uint32_t render_pass_id); +radspa_t * ampliverter_create(uint32_t init_var); +void ampliverter_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); + diff --git a/components/bl00mbox/plugins/brok3n/filter.c b/components/bl00mbox/plugins/brok3n/filter.c index d15696d24bcdf11f48e643b78afff2a0be94dee6..d9cdd4ff830cc365cd72ab3e6620602db4ec7f1f 100644 --- a/components/bl00mbox/plugins/brok3n/filter.c +++ b/components/bl00mbox/plugins/brok3n/filter.c @@ -1,12 +1,13 @@ #include "filter.h" -radspa_t* filter_create(uint32_t init_var); -radspa_descriptor_t filter_desc = { .name = "filter", - .id = 69420, - .description = "simple filter", - .create_plugin_instance = filter_create, - .destroy_plugin_instance = - radspa_standard_plugin_destroy }; +radspa_t * filter_create(uint32_t init_var); +radspa_descriptor_t filter_desc = { + .name = "filter", + .id = 69420, + .description = "simple filter", + .create_plugin_instance = filter_create, + .destroy_plugin_instance = radspa_standard_plugin_destroy +}; #define FILTER_NUM_SIGNALS 5 #define FILTER_OUTPUT 0 @@ -15,20 +16,21 @@ radspa_descriptor_t filter_desc = { .name = "filter", #define FILTER_Q 3 #define FILTER_GAIN 4 -static int16_t apply_filter(filter_data_t* data, int32_t input, int32_t gain) { + +static int16_t apply_filter(filter_data_t * data, int32_t input, int32_t gain){ data->pos++; - if (data->pos >= 3) data->pos = 0; + if(data->pos >= 3) data->pos = 0; - int64_t out = 0; + int64_t out = 0; int64_t in_acc = input; - for (int8_t i = 0; i < 2; i++) { + for(int8_t i=0; i<2; i++){ int8_t pos = data->pos - i - 1; - if (pos < 0) pos += 3; - in_acc += (2 - i) * data->in_history[pos]; + if(pos < 0) pos += 3; + in_acc += (2-i)*data->in_history[pos]; int16_t shift = data->out_coeff_shift[i] - data->in_coeff_shift; - if (shift >= 0) { + if(shift >= 0){ out -= (data->out_history[pos] * data->out_coeff[i]) >> shift; } else { out -= (data->out_history[pos] * data->out_coeff[i]) << (-shift); @@ -40,38 +42,38 @@ static int16_t apply_filter(filter_data_t* data, int32_t input, int32_t gain) { data->in_history[data->pos] = input; data->out_history[data->pos] = out; - return radspa_mult_shift(out, gain); + return radspa_mult_shift(out, gain); } static uint8_t coeff_shift(float coeff) { int32_t ret = 16; - while (1) { - int32_t test_val = (1 << ret) * coeff; - if (test_val < 0) test_val = -test_val; - if (test_val > (1 << 12)) { + while(1){ + int32_t test_val = (1<<ret) * coeff; + if(test_val < 0) test_val = -test_val; + if(test_val > (1<<12)){ ret -= 3; - } else if (test_val < (1 << 8)) { + } else if (test_val < (1<<8)){ ret += 3; } else { break; } - if (ret > 28) break; - if (ret < 4) break; + if(ret > 28) break; + if(ret < 4) break; } return ret; } -static void set_filter_coeffs(filter_data_t* data, float freq, float q) { - // molasses, sorry - if (freq == 0) return; - if (q == 0) return; - float K = 2 * 48000; +static void set_filter_coeffs(filter_data_t * data, float freq, float q){ + //molasses, sorry + if(freq == 0) return; + if(q == 0) return; + float K = 2*48000; float omega = freq * 6.28; float A[3]; - A[0] = K * K; - A[1] = K * omega / q; - A[2] = omega * omega; - float B = omega * omega; + A[0] = K*K; + A[1] = K*omega/q; + A[2] = omega*omega; + float B = omega*omega; float sum_a = A[0] + A[1] + A[2]; @@ -80,46 +82,39 @@ static void set_filter_coeffs(filter_data_t* data, float freq, float q) { round = B / sum_a; shift = coeff_shift(round); - data->in_coeff = round * (1 << shift); + data->in_coeff = round * (1<<shift); data->in_coeff_shift = shift; - round = 2. * (A[2] - A[0]) / sum_a; + round = 2.*(A[2]-A[0]) / sum_a; shift = coeff_shift(round); - data->out_coeff[0] = round * (1 << shift); + data->out_coeff[0] = round * (1<<shift); data->out_coeff_shift[0] = shift; - round = (A[0] - A[1] + A[2]) / sum_a; + round = (A[0]-A[1]+A[2]) / sum_a; shift = coeff_shift(round); - data->out_coeff[1] = round * (1 << shift); + data->out_coeff[1] = round * (1<<shift); data->out_coeff_shift[1] = shift; } -void filter_run(radspa_t* filter, uint16_t num_samples, - uint32_t render_pass_id) { - radspa_signal_t* output_sig = - radspa_signal_get_by_index(filter, FILTER_OUTPUT); - if (output_sig->buffer == NULL) return; - filter_data_t* data = filter->plugin_data; - radspa_signal_t* input_sig = - radspa_signal_get_by_index(filter, FILTER_INPUT); - radspa_signal_t* freq_sig = radspa_signal_get_by_index(filter, FILTER_FREQ); - radspa_signal_t* q_sig = radspa_signal_get_by_index(filter, FILTER_Q); - radspa_signal_t* gain_sig = radspa_signal_get_by_index(filter, FILTER_GAIN); +void filter_run(radspa_t * filter, uint16_t num_samples, uint32_t render_pass_id){ + radspa_signal_t * output_sig = radspa_signal_get_by_index(filter, FILTER_OUTPUT); + if(output_sig->buffer == NULL) return; + filter_data_t * data = filter->plugin_data; + radspa_signal_t * input_sig = radspa_signal_get_by_index(filter, FILTER_INPUT); + radspa_signal_t * freq_sig = radspa_signal_get_by_index(filter, FILTER_FREQ); + radspa_signal_t * q_sig = radspa_signal_get_by_index(filter, FILTER_Q); + radspa_signal_t * gain_sig = radspa_signal_get_by_index(filter, FILTER_GAIN); static int16_t ret = 0; - - for (uint16_t i = 0; i < num_samples; i++) { - int16_t input = - radspa_signal_get_value(input_sig, i, num_samples, render_pass_id); - int32_t freq = - radspa_signal_get_value(freq_sig, i, num_samples, render_pass_id); - int16_t q = - radspa_signal_get_value(q_sig, i, num_samples, render_pass_id); - int16_t gain = - radspa_signal_get_value(gain_sig, i, num_samples, render_pass_id); - - if ((freq != data->prev_freq) | (q != data->prev_q)) { - set_filter_coeffs(data, freq, ((float)q + 1.) / 1000.); + + for(uint16_t i = 0; i < num_samples; i++){ + int16_t input = radspa_signal_get_value(input_sig, i, num_samples, render_pass_id); + int32_t freq = radspa_signal_get_value(freq_sig, i, num_samples, render_pass_id); + int16_t q = radspa_signal_get_value(q_sig, i, num_samples, render_pass_id); + int16_t gain = radspa_signal_get_value(gain_sig, i, num_samples, render_pass_id); + + if((freq != data->prev_freq) | (q != data->prev_q)){ + set_filter_coeffs(data, freq, ((float) q + 1.)/1000.); data->prev_freq = freq; data->prev_q = q; } @@ -130,22 +125,17 @@ void filter_run(radspa_t* filter, uint16_t num_samples, output_sig->value = ret; } -radspa_t* filter_create(uint32_t real_init_var) { - radspa_t* filter = radspa_standard_plugin_create( - &filter_desc, FILTER_NUM_SIGNALS, sizeof(filter_data_t), 0); - if (filter == NULL) return NULL; +radspa_t * filter_create(uint32_t real_init_var){ + radspa_t * filter = radspa_standard_plugin_create(&filter_desc, FILTER_NUM_SIGNALS, sizeof(filter_data_t), 0); + if(filter == NULL) return NULL; filter->render = filter_run; - radspa_signal_set(filter, FILTER_OUTPUT, "output", - RADSPA_SIGNAL_HINT_OUTPUT, 0); - radspa_signal_set(filter, FILTER_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, - 0); - radspa_signal_set(filter, FILTER_FREQ, "freq", RADSPA_SIGNAL_HINT_INPUT, - 500); + radspa_signal_set(filter, FILTER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(filter, FILTER_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 0); + radspa_signal_set(filter, FILTER_FREQ, "freq", RADSPA_SIGNAL_HINT_INPUT, 500); radspa_signal_set(filter, FILTER_Q, "reso", RADSPA_SIGNAL_HINT_INPUT, 1000); - radspa_signal_set(filter, FILTER_GAIN, "gain", RADSPA_SIGNAL_HINT_INPUT, - 32760); - filter_data_t* data = filter->plugin_data; + radspa_signal_set(filter, FILTER_GAIN, "gain", RADSPA_SIGNAL_HINT_INPUT, 32760); + filter_data_t * data = filter->plugin_data; data->pos = 0; - data->prev_freq = 1 << 24; + data->prev_freq = 1<<24; return filter; } diff --git a/components/bl00mbox/plugins/brok3n/filter.h b/components/bl00mbox/plugins/brok3n/filter.h index e575e7daca36dee48d17ba3ac24f98a115317ed8..36e3d1e93c06e5b01ef76a9e76a9360be44aa07f 100644 --- a/components/bl00mbox/plugins/brok3n/filter.h +++ b/components/bl00mbox/plugins/brok3n/filter.h @@ -15,5 +15,5 @@ typedef struct { } filter_data_t; extern radspa_descriptor_t filter_desc; -radspa_t* filter_create(uint32_t init_var); -void filter_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id); +radspa_t * filter_create(uint32_t init_var); +void filter_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); diff --git a/components/bl00mbox/plugins/delay.c b/components/bl00mbox/plugins/delay.c index ede1d95a490180c060ef9c1dc3355a79acf3c252..756e703d72df7d4228bc9f21632a1b839de702b3 100644 --- a/components/bl00mbox/plugins/delay.c +++ b/components/bl00mbox/plugins/delay.c @@ -1,6 +1,6 @@ #include "delay.h" -radspa_t* delay_create(uint32_t init_var); +radspa_t * delay_create(uint32_t init_var); radspa_descriptor_t delay_desc = { .name = "delay", .id = 42069, @@ -18,94 +18,73 @@ radspa_descriptor_t delay_desc = { #define DELAY_DRY_VOL 5 #define DELAY_REC_VOL 6 -void delay_run(radspa_t* delay, uint16_t num_samples, uint32_t render_pass_id) { - radspa_signal_t* output_sig = - radspa_signal_get_by_index(delay, DELAY_OUTPUT); - if (output_sig->buffer == NULL) return; - delay_data_t* data = delay->plugin_data; - int16_t* buf = delay->plugin_table; - radspa_signal_t* input_sig = radspa_signal_get_by_index(delay, DELAY_INPUT); - radspa_signal_t* time_sig = radspa_signal_get_by_index(delay, DELAY_TIME); - radspa_signal_t* feedback_sig = - radspa_signal_get_by_index(delay, DELAY_FEEDBACK); - radspa_signal_t* level_sig = radspa_signal_get_by_index(delay, DELAY_LEVEL); - radspa_signal_t* dry_vol_sig = - radspa_signal_get_by_index(delay, DELAY_DRY_VOL); - radspa_signal_t* rec_vol_sig = - radspa_signal_get_by_index(delay, DELAY_REC_VOL); +void delay_run(radspa_t * delay, uint16_t num_samples, uint32_t render_pass_id){ + radspa_signal_t * output_sig = radspa_signal_get_by_index(delay, DELAY_OUTPUT); + if(output_sig->buffer == NULL) return; + delay_data_t * data = delay->plugin_data; + int16_t * buf = delay->plugin_table; + radspa_signal_t * input_sig = radspa_signal_get_by_index(delay, DELAY_INPUT); + radspa_signal_t * time_sig = radspa_signal_get_by_index(delay, DELAY_TIME); + radspa_signal_t * feedback_sig = radspa_signal_get_by_index(delay, DELAY_FEEDBACK); + radspa_signal_t * level_sig = radspa_signal_get_by_index(delay, DELAY_LEVEL); + radspa_signal_t * dry_vol_sig = radspa_signal_get_by_index(delay, DELAY_DRY_VOL); + radspa_signal_t * rec_vol_sig = radspa_signal_get_by_index(delay, DELAY_REC_VOL); static int16_t ret = 0; - + uint32_t buffer_size = delay->plugin_table_len; - - for (uint16_t i = 0; i < num_samples; i++) { - uint32_t time = - time_sig->get_value(time_sig, i, num_samples, render_pass_id); - if (time > data->max_delay) time = data->max_delay; + + for(uint16_t i = 0; i < num_samples; i++){ + uint32_t time = time_sig->get_value(time_sig, i, num_samples, render_pass_id); + if(time > data->max_delay) time = data->max_delay; data->write_head_position++; - while (data->write_head_position >= buffer_size) - data->write_head_position -= buffer_size; // maybe faster than % - if (time != data->time_prev) { - data->read_head_position = - time * (48000 / 1000) + data->write_head_position; + while(data->write_head_position >= buffer_size) data->write_head_position -= buffer_size; // maybe faster than % + if(time != data->time_prev){ + data->read_head_position = time * (48000/1000) + data->write_head_position; data->time_prev = time; } else { data->read_head_position++; } - while (data->read_head_position >= buffer_size) - data->read_head_position -= buffer_size; + while(data->read_head_position >= buffer_size) data->read_head_position -= buffer_size; - // int16_t * buf = &(data->buffer); - - int16_t dry = - input_sig->get_value(input_sig, i, num_samples, render_pass_id); + //int16_t * buf = &(data->buffer); + + int16_t dry = input_sig->get_value(input_sig, i, num_samples, render_pass_id); int16_t wet = buf[data->read_head_position]; - int16_t fb = feedback_sig->get_value(feedback_sig, i, num_samples, - render_pass_id); - int16_t level = - level_sig->get_value(level_sig, i, num_samples, render_pass_id); + int16_t fb = feedback_sig->get_value(feedback_sig, i, num_samples, render_pass_id); + int16_t level = level_sig->get_value(level_sig, i, num_samples, render_pass_id); - int16_t dry_vol = - dry_vol_sig->get_value(dry_vol_sig, i, num_samples, render_pass_id); - int16_t rec_vol = - rec_vol_sig->get_value(rec_vol_sig, i, num_samples, render_pass_id); + int16_t dry_vol = dry_vol_sig->get_value(dry_vol_sig, i, num_samples, render_pass_id); + int16_t rec_vol = rec_vol_sig->get_value(rec_vol_sig, i, num_samples, render_pass_id); - if (rec_vol) { - buf[data->write_head_position] = radspa_add_sat( - radspa_mult_shift(rec_vol, dry), radspa_mult_shift(wet, fb)); + if(rec_vol){ + buf[data->write_head_position] = radspa_add_sat(radspa_mult_shift(rec_vol, dry), radspa_mult_shift(wet,fb)); } - - ret = radspa_add_sat(radspa_mult_shift(dry_vol, dry), - radspa_mult_shift(wet, level)); + + ret = radspa_add_sat(radspa_mult_shift(dry_vol,dry), radspa_mult_shift(wet,level)); (output_sig->buffer)[i] = ret; } output_sig->value = ret; } -radspa_t* delay_create(uint32_t init_var) { - if (init_var == 0) init_var = 500; - uint32_t buffer_size = init_var * (48000 / 1000); - radspa_t* delay = radspa_standard_plugin_create( - &delay_desc, DELAY_NUM_SIGNALS, sizeof(delay_data_t), buffer_size); +radspa_t * delay_create(uint32_t init_var){ + if(init_var == 0) init_var = 500; + uint32_t buffer_size = init_var*(48000/1000); + radspa_t * delay = radspa_standard_plugin_create(&delay_desc, DELAY_NUM_SIGNALS, sizeof(delay_data_t), buffer_size); - if (delay == NULL) return NULL; - delay_data_t* plugin_data = delay->plugin_data; + if(delay == NULL) return NULL; + delay_data_t * plugin_data = delay->plugin_data; plugin_data->max_delay = init_var; delay->render = delay_run; - radspa_signal_set(delay, DELAY_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, - 0); + radspa_signal_set(delay, DELAY_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); radspa_signal_set(delay, DELAY_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 0); radspa_signal_set(delay, DELAY_TIME, "time", RADSPA_SIGNAL_HINT_INPUT, 200); - radspa_signal_set(delay, DELAY_FEEDBACK, "feedback", - RADSPA_SIGNAL_HINT_INPUT, 16000); - radspa_signal_set(delay, DELAY_LEVEL, "level", RADSPA_SIGNAL_HINT_INPUT, - 16000); - radspa_signal_set(delay, DELAY_DRY_VOL, "dry_vol", RADSPA_SIGNAL_HINT_INPUT, - 32767); - radspa_signal_set(delay, DELAY_REC_VOL, "rec_vol", RADSPA_SIGNAL_HINT_INPUT, - 32767); + radspa_signal_set(delay, DELAY_FEEDBACK, "feedback", RADSPA_SIGNAL_HINT_INPUT, 16000); + radspa_signal_set(delay, DELAY_LEVEL, "level", RADSPA_SIGNAL_HINT_INPUT, 16000); + radspa_signal_set(delay, DELAY_DRY_VOL, "dry_vol", RADSPA_SIGNAL_HINT_INPUT, 32767); + radspa_signal_set(delay, DELAY_REC_VOL, "rec_vol", RADSPA_SIGNAL_HINT_INPUT, 32767); return delay; } diff --git a/components/bl00mbox/plugins/delay.h b/components/bl00mbox/plugins/delay.h index 040a5af2cc9a4a7990055fa7e4fbf03da07a4ce0..c0882a1085164432b99351c98871834d39e1ad94 100644 --- a/components/bl00mbox/plugins/delay.h +++ b/components/bl00mbox/plugins/delay.h @@ -10,5 +10,6 @@ typedef struct { } delay_data_t; extern radspa_descriptor_t delay_desc; -radspa_t* delay_create(uint32_t init_var); -void delay_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id); +radspa_t * delay_create(uint32_t init_var); +void delay_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); + diff --git a/components/bl00mbox/plugins/sampler.c b/components/bl00mbox/plugins/sampler.c index c00041c5da1372c075c7cbc74e18ec288e57c9b8..8c7d65711c87edb8d2e89adb662f0b13f6805e02 100644 --- a/components/bl00mbox/plugins/sampler.c +++ b/components/bl00mbox/plugins/sampler.c @@ -1,6 +1,6 @@ #include "sampler.h" -radspa_t* sampler_create(uint32_t init_var); +radspa_t * sampler_create(uint32_t init_var); radspa_descriptor_t sampler_desc = { .name = "sampler_ram", .id = 696969, @@ -13,39 +13,35 @@ radspa_descriptor_t sampler_desc = { #define SAMPLER_OUTPUT 0 #define SAMPLER_TRIGGER 1 -void sampler_run(radspa_t* sampler, uint16_t num_samples, - uint32_t render_pass_id) { - radspa_signal_t* output_sig = - radspa_signal_get_by_index(sampler, SAMPLER_OUTPUT); - if (output_sig->buffer == NULL) return; - sampler_data_t* data = sampler->plugin_data; - int16_t* buf = sampler->plugin_table; - radspa_signal_t* trigger_sig = - radspa_signal_get_by_index(sampler, SAMPLER_TRIGGER); +void sampler_run(radspa_t * sampler, uint16_t num_samples, uint32_t render_pass_id){ + radspa_signal_t * output_sig = radspa_signal_get_by_index(sampler, SAMPLER_OUTPUT); + if(output_sig->buffer == NULL) return; + sampler_data_t * data = sampler->plugin_data; + int16_t * buf = sampler->plugin_table; + radspa_signal_t * trigger_sig = radspa_signal_get_by_index(sampler, SAMPLER_TRIGGER); static int32_t ret = 0; - + uint32_t buffer_size = sampler->plugin_table_len; + + for(uint16_t i = 0; i < num_samples; i++){ - 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 trigger = trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id); + int16_t vel = radspa_trigger_get(trigger, &(data->trigger_prev)); - if (vel > 0) { + if(vel > 0){ data->read_head_position = 0; data->volume = vel; - } else if (vel < 0) { + } else if(vel < 0){ data->read_head_position = buffer_size; } - if (data->read_head_position < buffer_size) { - ret = - radspa_mult_shift(buf[data->read_head_position], data->volume); + if(data->read_head_position < buffer_size){ + ret = radspa_mult_shift(buf[data->read_head_position], data->volume); data->read_head_position++; } else { - // ret = (ret * 255)>>8; // avoid dc clicks with bad samples + //ret = (ret * 255)>>8; // avoid dc clicks with bad samples ret = 0; } @@ -54,17 +50,13 @@ void sampler_run(radspa_t* sampler, uint16_t num_samples, output_sig->value = ret; } -radspa_t* sampler_create(uint32_t init_var) { - if (init_var == 0) return NULL; // doesn't make sense +radspa_t * sampler_create(uint32_t init_var){ + if(init_var == 0) return NULL; //doesn't make sense uint32_t buffer_size = init_var; - radspa_t* sampler = - radspa_standard_plugin_create(&sampler_desc, SAMPLER_NUM_SIGNALS, - sizeof(sampler_data_t), buffer_size); - if (sampler == NULL) return NULL; + radspa_t * sampler = radspa_standard_plugin_create(&sampler_desc, SAMPLER_NUM_SIGNALS, sizeof(sampler_data_t), buffer_size); + if(sampler == NULL) return NULL; sampler->render = sampler_run; - radspa_signal_set(sampler, SAMPLER_OUTPUT, "output", - RADSPA_SIGNAL_HINT_OUTPUT, 0); - radspa_signal_set(sampler, SAMPLER_TRIGGER, "trigger", - RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0); + radspa_signal_set(sampler, SAMPLER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(sampler, SAMPLER_TRIGGER, "trigger", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0); return sampler; } diff --git a/components/bl00mbox/plugins/sampler.h b/components/bl00mbox/plugins/sampler.h index c9bfd8dd28acb401ffa7e3c958704b957d3b5c44..53bedfbacd9b77c84148b80ecfcc34c74040fb27 100644 --- a/components/bl00mbox/plugins/sampler.h +++ b/components/bl00mbox/plugins/sampler.h @@ -9,5 +9,6 @@ typedef struct { } sampler_data_t; extern radspa_descriptor_t sampler_desc; -radspa_t* sampler_create(uint32_t init_var); -void sampler_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id); +radspa_t * sampler_create(uint32_t init_var); +void sampler_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); + diff --git a/components/bl00mbox/plugins/sequencer.c b/components/bl00mbox/plugins/sequencer.c index 21187962e47cc948f1e993c371f0cbe68a98c5d6..0d13d377acf206de274d2c4db97a4d7411d4adb1 100644 --- a/components/bl00mbox/plugins/sequencer.c +++ b/components/bl00mbox/plugins/sequencer.c @@ -1,12 +1,12 @@ #include "sequencer.h" -radspa_descriptor_t sequencer_desc = { .name = "sequencer", - .id = 56709, - .description = "i.o.u.", - .create_plugin_instance = - sequencer_create, - .destroy_plugin_instance = - radspa_standard_plugin_destroy }; +radspa_descriptor_t sequencer_desc = { + .name = "sequencer", + .id = 56709, + .description = "i.o.u.", + .create_plugin_instance = sequencer_create, + .destroy_plugin_instance = radspa_standard_plugin_destroy +}; #define SEQUENCER_NUM_SIGNALS 6 #define SEQUENCER_STEP 0 @@ -17,53 +17,42 @@ radspa_descriptor_t sequencer_desc = { .name = "sequencer", #define SEQUENCER_BEAT_DIV 5 #define SEQUENCER_OUTPUT 6 -static uint64_t target(uint64_t step_len, uint64_t bpm, uint64_t beat_div) { - return (48000ULL * 60 * 4) / (bpm * beat_div); +static uint64_t target(uint64_t step_len, uint64_t bpm, uint64_t beat_div){ + return (48000ULL * 60 * 4) / (bpm * beat_div); } -radspa_t* sequencer_create(uint32_t init_var) { - // init_var: - // lsbyte: number of channels - // lsbyte+1: number of pixels in channel (>= bars*beats_div) +radspa_t * sequencer_create(uint32_t init_var){ + //init_var: + // lsbyte: number of channels + // lsbyte+1: number of pixels in channel (>= bars*beats_div) uint32_t num_tracks = 1; uint32_t num_pixels = 16; - if (init_var) { + if(init_var){ num_tracks = init_var & 0xFF; - num_pixels = (init_var >> 8) & 0xFF; + num_pixels = (init_var>>8) & 0xFF; } uint32_t table_size = num_tracks * (num_pixels + 1); - uint32_t num_signals = - num_tracks + SEQUENCER_NUM_SIGNALS; // one for each channel output - radspa_t* sequencer = radspa_standard_plugin_create( - &sequencer_desc, num_signals, sizeof(sequencer_data_t), table_size); + uint32_t num_signals = num_tracks + SEQUENCER_NUM_SIGNALS; //one for each channel output + radspa_t * sequencer = radspa_standard_plugin_create(&sequencer_desc, num_signals, sizeof(sequencer_data_t), table_size); sequencer->render = sequencer_run; - sequencer_data_t* data = sequencer->plugin_data; + sequencer_data_t * data = sequencer->plugin_data; data->track_step_len = num_pixels; data->num_tracks = num_tracks; data->bpm_prev = 120; data->beat_div_prev = 16; - 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_STEP_LEN, "step_len", - RADSPA_SIGNAL_HINT_INPUT, num_pixels); - 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_BPM, "bpm", RADSPA_SIGNAL_HINT_INPUT, - data->bpm_prev); - radspa_signal_set(sequencer, SEQUENCER_BEAT_DIV, "beat_div", - RADSPA_SIGNAL_HINT_INPUT, data->beat_div_prev); - radspa_signal_set(sequencer, SEQUENCER_OUTPUT, "output", - RADSPA_SIGNAL_HINT_OUTPUT, 0); + 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_STEP_LEN, "step_len", RADSPA_SIGNAL_HINT_INPUT, num_pixels); + 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_BPM, "bpm", RADSPA_SIGNAL_HINT_INPUT, data->bpm_prev); + radspa_signal_set(sequencer, SEQUENCER_BEAT_DIV, "beat_div", RADSPA_SIGNAL_HINT_INPUT, data->beat_div_prev); + radspa_signal_set(sequencer, SEQUENCER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); /* for(uint8_t i = 0; i < num_signals; i++){ - radspa_signal_set(sequencer, SEQUENCER_NUM_SIGNALS + i, "track", - RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(sequencer, SEQUENCER_NUM_SIGNALS + i, "track", RADSPA_SIGNAL_HINT_OUTPUT, 0); } */ @@ -71,6 +60,7 @@ radspa_t* sequencer_create(uint32_t init_var) { data->sync_in_prev = 0; data->sync_out = 32767; + return sequencer; } @@ -78,90 +68,70 @@ radspa_t* sequencer_create(uint32_t init_var) { * first int16_t: track type: * -32767 : trigger track * 32767 : direct track - * in between: slew rate + * in between: slew rate */ -void sequencer_run(radspa_t* sequencer, uint16_t num_samples, - uint32_t render_pass_id) { - radspa_signal_t* step_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_STEP); - radspa_signal_t* sync_out_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_OUT); - radspa_signal_t* output_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_OUTPUT); - if ((output_sig->buffer == NULL) && (sync_out_sig->buffer == NULL) && - (step_sig->buffer == NULL)) - return; - - radspa_signal_t* step_len_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_STEP_LEN); - radspa_signal_t* sync_in_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_IN); - radspa_signal_t* bpm_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_BPM); - radspa_signal_t* beat_div_sig = - radspa_signal_get_by_index(sequencer, SEQUENCER_BEAT_DIV); - sequencer_data_t* data = sequencer->plugin_data; - int16_t* table = sequencer->plugin_table; - - int16_t s1 = - radspa_signal_get_value(step_len_sig, 0, num_samples, render_pass_id); +void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_pass_id){ + radspa_signal_t * step_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_STEP); + radspa_signal_t * sync_out_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_OUT); + radspa_signal_t * output_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_OUTPUT); + if((output_sig->buffer == NULL) && (sync_out_sig->buffer == NULL) && (step_sig->buffer == NULL)) return; + + radspa_signal_t * step_len_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_STEP_LEN); + radspa_signal_t * sync_in_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_IN); + radspa_signal_t * bpm_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_BPM); + radspa_signal_t * beat_div_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_BEAT_DIV); + sequencer_data_t * data = sequencer->plugin_data; + int16_t * table = sequencer->plugin_table; + + int16_t s1 = radspa_signal_get_value(step_len_sig, 0, num_samples, render_pass_id); int16_t s2 = data->track_step_len; data->step_target = s1 > 0 ? (s1 > s2 ? s2 : s1) : 1; int16_t bpm = bpm_sig->get_value(bpm_sig, 0, num_samples, render_pass_id); - int16_t beat_div = - beat_div_sig->get_value(beat_div_sig, 0, num_samples, render_pass_id); - if ((bpm != data->bpm_prev) || (beat_div != data->beat_div_prev)) { + int16_t beat_div = beat_div_sig->get_value(beat_div_sig, 0, num_samples, render_pass_id); + if((bpm != data->bpm_prev) || (beat_div != data->beat_div_prev)){ data->counter_target = target(data->track_step_len, bpm, beat_div); data->bpm_prev = bpm; data->beat_div_prev = beat_div; } + + for(uint16_t i = 0; i < num_samples; i++){ - for (uint16_t i = 0; i < num_samples; i++) { data->counter++; - if (data->counter >= data->counter_target) { + if(data->counter >= data->counter_target){ data->counter = 0; data->step++; - if (data->step >= data->step_target) { + if(data->step >= data->step_target){ data->step = 0; data->sync_out = -data->sync_out; } } - int16_t sync_in = - sync_in_sig->get_value(sync_in_sig, i, num_samples, render_pass_id); - if (((sync_in > 0) && (data->sync_in_prev <= 0)) || - ((sync_in > 0) && (data->sync_in_prev <= 0))) { + int16_t sync_in = sync_in_sig->get_value(sync_in_sig, i, num_samples, render_pass_id); + if(((sync_in > 0) && (data->sync_in_prev <= 0)) || ((sync_in > 0) && (data->sync_in_prev <= 0))){ data->counter = 0; data->step = 0; data->sync_out = -data->sync_out; } data->sync_in_prev = sync_in; - - if (!data->counter) { // event just happened - for (uint8_t track = 0; track < data->num_tracks; track++) { - int16_t type = table[track * data->track_step_len]; - int16_t stage_val = - table[data->step + 1 + data->track_step_len * track]; - if (type == 32767) { + + if(!data->counter){ //event just happened + for(uint8_t track = 0; track < data->num_tracks; track++){ + int16_t type = table[track*data->track_step_len]; + int16_t stage_val = table[data->step + 1 + data->track_step_len * track]; + if(type == 32767){ data->track_fill[track] = stage_val; - } else if (type == -32767) { - if (stage_val > 0) - data->track_fill[track] = radspa_trigger_start( - stage_val, &(data->trigger_hist[track])); - if (stage_val < 0) - data->track_fill[track] = - radspa_trigger_stop(&(data->trigger_hist[track])); + } else if(type == -32767){ + if(stage_val > 0) data->track_fill[track] = radspa_trigger_start(stage_val, &(data->trigger_hist[track])); + if(stage_val < 0) data->track_fill[track] = radspa_trigger_stop(&(data->trigger_hist[track])); } } } - - if (output_sig->buffer != NULL) - (output_sig->buffer)[i] = data->track_fill[0]; - if (sync_out_sig->buffer != NULL) - (sync_out_sig->buffer)[i] = data->sync_out; - if (step_sig->buffer != NULL) (step_sig->buffer)[i] = data->step; + + if(output_sig->buffer != NULL) (output_sig->buffer)[i] = data->track_fill[0]; + if(sync_out_sig->buffer != NULL) (sync_out_sig->buffer)[i] = data->sync_out; + if(step_sig->buffer != NULL) (step_sig->buffer)[i] = data->step; } sync_out_sig->value = data->sync_out; output_sig->value = data->track_fill[0]; diff --git a/components/bl00mbox/plugins/sequencer.h b/components/bl00mbox/plugins/sequencer.h index f59a3c092c7c71344c3b32c0cde92bdf4f134575..a6b5748af15ae359ca111fc08feea3a9403792b8 100644 --- a/components/bl00mbox/plugins/sequencer.h +++ b/components/bl00mbox/plugins/sequencer.h @@ -19,6 +19,5 @@ typedef struct { } sequencer_data_t; extern radspa_descriptor_t sequencer_desc; -radspa_t* sequencer_create(uint32_t init_var); -void sequencer_run(radspa_t* osc, uint16_t num_samples, - uint32_t render_pass_id); +radspa_t * sequencer_create(uint32_t init_var); +void sequencer_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); diff --git a/components/bl00mbox/plugins/trad_synth/trad_synth.c b/components/bl00mbox/plugins/trad_synth/trad_synth.c index d913f4567fc933723cb6c3c0a720d59643245493..aa1032bf854b5d41d8c11b2ab345d54ee737d6ef 100644 --- a/components/bl00mbox/plugins/trad_synth/trad_synth.c +++ b/components/bl00mbox/plugins/trad_synth/trad_synth.c @@ -19,109 +19,97 @@ radspa_descriptor_t trad_osc_desc = { #define TRAD_OSC_WAVEFORM 2 #define TRAD_OSC_LIN_FM 3 -radspa_t* trad_osc_create(uint32_t init_var) { - radspa_t* trad_osc = radspa_standard_plugin_create( - &trad_osc_desc, TRAD_OSC_NUM_SIGNALS, sizeof(trad_osc_data_t), 0); +radspa_t * trad_osc_create(uint32_t init_var){ + radspa_t * trad_osc = radspa_standard_plugin_create(&trad_osc_desc, TRAD_OSC_NUM_SIGNALS, sizeof(trad_osc_data_t), 0); trad_osc->render = trad_osc_run; - radspa_signal_set(trad_osc, TRAD_OSC_OUTPUT, "output", - RADSPA_SIGNAL_HINT_OUTPUT, 0); - radspa_signal_set(trad_osc, TRAD_OSC_PITCH, "pitch", - RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_SCT, 18367); - radspa_signal_set(trad_osc, TRAD_OSC_WAVEFORM, "waveform", - RADSPA_SIGNAL_HINT_INPUT, -16000); - radspa_signal_set(trad_osc, TRAD_OSC_LIN_FM, "lin_fm", - RADSPA_SIGNAL_HINT_INPUT, 0); + radspa_signal_set(trad_osc, TRAD_OSC_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(trad_osc, TRAD_OSC_PITCH, "pitch", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_SCT, 18367); + radspa_signal_set(trad_osc, TRAD_OSC_WAVEFORM, "waveform", RADSPA_SIGNAL_HINT_INPUT, -16000); + radspa_signal_set(trad_osc, TRAD_OSC_LIN_FM, "lin_fm", RADSPA_SIGNAL_HINT_INPUT, 0); return trad_osc; } -void trad_osc_run(radspa_t* trad_osc, uint16_t num_samples, - uint32_t render_pass_id) { - trad_osc_data_t* plugin_data = trad_osc->plugin_data; - radspa_signal_t* output_sig = - radspa_signal_get_by_index(trad_osc, TRAD_OSC_OUTPUT); - radspa_signal_t* pitch_sig = - radspa_signal_get_by_index(trad_osc, TRAD_OSC_PITCH); - radspa_signal_t* waveform_sig = - radspa_signal_get_by_index(trad_osc, TRAD_OSC_WAVEFORM); - radspa_signal_t* lin_fm_sig = - radspa_signal_get_by_index(trad_osc, TRAD_OSC_LIN_FM); - if (output_sig->buffer == NULL) return; +void trad_osc_run(radspa_t * trad_osc, uint16_t num_samples, uint32_t render_pass_id){ + trad_osc_data_t * plugin_data = trad_osc->plugin_data; + radspa_signal_t * output_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_OUTPUT); + radspa_signal_t * pitch_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_PITCH); + radspa_signal_t * waveform_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_WAVEFORM); + radspa_signal_t * lin_fm_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_LIN_FM); + if(output_sig->buffer == NULL) return; int16_t ret = 0; - for (uint16_t i = 0; i < num_samples; i++) { - int16_t pitch = - pitch_sig->get_value(pitch_sig, i, num_samples, render_pass_id); - int16_t wave = waveform_sig->get_value(waveform_sig, i, num_samples, - render_pass_id); - int32_t lin_fm = - lin_fm_sig->get_value(lin_fm_sig, i, num_samples, render_pass_id); - - if (pitch != plugin_data->prev_pitch) { + for(uint16_t i = 0; i < num_samples; i++){ + int16_t pitch = pitch_sig->get_value(pitch_sig, i, num_samples, render_pass_id); + int16_t wave = waveform_sig->get_value(waveform_sig, i, num_samples, render_pass_id); + int32_t lin_fm = lin_fm_sig->get_value(lin_fm_sig, i, num_samples, render_pass_id); + + if(pitch != plugin_data->prev_pitch){ plugin_data->incr = radspa_sct_to_rel_freq(pitch, 0); plugin_data->prev_pitch = pitch; } plugin_data->counter += plugin_data->incr; - if (lin_fm) { + if(lin_fm){ plugin_data->counter += lin_fm * (plugin_data->incr >> 15); } int32_t tmp = (plugin_data->counter) >> 17; - tmp = (tmp * 2) - 32767; + tmp = (tmp*2) - 32767; ret = waveshaper(tmp, wave); (output_sig->buffer)[i] = ret; } output_sig->value = ret; } -static inline int16_t triangle(int16_t saw) { +static inline int16_t triangle(int16_t saw){ int32_t tmp = saw; tmp += 16384; - if (tmp > 32767) tmp -= 65535; - if (tmp > 0) tmp = -tmp; + if(tmp > 32767) tmp -= 65535; + if(tmp > 0) tmp = -tmp; tmp = (2 * tmp) + 32767; return tmp; } -inline int16_t waveshaper(int16_t saw, int16_t shape) { +inline int16_t waveshaper(int16_t saw, int16_t shape){ int32_t tmp = saw; - uint8_t sh = ((uint16_t)shape) >> 14; - sh = (sh + 2) % 4; - switch (sh) { - case 0: // sine + uint8_t sh = ((uint16_t) shape) >> 14; + sh = (sh + 2)%4; + switch(sh){ + case 0: //sine tmp = triangle(tmp); - if (tmp > 0) { + if(tmp > 0){ tmp = 32767 - tmp; - tmp = (tmp * tmp) >> 15; + tmp = (tmp*tmp)>>15; tmp = 32767. - tmp; } else { tmp = 32767 + tmp; - tmp = (tmp * tmp) >> 15; + tmp = (tmp*tmp)>>15; tmp = tmp - 32767.; } break; - case 1: // tri + case 1: //tri tmp = triangle(tmp); break; - case 2: // square: - if (tmp > 0) { + case 2: //square: + if(tmp > 0){ tmp = 32767; } else { tmp = -32767; } break; - default: // saw + default: //saw break; } return tmp; } // plugin: trad_env -radspa_descriptor_t trad_env_desc = { .name = "env_adsr", - .id = 42, - .description = "simple ADSR envelope", - .create_plugin_instance = trad_env_create, - .destroy_plugin_instance = - radspa_standard_plugin_destroy }; +radspa_descriptor_t trad_env_desc = { + .name = "env_adsr", + .id = 42, + .description = "simple ADSR envelope", + .create_plugin_instance = trad_env_create, + .destroy_plugin_instance = radspa_standard_plugin_destroy +}; #define TRAD_ENV_NUM_SIGNALS 9 #define TRAD_ENV_OUTPUT 0 @@ -140,77 +128,66 @@ radspa_descriptor_t trad_env_desc = { .name = "env_adsr", #define TRAD_ENV_PHASE_SUSTAIN 3 #define TRAD_ENV_PHASE_RELEASE 4 -radspa_t* trad_env_create(uint32_t init_var) { - radspa_t* trad_env = radspa_standard_plugin_create( - &trad_env_desc, TRAD_ENV_NUM_SIGNALS, sizeof(trad_env_data_t), 0); +radspa_t * trad_env_create(uint32_t init_var){ + radspa_t * trad_env = radspa_standard_plugin_create(&trad_env_desc, TRAD_ENV_NUM_SIGNALS, sizeof(trad_env_data_t),0); trad_env->render = trad_env_run; - radspa_signal_set(trad_env, TRAD_ENV_OUTPUT, "output", - RADSPA_SIGNAL_HINT_OUTPUT, 0); - radspa_signal_set(trad_env, TRAD_ENV_PHASE, "phase", - RADSPA_SIGNAL_HINT_OUTPUT, 0); - radspa_signal_set(trad_env, TRAD_ENV_INPUT, "input", - RADSPA_SIGNAL_HINT_INPUT, 32767); - radspa_signal_set(trad_env, TRAD_ENV_TRIGGER, "trigger", - RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0); - radspa_signal_set(trad_env, TRAD_ENV_ATTACK, "attack", - RADSPA_SIGNAL_HINT_INPUT, 100); - radspa_signal_set(trad_env, TRAD_ENV_DECAY, "decay", - RADSPA_SIGNAL_HINT_INPUT, 250); - radspa_signal_set(trad_env, TRAD_ENV_SUSTAIN, "sustain", - RADSPA_SIGNAL_HINT_INPUT, 16000); - radspa_signal_set(trad_env, TRAD_ENV_RELEASE, "release", - RADSPA_SIGNAL_HINT_INPUT, 50); - radspa_signal_set(trad_env, TRAD_ENV_GATE, "gate", RADSPA_SIGNAL_HINT_INPUT, - 0); + radspa_signal_set(trad_env, TRAD_ENV_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(trad_env, TRAD_ENV_PHASE, "phase", RADSPA_SIGNAL_HINT_OUTPUT, 0); + radspa_signal_set(trad_env, TRAD_ENV_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 32767); + radspa_signal_set(trad_env, TRAD_ENV_TRIGGER, "trigger", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0); + radspa_signal_set(trad_env, TRAD_ENV_ATTACK, "attack", RADSPA_SIGNAL_HINT_INPUT, 100); + radspa_signal_set(trad_env, TRAD_ENV_DECAY, "decay", RADSPA_SIGNAL_HINT_INPUT, 250); + radspa_signal_set(trad_env, TRAD_ENV_SUSTAIN, "sustain", RADSPA_SIGNAL_HINT_INPUT, 16000); + radspa_signal_set(trad_env, TRAD_ENV_RELEASE, "release", RADSPA_SIGNAL_HINT_INPUT, 50); + radspa_signal_set(trad_env, TRAD_ENV_GATE, "gate", RADSPA_SIGNAL_HINT_INPUT,0); radspa_signal_get_by_index(trad_env, TRAD_ENV_ATTACK)->unit = "ms"; radspa_signal_get_by_index(trad_env, TRAD_ENV_DECAY)->unit = "ms"; radspa_signal_get_by_index(trad_env, TRAD_ENV_SUSTAIN)->unit = "ms"; - trad_env_data_t* data = trad_env->plugin_data; + trad_env_data_t * data = trad_env->plugin_data; data->trigger_prev = 0; data->env_phase = TRAD_ENV_PHASE_OFF; return trad_env; } -static int16_t trad_env_run_single(trad_env_data_t* env) { +static int16_t trad_env_run_single(trad_env_data_t * env){ uint32_t tmp; - switch (env->env_phase) { + switch(env->env_phase){ case TRAD_ENV_PHASE_OFF: - env->env_counter = 0; - ; + env->env_counter = 0;; break; case TRAD_ENV_PHASE_ATTACK: tmp = env->env_counter + env->attack; - if (tmp < env->env_counter) { // overflow - tmp = ~((uint32_t)0); // max out + if(tmp < env->env_counter){ // overflow + tmp = ~((uint32_t) 0); // max out env->env_phase = TRAD_ENV_PHASE_DECAY; } env->env_counter = tmp; break; case TRAD_ENV_PHASE_DECAY: tmp = env->env_counter - env->decay; - if (tmp > env->env_counter) { // underflow - tmp = 0; // bottom out + if(tmp > env->env_counter){ // underflow + tmp = 0; //bottom out } env->env_counter = tmp; - if (env->env_counter <= env->sustain) { + if(env->env_counter <= env->sustain){ env->env_counter = env->sustain; env->env_phase = TRAD_ENV_PHASE_SUSTAIN; - } else if (env->env_counter < env->gate) { + } else if(env->env_counter < env->gate){ env->env_counter = 0; env->env_phase = TRAD_ENV_PHASE_OFF; } break; case TRAD_ENV_PHASE_SUSTAIN: - if (env->sustain == 0) env->env_phase = TRAD_ENV_PHASE_OFF; + if(env->sustain == 0) env->env_phase = TRAD_ENV_PHASE_OFF; env->env_counter = env->sustain; break; case TRAD_ENV_PHASE_RELEASE: tmp = env->env_counter - env->release; - if (tmp > env->env_counter) { // underflow - tmp = 0; // bottom out + if(tmp > env->env_counter){ // underflow + tmp = 0; //bottom out env->env_phase = TRAD_ENV_PHASE_OFF; } env->env_counter = tmp; @@ -228,152 +205,123 @@ static int16_t trad_env_run_single(trad_env_data_t* env) { #define SAMPLE_RATE_SORRY 48000 #define TRAD_ENV_UNDERSAMPLING 5 -static inline uint32_t trad_env_time_ms_to_val_rise(uint16_t time_ms, - uint32_t val) { - if (!time_ms) return UINT32_MAX; - uint32_t div = time_ms * ((SAMPLE_RATE_SORRY) / 1000); - return val / div; + +static inline uint32_t trad_env_time_ms_to_val_rise(uint16_t time_ms, uint32_t val){ + if(!time_ms) return UINT32_MAX; + uint32_t div = time_ms * ((SAMPLE_RATE_SORRY)/1000); + return val/div; } -static inline uint32_t uint32_sat_leftshift(uint32_t input, uint16_t left) { - if (!left) return input; // nothing to do - if (input >> (32 - left)) return UINT32_MAX; // sat +static inline uint32_t uint32_sat_leftshift(uint32_t input, uint16_t left){ + if(!left) return input; // nothing to do + if(input >> (32-left)) return UINT32_MAX; // sat return input << left; } -void trad_env_run(radspa_t* trad_env, uint16_t num_samples, - uint32_t render_pass_id) { - trad_env_data_t* plugin_data = trad_env->plugin_data; - radspa_signal_t* output_sig = - radspa_signal_get_by_index(trad_env, TRAD_ENV_OUTPUT); - radspa_signal_t* phase_sig = - radspa_signal_get_by_index(trad_env, TRAD_ENV_PHASE); - if ((output_sig->buffer == NULL) && (phase_sig->buffer == NULL)) return; - radspa_signal_t* trigger_sig = - radspa_signal_get_by_index(trad_env, TRAD_ENV_TRIGGER); - radspa_signal_t* input_sig = - radspa_signal_get_by_index(trad_env, TRAD_ENV_INPUT); - radspa_signal_t* attack_sig = NULL; - radspa_signal_t* decay_sig = NULL; - radspa_signal_t* sustain_sig = NULL; - radspa_signal_t* release_sig = NULL; - radspa_signal_t* gate_sig = NULL; + +void trad_env_run(radspa_t * trad_env, uint16_t num_samples, uint32_t render_pass_id){ + trad_env_data_t * plugin_data = trad_env->plugin_data; + radspa_signal_t * output_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_OUTPUT); + radspa_signal_t * phase_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_PHASE); + if((output_sig->buffer == NULL) && (phase_sig->buffer == NULL)) return; + radspa_signal_t * trigger_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_TRIGGER); + radspa_signal_t * input_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_INPUT); + radspa_signal_t * attack_sig = NULL; + radspa_signal_t * decay_sig = NULL; + radspa_signal_t * sustain_sig = NULL; + radspa_signal_t * release_sig = NULL; + radspa_signal_t * gate_sig = NULL; int16_t ret = output_sig->value; - for (uint16_t i = 0; i < num_samples; i++) { + for(uint16_t i = 0; i < num_samples; i++){ static int16_t env = 0; - int16_t trigger = - trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id); + 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 - if (plugin_data->env_phase != TRAD_ENV_PHASE_OFF) { + if(vel < 0){ // stop + if(plugin_data->env_phase != TRAD_ENV_PHASE_OFF){ plugin_data->env_phase = TRAD_ENV_PHASE_RELEASE; plugin_data->release_init_val = plugin_data->env_counter; } - } else if (vel > 0) { // start + } else if(vel > 0 ){ // start plugin_data->env_phase = TRAD_ENV_PHASE_ATTACK; - plugin_data->velocity = ((uint32_t)vel) << 17; + plugin_data->velocity = ((uint32_t) vel) << 17; } - if (!(i % (1 << TRAD_ENV_UNDERSAMPLING))) { + if(!(i%(1<<TRAD_ENV_UNDERSAMPLING))){ uint16_t time_ms; uint32_t sus; - switch (plugin_data->env_phase) { + switch(plugin_data->env_phase){ case TRAD_ENV_PHASE_OFF: break; case TRAD_ENV_PHASE_ATTACK: - if (attack_sig == NULL) { - attack_sig = radspa_signal_get_by_index( - trad_env, TRAD_ENV_ATTACK); + if(attack_sig == NULL){ + attack_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_ATTACK); } - time_ms = attack_sig->get_value(attack_sig, i, num_samples, - render_pass_id); - if (time_ms != plugin_data->attack_prev_ms) { - plugin_data->attack = uint32_sat_leftshift( - trad_env_time_ms_to_val_rise(time_ms, UINT32_MAX), - TRAD_ENV_UNDERSAMPLING); + time_ms = attack_sig->get_value(attack_sig, i, num_samples, render_pass_id); + if(time_ms != plugin_data->attack_prev_ms){ + plugin_data->attack = uint32_sat_leftshift(trad_env_time_ms_to_val_rise(time_ms, UINT32_MAX), TRAD_ENV_UNDERSAMPLING); plugin_data->attack_prev_ms = time_ms; } break; case TRAD_ENV_PHASE_DECAY: - if (sustain_sig == NULL) { - sustain_sig = radspa_signal_get_by_index( - trad_env, TRAD_ENV_SUSTAIN); + if(sustain_sig == NULL){ + sustain_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_SUSTAIN); } - sus = sustain_sig->get_value(sustain_sig, i, num_samples, - render_pass_id); - plugin_data->sustain = sus << 17; + sus = sustain_sig->get_value(sustain_sig, i, num_samples, render_pass_id); + plugin_data->sustain = sus<<17; - if (gate_sig == NULL) { - gate_sig = - radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE); + if(gate_sig == NULL){ + gate_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE); } - sus = gate_sig->get_value(gate_sig, i, num_samples, - render_pass_id); - plugin_data->gate = sus << 17; + sus = gate_sig->get_value(gate_sig, i, num_samples, render_pass_id); + plugin_data->gate = sus<<17; - if (decay_sig == NULL) { - decay_sig = radspa_signal_get_by_index(trad_env, - TRAD_ENV_DECAY); + if(decay_sig == NULL){ + decay_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_DECAY); } - time_ms = decay_sig->get_value(decay_sig, i, num_samples, - render_pass_id); - if (time_ms != plugin_data->decay_prev_ms) { - plugin_data->decay = uint32_sat_leftshift( - trad_env_time_ms_to_val_rise( - time_ms, UINT32_MAX - plugin_data->sustain), - TRAD_ENV_UNDERSAMPLING); + time_ms = decay_sig->get_value(decay_sig, i, num_samples, render_pass_id); + if(time_ms != plugin_data->decay_prev_ms){ + plugin_data->decay = uint32_sat_leftshift(trad_env_time_ms_to_val_rise(time_ms, UINT32_MAX-plugin_data->sustain), TRAD_ENV_UNDERSAMPLING); plugin_data->decay_prev_ms = time_ms; } break; case TRAD_ENV_PHASE_SUSTAIN: - if (sustain_sig == NULL) { - sustain_sig = radspa_signal_get_by_index( - trad_env, TRAD_ENV_SUSTAIN); + if(sustain_sig == NULL){ + sustain_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_SUSTAIN); } - sus = sustain_sig->get_value(sustain_sig, i, num_samples, - render_pass_id); - plugin_data->sustain = sus << 17; + sus = sustain_sig->get_value(sustain_sig, i, num_samples, render_pass_id); + plugin_data->sustain = sus<<17; break; case TRAD_ENV_PHASE_RELEASE: - if (gate_sig == NULL) { - gate_sig = - radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE); + if(gate_sig == NULL){ + gate_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE); } - sus = gate_sig->get_value(gate_sig, i, num_samples, - render_pass_id); - plugin_data->gate = sus << 17; + sus = gate_sig->get_value(gate_sig, i, num_samples, render_pass_id); + plugin_data->gate = sus<<17; - if (release_sig == NULL) { - release_sig = radspa_signal_get_by_index( - trad_env, TRAD_ENV_RELEASE); + if(release_sig == NULL){ + release_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_RELEASE); } - time_ms = release_sig->get_value( - release_sig, i, num_samples, render_pass_id); - if (time_ms != plugin_data->release_prev_ms) { - plugin_data->release = uint32_sat_leftshift( - trad_env_time_ms_to_val_rise( - time_ms, plugin_data->release_init_val), - TRAD_ENV_UNDERSAMPLING); + time_ms = release_sig->get_value(release_sig, i, num_samples, render_pass_id); + if(time_ms != plugin_data->release_prev_ms){ + plugin_data->release = uint32_sat_leftshift(trad_env_time_ms_to_val_rise(time_ms, plugin_data->release_init_val), TRAD_ENV_UNDERSAMPLING); plugin_data->release_prev_ms = time_ms; } break; } env = trad_env_run_single(plugin_data); } - if (env) { - int16_t input = - input_sig->get_value(input_sig, i, num_samples, render_pass_id); + if(env){ + int16_t input = input_sig->get_value(input_sig, i, num_samples, render_pass_id); ret = radspa_mult_shift(env, input); } else { ret = 0; } - if (phase_sig->buffer != NULL) - (phase_sig->buffer)[i] = plugin_data->env_phase; - if (output_sig->buffer != NULL) (output_sig->buffer)[i] = ret; + if(phase_sig->buffer != NULL) (phase_sig->buffer)[i] = plugin_data->env_phase; + if(output_sig->buffer != NULL) (output_sig->buffer)[i] = ret; } phase_sig->value = plugin_data->env_phase; output_sig->value = ret; diff --git a/components/bl00mbox/plugins/trad_synth/trad_synth.h b/components/bl00mbox/plugins/trad_synth/trad_synth.h index bb144d0faa01e39a4b67b891effff8f3112ce561..e186cc7d35560c6d89d2c77312944f94b0079730 100644 --- a/components/bl00mbox/plugins/trad_synth/trad_synth.h +++ b/components/bl00mbox/plugins/trad_synth/trad_synth.h @@ -3,13 +3,11 @@ #include "radspa.h" #include "radspa_helpers.h" -/* provides traditional synthesizer functionality distributed over several - * plugins. +/* provides traditional synthesizer functionality distributed over several plugins. */ /* plugin: trad_osc - * oscillator that can generate sine, square, saw and triangle waves in the - * audio band. uses trad_wave. + * oscillator that can generate sine, square, saw and triangle waves in the audio band. uses trad_wave. */ typedef struct { @@ -19,26 +17,27 @@ typedef struct { } trad_osc_data_t; extern radspa_descriptor_t trad_osc_desc; -radspa_t* trad_osc_create(uint32_t init_var); -void trad_osc_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id); +radspa_t * trad_osc_create(uint32_t init_var); +void trad_osc_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); typedef struct { - uint32_t env_counter; - uint32_t attack; - uint32_t decay; - uint32_t sustain; - uint32_t release; - uint32_t release_init_val; - uint16_t attack_prev_ms; - uint16_t decay_prev_ms; - uint16_t release_prev_ms; - uint32_t gate; - uint32_t velocity; - uint8_t env_phase; - uint8_t skip_hold; - int16_t trigger_prev; + uint32_t env_counter; + uint32_t attack; + uint32_t decay; + uint32_t sustain; + uint32_t release; + uint32_t release_init_val; + uint16_t attack_prev_ms; + uint16_t decay_prev_ms; + uint16_t release_prev_ms; + uint32_t gate; + uint32_t velocity; + uint8_t env_phase; + uint8_t skip_hold; + int16_t trigger_prev; } trad_env_data_t; extern radspa_descriptor_t trad_env_desc; -radspa_t* trad_env_create(uint32_t init_var); -void trad_env_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id); +radspa_t * trad_env_create(uint32_t init_var); +void trad_env_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id); + diff --git a/components/bl00mbox/radspa/radspa.h b/components/bl00mbox/radspa/radspa.h index 759238c1843dc11553810cfe759d6e0d8c5eb2b0..8093a71d98cecd8d4238e9676c42fadb9302a09d 100644 --- a/components/bl00mbox/radspa/radspa.h +++ b/components/bl00mbox/radspa/radspa.h @@ -1,30 +1,29 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 // Version 0.1.0 /* Realtime Audio Developer's Simple Plugin Api * - * Written from scratch but largely inspired by faint memories of the excellent - * ladspa.h For a simple plugin implementation example check ampliverter.c/.h :D + * Written from scratch but largely inspired by faint memories of the excellent ladspa.h + * For a simple plugin implementation example check ampliverter.c/.h :D */ #pragma once +#include <string.h> #include <stdbool.h> #include <stdint.h> -#include <string.h> /* CONVENTIONS * * All plugins communicate all signals in int16_t data. * - * SCT (semi-cent, 2/ct) is a mapping between int16_t pitch values and frequency - * values comparable to 1V/oct. in analog music electronics. A cent is a common - * unit in music theory and describes 1/100 of a semitone or 1/1200 of an - * octave. Typically 1 cent is precise enough for synth applications, however - * 1/2 cent is better and allows for a 27 octave range. INT16_MAX represents a - * frequency of 28160Hz, 6 octaves above middle A (440Hz) which is represented - * by INT16_MAX - 6 * 2400. + * SCT (semi-cent, 2/ct) is a mapping between int16_t pitch values and frequency values comparable + * to 1V/oct. in analog music electronics. A cent is a common unit in music theory and describes + * 1/100 of a semitone or 1/1200 of an octave. Typically 1 cent is precise enough for synth + * applications, however 1/2 cent is better and allows for a 27 octave range. INT16_MAX + * represents a frequency of 28160Hz, 6 octaves above middle A (440Hz) which is represented by + * INT16_MAX - 6 * 2400. */ // signal hints @@ -39,70 +38,64 @@ struct _radspa_descriptor_t; struct _radspa_signal_t; struct _radspa_t; -typedef struct _radspa_descriptor_t { - char* name; - uint32_t id; // unique id number - char* description; - struct _radspa_t* (*create_plugin_instance)(uint32_t init_var); - void (*destroy_plugin_instance)( - struct _radspa_t* plugin); // point to radspa_t +typedef struct _radspa_descriptor_t{ + char * name; + uint32_t id; // unique id number + char * description; + struct _radspa_t * (* create_plugin_instance)(uint32_t init_var); + void (* destroy_plugin_instance)(struct _radspa_t * plugin); // point to radspa_t } radspa_descriptor_t; -typedef struct _radspa_signal_t { +typedef struct _radspa_signal_t{ uint32_t hints; - char* name; - char* description; - char* unit; + char * name; + char * description; + char * unit; int8_t name_multiplex; - int16_t* buffer; // full buffer of num_samples. may be NULL. + int16_t * buffer; // full buffer of num_samples. may be NULL. // used for input channels only - int16_t value; // static value, should be used if buffer is NULL. + int16_t value; //static value, should be used if buffer is NULL. uint32_t render_pass_id; // function to retrieve value. radspa_helpers provides an example. - int16_t (*get_value)(struct _radspa_signal_t* sig, int16_t index, - uint16_t num_samples, uint32_t render_pass_id); + int16_t (* get_value)(struct _radspa_signal_t * sig, int16_t index, uint16_t num_samples, uint32_t render_pass_id); - struct _radspa_signal_t* next; // signals are in a linked list + struct _radspa_signal_t * next; //signals are in a linked list } radspa_signal_t; -typedef struct _radspa_t { - const radspa_descriptor_t* descriptor; +typedef struct _radspa_t{ + const radspa_descriptor_t * descriptor; // linked list of all i/o signals of the module and length of list - radspa_signal_t* signals; + radspa_signal_t * signals; uint8_t len_signals; - + // renders all signal outputs for num_samples if render_pass_id has changed // since the last call, else does nothing. - void (*render)(struct _radspa_t* plugin, uint16_t num_samples, - uint32_t render_pass_id); + void (* render)(struct _radspa_t * plugin, uint16_t num_samples, uint32_t render_pass_id); // stores id number of render pass. uint32_t render_pass_id; - void* plugin_data; // internal data for the plugin to use. should not be - // accessed from outside. + + void * plugin_data; // internal data for the plugin to use. should not be accessed from outside. uint32_t plugin_table_len; - int16_t* plugin_table; + int16_t * plugin_table; } radspa_t; /* REQUIREMENTS * Hosts must provide implementations for the following functions: */ -/* The return value should equal frequency(sct) * UINT32_MAX / - * (sample_rate>>undersample_pow) with: frequency(sct) = pow(2, (sct + - * 2708)/2400) - * /!\ Performance critical, might be called on a per-sample basis, do _not_ - * just use pow()! +/* The return value should equal frequency(sct) * UINT32_MAX / (sample_rate>>undersample_pow) with: + * frequency(sct) = pow(2, (sct + 2708)/2400) + * /!\ Performance critical, might be called on a per-sample basis, do _not_ just use pow()! */ extern uint32_t radspa_sct_to_rel_freq(int16_t sct, int16_t undersample_pow); // Return 1 if the buffer wasn't rendered already, 0 otherwise. -extern bool radspa_host_request_buffer_render(int16_t* buf, - uint16_t num_samples); +extern bool radspa_host_request_buffer_render(int16_t * buf, uint16_t num_samples); // limit a to -32767..32767 extern int16_t radspa_clip(int32_t a); @@ -111,6 +104,6 @@ extern int16_t radspa_add_sat(int32_t a, int32_t b); // (a*b)>>15 extern int16_t radspa_mult_shift(int32_t a, int32_t b); -extern int16_t radspa_trigger_start(int16_t velocity, int16_t* hist); -extern int16_t radspa_trigger_stop(int16_t* hist); -extern int16_t radspa_trigger_get(int16_t trigger_signal, int16_t* hist); +extern int16_t radspa_trigger_start(int16_t velocity, int16_t * hist); +extern int16_t radspa_trigger_stop(int16_t * hist); +extern int16_t radspa_trigger_get(int16_t trigger_signal, int16_t * hist); diff --git a/components/bl00mbox/radspa/radspa_helpers.c b/components/bl00mbox/radspa/radspa_helpers.c index 66848db4e712e5e924b1c785a64c18f4c790c92f..a557e51b831cdbf94362a2bffdc3cbcbed8fbe0e 100644 --- a/components/bl00mbox/radspa/radspa_helpers.c +++ b/components/bl00mbox/radspa/radspa_helpers.c @@ -1,29 +1,26 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #include "radspa_helpers.h" -radspa_signal_t* radspa_signal_get_by_index(radspa_t* plugin, - uint16_t signal_index) { - radspa_signal_t* ret = plugin->signals; - for (uint16_t i = 0; i < signal_index; i++) { +radspa_signal_t * radspa_signal_get_by_index(radspa_t * plugin, uint16_t signal_index){ + radspa_signal_t * ret = plugin->signals; + for(uint16_t i = 0; i < signal_index; i++){ ret = ret->next; - if (ret == NULL) break; + if(ret == NULL) break; } return ret; } -void radspa_signal_set(radspa_t* plugin, uint8_t signal_index, char* name, - uint32_t hints, int16_t value) { - radspa_signal_t* sig = radspa_signal_get_by_index(plugin, signal_index); - if (sig == NULL) return; +void radspa_signal_set(radspa_t * plugin, uint8_t signal_index, char * name, uint32_t hints, int16_t value){ + radspa_signal_t * sig = radspa_signal_get_by_index(plugin, signal_index); + if(sig == NULL) return; sig->name = name; sig->hints = hints; sig->value = value; } -int16_t radspa_signal_add(radspa_t* plugin, char* name, uint32_t hints, - int16_t value) { - radspa_signal_t* sig = calloc(1, sizeof(radspa_signal_t)); - if (sig == NULL) return -1; // allocation failed +int16_t radspa_signal_add(radspa_t * plugin, char * name, uint32_t hints, int16_t value){ + radspa_signal_t * sig = calloc(1,sizeof(radspa_signal_t)); + if(sig == NULL) return -1; // allocation failed sig->name = name; sig->hints = hints; sig->unit = ""; @@ -33,33 +30,29 @@ int16_t radspa_signal_add(radspa_t* plugin, char* name, uint32_t hints, sig->value = value; sig->name_multiplex = -1; sig->get_value = radspa_signal_get_value; - - // find end of linked list + + //find end of linked list uint16_t list_index = 0; - if (plugin->signals == NULL) { + if(plugin->signals == NULL){ plugin->signals = sig; } else { - radspa_signal_t* sigs = plugin->signals; + radspa_signal_t * sigs = plugin->signals; list_index++; - while (sigs->next != NULL) { + while(sigs->next != NULL){ sigs = sigs->next; list_index++; } sigs->next = sig; } - if (plugin->len_signals != list_index) { - abort(); - } + if(plugin->len_signals != list_index){ abort(); } plugin->len_signals++; return list_index; } -int16_t radspa_signal_get_value(radspa_signal_t* sig, int16_t index, - uint16_t num_samples, uint32_t render_pass_id) { - if (sig->buffer != NULL) { - if (sig->render_pass_id != render_pass_id) { - radspa_host_request_buffer_render( - sig->buffer, num_samples); //, render_pass_id); +int16_t radspa_signal_get_value(radspa_signal_t * sig, int16_t index, uint16_t num_samples, uint32_t render_pass_id){ + if(sig->buffer != NULL){ + if(sig->render_pass_id != render_pass_id){ + radspa_host_request_buffer_render(sig->buffer, num_samples); //, render_pass_id); sig->render_pass_id = render_pass_id; } return sig->buffer[index]; @@ -67,15 +60,12 @@ int16_t radspa_signal_get_value(radspa_signal_t* sig, int16_t index, return sig->value; } -radspa_t* radspa_standard_plugin_create(radspa_descriptor_t* desc, - uint8_t num_signals, - size_t plugin_data_size, - uint32_t plugin_table_size) { - radspa_t* ret = calloc(1, sizeof(radspa_t)); - if (ret == NULL) return NULL; - if (plugin_data_size) { - ret->plugin_data = calloc(1, plugin_data_size); - if (ret->plugin_data == NULL) { +radspa_t * radspa_standard_plugin_create(radspa_descriptor_t * desc, uint8_t num_signals, size_t plugin_data_size, uint32_t plugin_table_size){ + radspa_t * ret = calloc(1, sizeof(radspa_t)); + if(ret == NULL) return NULL; + if(plugin_data_size){ + ret->plugin_data = calloc(1,plugin_data_size); + if(ret->plugin_data == NULL){ free(ret); return NULL; } @@ -87,35 +77,35 @@ radspa_t* radspa_standard_plugin_create(radspa_descriptor_t* desc, ret->plugin_table_len = plugin_table_size; bool init_failed = false; - for (uint8_t i = 0; i < num_signals; i++) { - if (radspa_signal_add(ret, "UNINITIALIZED", 0, 0) == -1) { + for(uint8_t i = 0; i < num_signals; i++){ + if(radspa_signal_add(ret,"UNINITIALIZED",0,0) == -1){ init_failed = true; break; } } - if (ret->plugin_table_len) { + if(ret->plugin_table_len){ ret->plugin_table = calloc(plugin_table_size, sizeof(int16_t)); - if (ret->plugin_table == NULL) init_failed = true; + if(ret->plugin_table == NULL) init_failed = true; } else { ret->plugin_table = NULL; } - if (init_failed) { + if(init_failed){ radspa_standard_plugin_destroy(ret); return NULL; } return ret; } -void radspa_standard_plugin_destroy(radspa_t* plugin) { - radspa_signal_t* sig = plugin->signals; - while (sig != NULL) { - radspa_signal_t* sig_next = sig->next; +void radspa_standard_plugin_destroy(radspa_t * plugin){ + radspa_signal_t * sig = plugin->signals; + while(sig != NULL){ + radspa_signal_t * sig_next = sig->next; free(sig); sig = sig_next; } - if (plugin->plugin_table != NULL) free(plugin->plugin_table); - if (plugin->plugin_data != NULL) free(plugin->plugin_data); + if(plugin->plugin_table != NULL) free(plugin->plugin_table); + if(plugin->plugin_data != NULL) free(plugin->plugin_data); free(plugin); } diff --git a/components/bl00mbox/radspa/radspa_helpers.h b/components/bl00mbox/radspa/radspa_helpers.h index 0db184684991dde91e0bd73dabf8f0d9446523d4..e1b9fa0eb852a38869384d6ee1161e7bb23a9557 100644 --- a/components/bl00mbox/radspa/radspa_helpers.h +++ b/components/bl00mbox/radspa/radspa_helpers.h @@ -1,31 +1,22 @@ -// SPDX-License-Identifier: CC0-1.0 +//SPDX-License-Identifier: CC0-1.0 #pragma once #include "radspa.h" -// adds signal to plugin instance struct. typically used to initiate a plugin -// instance. -int16_t radspa_signal_add(radspa_t* plugin, char* name, uint32_t hints, - int16_t value); -// as above, but sets parameters of an already existing signal with at list -// position signal_index -void radspa_signal_set(radspa_t* plugin, uint8_t signal_index, char* name, - uint32_t hints, int16_t value); +// adds signal to plugin instance struct. typically used to initiate a plugin instance. +int16_t radspa_signal_add(radspa_t * plugin, char * name, uint32_t hints, int16_t value); +// as above, but sets parameters of an already existing signal with at list position signal_index +void radspa_signal_set(radspa_t * plugin, uint8_t signal_index, char * name, uint32_t hints, int16_t value); // get signal struct from a signal index -radspa_signal_t* radspa_signal_get_by_index(radspa_t* plugin, - uint16_t signal_index); +radspa_signal_t * radspa_signal_get_by_index(radspa_t * plugin, uint16_t signal_index); -radspa_t* radspa_standard_plugin_create(radspa_descriptor_t* desc, - uint8_t num_signals, - size_t plugin_data_size, - uint32_t plugin_table_size); -void radspa_standard_plugin_destroy(radspa_t* plugin); +radspa_t * radspa_standard_plugin_create(radspa_descriptor_t * desc, uint8_t num_signals, size_t plugin_data_size, uint32_t plugin_table_size); +void radspa_standard_plugin_destroy(radspa_t * plugin); // frees all signal structs. typically used to destroy a plugin instance. -void radspa_signals_free(radspa_t* plugin); +void radspa_signals_free(radspa_t * plugin); /* returns the value that a signal has at a given moment in time. time is - * represented as the buffer index. requests rendering from host and requires - * implementation of radspa_host_request_buffer_render. + * represented as the buffer index. requests rendering from host and requires implementation + * of radspa_host_request_buffer_render. */ -int16_t radspa_signal_get_value(radspa_signal_t* sig, int16_t index, - uint16_t num_samples, uint32_t render_pass_id); +int16_t radspa_signal_get_value(radspa_signal_t * sig, int16_t index, uint16_t num_samples, uint32_t render_pass_id); diff --git a/tools/format.sh b/tools/format.sh index bbb3b711978d8d9d14619e8dfb92ed958357194c..72383cbe702db46e484c31f8d1fbea9b946a0061 100755 --- a/tools/format.sh +++ b/tools/format.sh @@ -17,6 +17,7 @@ find . \ -path './components/micropython/vendor' -o \ -path './components/tinyusb' -o \ -path './components/ctx' -o \ + -path './components/bl00mbox' -o \ -path './components/bmi270' -o \ -path './components/bmp581' -o \ -path './sim' \