Skip to content
Snippets Groups Projects
Commit 4b7f18c9 authored by moon2's avatar moon2 :speech_balloon: Committed by dx
Browse files

bl00mbox: restore original c formatting

parent 95d0b9a2
Branches
Tags
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
Showing
with 876 additions and 1111 deletions
components/bl00mbox/bl00mbox.c
+ 3
− 3
View file @ 4b7f18c9
//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(){
......
components/bl00mbox/bl00mbox_audio.c
+ 78
− 86
View file @ 4b7f18c9
......@@ -15,12 +15,9 @@ 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;
bl00mbox_channel_background_mute_override[channel_index] = enable;
......@@ -42,8 +39,8 @@ 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;
/// 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;
......@@ -52,8 +49,7 @@ bool bl00mbox_audio_waitfor_pointer_change(void** ptr, void* new_val) {
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;
}
}
......@@ -71,7 +67,9 @@ 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;
......@@ -142,11 +140,10 @@ void bl00mbox_audio_bud_render(bl00mbox_bud_t* bud, uint16_t num_samples) {
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) {
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
// only to pass flow3r ci, omit before compliling
if(render_pass_id == chan->render_pass_id) return;
}
......@@ -160,7 +157,7 @@ static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan,
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;
......@@ -172,9 +169,7 @@ static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan,
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];
}
}
......@@ -184,8 +179,7 @@ static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan,
for(uint16_t i = 0; i < len; i++){
if(adding){
out[i] =
radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]);
out[i] = radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]);
} else {
out[i] = radspa_mult_shift(acc[i], chan->volume);
}
......@@ -212,10 +206,8 @@ void bl00mbox_audio_render(int16_t* rx, int16_t* tx, uint16_t 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
......
components/bl00mbox/bl00mbox_plugin_registry.c
+ 35
− 43
View file @ 4b7f18c9
......@@ -13,10 +13,7 @@ static void plugin_add(radspa_descriptor_t* descriptor) {
// 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();
}
if(p == NULL){ printf("bl00mbox: no memory for plugin list"); abort(); }
p->descriptor = descriptor;
p->next = NULL;
......@@ -25,9 +22,7 @@ static void plugin_add(radspa_descriptor_t* descriptor) {
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++;
......@@ -37,8 +32,7 @@ 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;
......@@ -50,8 +44,7 @@ radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_id(
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;
......@@ -66,8 +59,7 @@ 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;
......@@ -95,13 +87,13 @@ 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 "sequencer.h"
#include "sampler.h"
void bl00mbox_plugin_registry_init(void){
if(bl00mbox_plugin_registry_is_initialized) return;
plugin_add(&trad_osc_desc);
......
components/bl00mbox/bl00mbox_radspa_requirements.c
+ 49
− 48
View file @ 4b7f18c9
......@@ -10,35 +10,38 @@ 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
/// 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.
// 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;
......@@ -65,9 +68,7 @@ int16_t radspa_clip(int32_t 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_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;
......
components/bl00mbox/bl00mbox_user.c
+ 386
− 485
View file @ 4b7f18c9
This diff is collapsed.
components/bl00mbox/include/bl00mbox.h
+ 3
− 3
View file @ 4b7f18c9
components/bl00mbox/include/bl00mbox_audio.h
+ 32
− 39
View file @ 4b7f18c9
......@@ -11,8 +11,8 @@
#include "st3m_audio.h"
#include "st3m_scope.h"
#include <math.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "radspa.h"
......@@ -24,8 +24,7 @@ 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
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;
......@@ -39,14 +38,12 @@ typedef struct _bl00mbox_connection_subscriber_t {
} 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!
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{
......@@ -58,13 +55,10 @@ 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_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_connection_t * connections; // linked list with all channel connections
} bl00mbox_channel_t;
bl00mbox_channel_t * bl00mbox_get_channel(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);
components/bl00mbox/include/bl00mbox_plugin_registry.h
+ 8
− 9
View file @ 4b7f18c9
//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;
} 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);
components/bl00mbox/include/bl00mbox_radspa_requirements.h
+ 2
− 1
View file @ 4b7f18c9
......@@ -3,3 +3,4 @@
#include "bl00mbox_audio.h"
#include "radspa.h"
#include "radspa_helpers.h"
components/bl00mbox/include/bl00mbox_user.h
+ 33
− 65
View file @ 4b7f18c9
//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);
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);
components/bl00mbox/plugins/ampliverter.c
+ 40
− 54
View file @ 4b7f18c9
......@@ -8,10 +8,10 @@ radspa_descriptor_t ampliverter_desc = {
.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,45 +21,37 @@ 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);
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);
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);
// 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;
}
......@@ -67,27 +59,21 @@ void ampliverter_run(radspa_t* ampliverter, uint16_t num_samples,
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(
&ampliverter_desc, AMPLIVERTER_NUM_SIGNALS, sizeof(char), 0);
// 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(&ampliverter_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;
}
components/bl00mbox/plugins/ampliverter.h
+ 3
− 3
View file @ 4b7f18c9
......@@ -4,5 +4,5 @@
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);
void ampliverter_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
components/bl00mbox/plugins/brok3n/filter.c
+ 64
− 74
View file @ 4b7f18c9
#include "filter.h"
radspa_t * filter_create(uint32_t init_var);
radspa_descriptor_t filter_desc = { .name = "filter",
radspa_descriptor_t filter_desc = {
.name = "filter",
.id = 69420,
.description = "simple filter",
.create_plugin_instance = filter_create,
.destroy_plugin_instance =
radspa_standard_plugin_destroy };
.destroy_plugin_instance = radspa_standard_plugin_destroy
};
#define FILTER_NUM_SIGNALS 5
#define FILTER_OUTPUT 0
......@@ -15,6 +16,7 @@ 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){
data->pos++;
if(data->pos >= 3) data->pos = 0;
......@@ -94,14 +96,11 @@ static void set_filter_coeffs(filter_data_t* data, float freq, float q) {
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);
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 * 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);
......@@ -109,14 +108,10 @@ void filter_run(radspa_t* filter, uint16_t num_samples,
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);
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.);
......@@ -131,19 +126,14 @@ void filter_run(radspa_t* filter, uint16_t num_samples,
}
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);
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);
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;
......
components/bl00mbox/plugins/brok3n/filter.h
+ 2
− 2
View file @ 4b7f18c9
components/bl00mbox/plugins/delay.c
+ 43
− 64
View file @ 4b7f18c9
......@@ -19,66 +19,51 @@ radspa_descriptor_t delay_desc = {
#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);
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 * 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);
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);
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 %
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->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 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));
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;
}
......@@ -88,24 +73,18 @@ void delay_run(radspa_t* delay, uint16_t num_samples, uint32_t render_pass_id) {
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 = 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;
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;
}
components/bl00mbox/plugins/delay.h
+ 3
− 2
View file @ 4b7f18c9
......@@ -12,3 +12,4 @@ typedef struct {
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);
components/bl00mbox/plugins/sampler.c
+ 23
− 31
View file @ 4b7f18c9
......@@ -13,23 +13,20 @@ 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);
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);
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++){
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));
......@@ -41,8 +38,7 @@ void sampler_run(radspa_t* sampler, uint16_t num_samples,
}
if(data->read_head_position < buffer_size){
ret =
radspa_mult_shift(buf[data->read_head_position], data->volume);
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
......@@ -57,14 +53,10 @@ void sampler_run(radspa_t* sampler, uint16_t num_samples,
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);
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;
}
components/bl00mbox/plugins/sampler.h
+ 3
− 2
View file @ 4b7f18c9
......@@ -11,3 +11,4 @@ typedef struct {
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);
components/bl00mbox/plugins/sequencer.c
+ 64
− 94
View file @ 4b7f18c9
#include "sequencer.h"
radspa_descriptor_t sequencer_desc = { .name = "sequencer",
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 };
.create_plugin_instance = sequencer_create,
.destroy_plugin_instance = radspa_standard_plugin_destroy
};
#define SEQUENCER_NUM_SIGNALS 6
#define SEQUENCER_STEP 0
......@@ -32,10 +32,8 @@ radspa_t* sequencer_create(uint32_t init_var) {
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;
......@@ -43,27 +41,18 @@ radspa_t* sequencer_create(uint32_t init_var) {
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;
}
......@@ -81,37 +71,25 @@ radspa_t* sequencer_create(uint32_t init_var) {
* 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);
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 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);
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;
......@@ -119,6 +97,7 @@ void sequencer_run(radspa_t* sequencer, uint16_t num_samples,
}
for(uint16_t i = 0; i < num_samples; i++){
data->counter++;
if(data->counter >= data->counter_target){
data->counter = 0;
......@@ -129,10 +108,8 @@ void sequencer_run(radspa_t* sequencer, uint16_t num_samples,
}
}
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;
......@@ -142,25 +119,18 @@ void sequencer_run(radspa_t* sequencer, uint16_t num_samples,
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];
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]));
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(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;
......
components/bl00mbox/plugins/sequencer.h
+ 2
− 3
View file @ 4b7f18c9
......@@ -20,5 +20,4 @@ typedef struct {
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);
void sequencer_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment