boomjacky/looper
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

move engine to engine/

Browse Source
This commit is contained in:
Loic Coenen
2026-05-13 17:55:59 +00:00
parent 10d0269a5a
commit f3dde6b668
38 changed files with 3141 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
engine/src/channel.c Normal file
View File

@@ -0,0 +1,136 @@
// cppcheck-suppress missingIncludeSystem
#include "channel.h"
#include <jack/jack.h>
#include <stdatomic.h>
#include <stdio.h>
#include <string.h>
/* Helper: zero a scene and set its state to IDLE */
static void init_scene(scene_t *sc) {
memset(sc, 0, sizeof(scene_t));
atomic_store(&sc->state, STATE_IDLE);
atomic_store(&sc->prev_state, -1);
}
void channel_add(jack_client_t *client, int idx) {
struct channel_t *cur = get_channels_array();
char in_name[64], out_name[64];
snprintf(in_name, sizeof(in_name), "channel%d_input", next_channel_id);
snprintf(out_name, sizeof(out_name), "channel%d_output", next_channel_id);
cur[idx].audio_in = jack_port_register(
client, in_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
cur[idx].audio_out = jack_port_register(
client, out_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
if (!cur[idx].audio_in || !cur[idx].audio_out) {
fprintf(stderr, "Failed to register ports for channel %d\n",
next_channel_id);
atomic_store(&cur[idx].active, 0);
return;
}
atomic_store(&cur[idx].active, 1);
cur[idx].type = CHANNEL_AUDIO;
atomic_store(&cur[idx].scene_count, 1);
atomic_store(&cur[idx].current_scene, 0);
init_scene(&cur[idx].scenes[0]);
next_channel_id++;
atomic_fetch_add(&channel_count, 1);
}
void channel_add_midi(jack_client_t *client, int idx) {
struct channel_t *cur = get_channels_array();
char in_name[64], out_name[64];
snprintf(in_name, sizeof(in_name), "channel%d_midi_in", next_channel_id);
snprintf(out_name, sizeof(out_name), "channel%d_midi_out", next_channel_id);
cur[idx].midi_in = jack_port_register(client, in_name, JACK_DEFAULT_MIDI_TYPE,
JackPortIsInput, 0);
cur[idx].midi_out = jack_port_register(
client, out_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
if (!cur[idx].midi_in || !cur[idx].midi_out) {
fprintf(stderr, "Failed to register MIDI ports for channel %d\n",
next_channel_id);
atomic_store(&cur[idx].active, 0);
return;
}
atomic_store(&cur[idx].active, 1);
cur[idx].type = CHANNEL_MIDI;
atomic_store(&cur[idx].scene_count, 1);
atomic_store(&cur[idx].current_scene, 0);
init_scene(&cur[idx].scenes[0]);
next_channel_id++;
atomic_fetch_add(&channel_count, 1);
}
void channel_remove(jack_client_t *client, int idx) {
(void)client;
struct channel_t *cur = get_channels_array();
atomic_store(&cur[idx].active, 0);
atomic_fetch_sub(&channel_count, 1);
}
void channel_add_scene(jack_client_t *client, int idx) {
(void)client;
struct channel_t *cur = get_channels_array();
if (atomic_load(&cur[idx].scene_count) >= MAX_SCENES)
return;
int ns = atomic_load(&cur[idx].scene_count);
init_scene(&cur[idx].scenes[ns]);
atomic_fetch_add(&cur[idx].scene_count, 1);
}
void channel_remove_scene(jack_client_t *client, int idx) {
(void)client;
struct channel_t *cur = get_channels_array();
int sc = atomic_load(&cur[idx].scene_count);
if (sc <= 1)
return;
int cs = atomic_load(&cur[idx].current_scene);
/* shift remaining scenes down (atomic copy of fields) */
for (int i = cs; i < sc - 1; i++) {
atomic_store(&cur[idx].scenes[i].loop_count,
atomic_load(&cur[idx].scenes[i+1].loop_count));
atomic_store(&cur[idx].scenes[i].record_pos,
atomic_load(&cur[idx].scenes[i+1].record_pos));
atomic_store(&cur[idx].scenes[i].playback_pos,
atomic_load(&cur[idx].scenes[i+1].playback_pos));
atomic_store(&cur[idx].scenes[i].state,
atomic_load(&cur[idx].scenes[i+1].state));
atomic_store(&cur[idx].scenes[i].prev_state,
atomic_load(&cur[idx].scenes[i+1].prev_state));
/* copy loop data (may race with RT thread; acceptable for this release) */
memcpy(cur[idx].scenes[i].loop.audio_buffer,
cur[idx].scenes[i+1].loop.audio_buffer,
LOOP_BUF_SIZE * sizeof(float));
}
atomic_fetch_sub(&cur[idx].scene_count, 1);
int new_sc = atomic_load(&cur[idx].scene_count);
if (cs >= new_sc)
atomic_store(&cur[idx].current_scene, new_sc - 1);
}
void channel_next_scene(jack_client_t *client, int idx) {
(void)client;
struct channel_t *cur = get_channels_array();
int sc = atomic_load(&cur[idx].scene_count);
if (sc > 1) {
int cs = atomic_load(&cur[idx].current_scene);
atomic_store(&cur[idx].current_scene, (cs + 1) % sc);
}
}
void channel_prev_scene(jack_client_t *client, int idx) {
(void)client;
struct channel_t *cur = get_channels_array();
int sc = atomic_load(&cur[idx].scene_count);
if (sc > 1) {
int cs = atomic_load(&cur[idx].current_scene);
atomic_store(&cur[idx].current_scene, (cs - 1 + sc) % sc);
}
}

78
engine/src/channel.h Normal file
View File

@@ -0,0 +1,78 @@
#ifndef CHANNEL_H
#define CHANNEL_H
// cppcheck-suppress missingIncludeSystem
#include <jack/jack.h>
#include <stdatomic.h>
#define LOOP_BUF_SIZE (5 * 48000)
#define MAX_MIDI_EVENTS 1024
#define MAX_SCENES 16
typedef enum {
CHANNEL_AUDIO,
CHANNEL_MIDI
} channel_type_t;
typedef struct {
jack_nframes_t timestamp; /* frame offset relative to loop start */
unsigned char status;
unsigned char note;
unsigned char velocity;
} midi_event_t;
typedef enum {
STATE_IDLE,
STATE_RECORD,
STATE_LOOPING,
STATE_PAUSED
} looper_state;
typedef struct {
union {
float audio_buffer[LOOP_BUF_SIZE];
midi_event_t midi_events[MAX_MIDI_EVENTS];
} loop;
atomic_int loop_count;
atomic_int record_pos;
atomic_int playback_pos;
atomic_int state;
atomic_int prev_state;
} scene_t;
struct channel_t {
channel_type_t type;
atomic_int active;
jack_port_t *audio_in;
jack_port_t *audio_out;
jack_port_t *midi_in;
jack_port_t *midi_out;
scene_t scenes[MAX_SCENES];
atomic_int scene_count;
atomic_int current_scene;
};
/* Globals declared in looper.c */
extern struct channel_t *_Atomic channels;
extern atomic_int channel_capacity;
extern atomic_int channel_count;
extern int next_channel_id;
/* Safe accessor for the real‑time thread (returns a snapshot of the current pointer) */
static inline struct channel_t *get_channels_array(void) {
return atomic_load(&channels);
}
void channel_add(jack_client_t *client, int idx);
void channel_remove(jack_client_t *client, int idx);
void channel_add_midi(jack_client_t *client, int idx);
/* Scene management (called from main loop) */
void channel_add_scene(jack_client_t *client, int idx);
void channel_remove_scene(jack_client_t *client, int idx);
void channel_next_scene(jack_client_t *client, int idx);
void channel_prev_scene(jack_client_t *client, int idx);
#endif

24
engine/src/command.h Normal file
View File

@@ -0,0 +1,24 @@
#ifndef COMMAND_H
#define COMMAND_H
typedef enum {
CMD_CYCLE, // toggle record/stop for the current scene of a channel
CMD_STOP, // force to idle for all scenes
CMD_BIND_CHANNEL, // bind a channel index (data = channel)
CMD_UNBIND, // reset bind to channel 0
CMD_ADD_CHANNEL, // add a new dynamic channel
CMD_REMOVE_CHANNEL, // remove last dynamic channel
CMD_ADD_MIDI_CHANNEL, // add a new dynamic MIDI channel
CMD_NEXT_SCENE,
CMD_PREV_SCENE,
CMD_ADD_SCENE,
CMD_REMOVE_SCENE,
} cmd_type_t;
typedef struct {
cmd_type_t type;
int channel; // which channel; -1 means "current/bound"
int data; // extra parameter (e.g. bind channel number)
} command_t;
#endif

634
engine/src/looper.c Normal file
View File

@@ -0,0 +1,634 @@
// cppcheck-suppress missingIncludeSystem
#include "looper.h"
#include "channel.h"
#include "command.h"
#include "midi.h"
#include "queue.h"
#include <jack/jack.h>
#include <jack/midiport.h>
#include <math.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Global state (shared across files) */
struct channel_t *_Atomic channels = NULL;
atomic_int channel_capacity = 0;
atomic_int channel_count = 0;
int next_channel_id = 1;
spsc_queue_t cmd_queue_main_midi;
spsc_queue_t cmd_queue_main_fifo;
atomic_int global_rt_cycles = 0;
jack_port_t *midi_control_port = NULL;
jack_port_t *midi_clock_port = NULL;
atomic_int control_key_active = 0;
atomic_int bind_channel = 0;
spsc_queue_t cmd_queue;
/* Deferred removal index and cycle counter */
static int pending_unregister_idx = -1;
static int pending_unregister_cycle = 0;
/* Deferred free of old channel array (must not free while RT thread may hold
* pointer) */
static struct channel_t *pending_old = NULL;
static int pending_old_cycle = 0;
/* Helper: grow the channel array so that index idx is valid */
static int ensure_capacity(jack_client_t *client, int idx) {
(void)client;
int cur_cap = atomic_load(&channel_capacity);
if (idx < cur_cap)
return 0;
int new_cap = cur_cap == 0 ? 8 : cur_cap;
while (new_cap <= idx)
new_cap *= 2;
struct channel_t *new_arr = calloc(new_cap, sizeof(struct channel_t));
if (!new_arr)
return -1;
/* copy existing channels */
if (cur_cap > 0)
memcpy(new_arr, atomic_load(&channels), cur_cap * sizeof(struct channel_t));
/* atomically publish new array, defer free of old */
struct channel_t *old = atomic_exchange(&channels, new_arr);
atomic_store(&channel_capacity, new_cap);
/* schedule old pointer for later deallocation (after RT cycle) */
pending_old = old;
pending_old_cycle = atomic_load(&global_rt_cycles);
return 0;
}
static void apply_command(command_t cmd) {
int cap = atomic_load(&channel_capacity);
struct channel_t *cur = get_channels_array();
switch (cmd.type) {
case CMD_CYCLE:
if (cmd.channel >= 0 && cmd.channel < cap) {
int sc_idx = atomic_load(&cur[cmd.channel].current_scene);
scene_t *sc = &cur[cmd.channel].scenes[sc_idx];
int cst = atomic_load(&sc->state);
int next;
switch (cst) {
case STATE_IDLE:
next = STATE_RECORD;
break;
case STATE_RECORD:
next = STATE_LOOPING;
break;
case STATE_LOOPING:
next = STATE_PAUSED;
break;
case STATE_PAUSED:
next = STATE_LOOPING;
break;
default:
next = STATE_IDLE;
break;
}
atomic_store(&sc->state, next);
}
break;
case CMD_STOP:
if (cmd.channel >= 0 && cmd.channel < cap) {
struct channel_t *ch = &cur[cmd.channel];
int sc_cnt = atomic_load(&ch->scene_count);
for (int s = 0; s < sc_cnt; s++) {
atomic_store(&ch->scenes[s].state, STATE_IDLE);
atomic_store(&ch->scenes[s].loop_count, 0);
atomic_store(&ch->scenes[s].record_pos, 0);
atomic_store(&ch->scenes[s].playback_pos, 0);
atomic_store(&ch->scenes[s].prev_state, -1);
}
} else {
for (int i = 0; i < cap; i++) {
struct channel_t *ch = &cur[i];
int sc_cnt = atomic_load(&ch->scene_count);
for (int s = 0; s < sc_cnt; s++) {
atomic_store(&ch->scenes[s].state, STATE_IDLE);
atomic_store(&ch->scenes[s].loop_count, 0);
atomic_store(&ch->scenes[s].record_pos, 0);
atomic_store(&ch->scenes[s].playback_pos, 0);
atomic_store(&ch->scenes[s].prev_state, -1);
}
}
}
break;
case CMD_BIND_CHANNEL:
atomic_store(&bind_channel, cmd.data);
break;
case CMD_UNBIND:
atomic_store(&bind_channel, 0);
break;
default:
break;
}
}
/* ----------------------------------------------------------------
* process callback
* ---------------------------------------------------------------- */
int process_callback(jack_nframes_t nframes, void *arg) {
(void)arg;
if (midi_control_port) {
void *midi_ctrl_buf = jack_port_get_buffer(midi_control_port, nframes);
if (midi_ctrl_buf) {
midi_handle_events(midi_ctrl_buf, nframes);
}
}
/* drain RT‑safe commands */
command_t cmd;
while (queue_pop(&cmd_queue, &cmd)) {
apply_command(cmd);
}
/* process each active channel */
struct channel_t *active_channels = get_channels_array();
int cap = atomic_load(&channel_capacity);
for (int c = 0; c < cap; c++) {
if (!atomic_load(&active_channels[c].active))
continue;
/* Guard against NULL ports (e.g. if port registration failed) */
if (active_channels[c].type == CHANNEL_AUDIO) {
if (!active_channels[c].audio_in || !active_channels[c].audio_out) {
fprintf(stderr, "WARN: channel %d has NULL audio port(s), skipping\n",
c);
continue;
}
} else {
/* CHANNEL_MIDI */
if (!active_channels[c].midi_in || !active_channels[c].midi_out) {
fprintf(stderr, "WARN: channel %d has NULL MIDI port(s), skipping\n",
c);
continue;
}
}
/* Obtain current scene pointer */
int sc_idx = atomic_load(&active_channels[c].current_scene);
scene_t *sc = &active_channels[c].scenes[sc_idx];
const jack_default_audio_sample_t *in =
(const jack_default_audio_sample_t *)jack_port_get_buffer(
active_channels[c].audio_in, nframes);
jack_default_audio_sample_t *out =
(jack_default_audio_sample_t *)jack_port_get_buffer(
active_channels[c].audio_out, nframes);
if (!out)
continue;
int state = atomic_load(&sc->state);
int prev_state = atomic_load(&sc->prev_state);
if (state != prev_state) {
switch (state) {
case STATE_RECORD:
atomic_store(&sc->record_pos, 0);
atomic_store(&sc->loop_count, 0);
break;
case STATE_LOOPING:
if (atomic_load(&sc->record_pos) > 0)
atomic_store(&sc->loop_count, atomic_load(&sc->record_pos));
atomic_store(&sc->playback_pos, 0);
break;
default:
break;
}
}
if (active_channels[c].type == CHANNEL_MIDI) {
/* MIDI channel handling */
switch (state) {
case STATE_RECORD: {
void *midi_in_buf =
jack_port_get_buffer(active_channels[c].midi_in, nframes);
if (midi_in_buf) {
jack_nframes_t nevents = jack_midi_get_event_count(midi_in_buf);
jack_midi_event_t ev;
for (jack_nframes_t j = 0; j < nevents; j++) {
if (jack_midi_event_get(&ev, midi_in_buf, j) != 0)
continue;
int rp = atomic_load(&sc->record_pos);
if (rp < MAX_MIDI_EVENTS) {
sc->loop.midi_events[rp].timestamp = ev.time;
sc->loop.midi_events[rp].status = ev.buffer[0];
sc->loop.midi_events[rp].note =
(ev.size > 1) ? ev.buffer[1] : 0;
sc->loop.midi_events[rp].velocity =
(ev.size > 2) ? ev.buffer[2] : 0;
atomic_store(&sc->record_pos, rp + 1);
}
}
/* forward incoming MIDI to output during record */
void *midi_out_buf =
jack_port_get_buffer(active_channels[c].midi_out, nframes);
if (midi_out_buf) {
jack_midi_clear_buffer(midi_out_buf);
for (jack_nframes_t j = 0; j < nevents; j++) {
if (jack_midi_event_get(&ev, midi_in_buf, j) != 0)
continue;
jack_midi_event_write(midi_out_buf, ev.time, ev.buffer, ev.size);
}
}
}
break;
}
case STATE_LOOPING: {
void *midi_out_buf =
jack_port_get_buffer(active_channels[c].midi_out, nframes);
if (midi_out_buf) {
jack_midi_clear_buffer(midi_out_buf);
int cnt = atomic_load(&sc->loop_count);
if (cnt > 0) {
for (int e = 0; e < cnt; e++) {
unsigned char msg[3];
msg[0] = sc->loop.midi_events[e].status;
msg[1] = sc->loop.midi_events[e].note;
msg[2] = sc->loop.midi_events[e].velocity;
jack_midi_event_write(midi_out_buf, 0, msg, 3);
}
}
}
break;
}
case STATE_PAUSED:
/* no output */
break;
default: /* IDLE */
{
void *midi_in_buf =
jack_port_get_buffer(active_channels[c].midi_in, nframes);
void *midi_out_buf =
jack_port_get_buffer(active_channels[c].midi_out, nframes);
if (midi_in_buf && midi_out_buf) {
jack_midi_clear_buffer(midi_out_buf);
jack_nframes_t nevents = jack_midi_get_event_count(midi_in_buf);
jack_midi_event_t ev;
for (jack_nframes_t j = 0; j < nevents; j++) {
if (jack_midi_event_get(&ev, midi_in_buf, j) != 0)
continue;
jack_midi_event_write(midi_out_buf, ev.time, ev.buffer, ev.size);
}
}
}
break;
}
if (state == STATE_LOOPING) {
atomic_store(&sc->loop_count, atomic_load(&sc->record_pos));
}
} else {
/* audio channel handling */
jack_nframes_t i;
switch (state) {
case STATE_RECORD:
if (in) {
float *f_out = (float *)out;
const float *f_in = (const float *)in;
for (i = 0; i < nframes; i++) {
int rp = atomic_load(&sc->record_pos);
if (rp < LOOP_BUF_SIZE) {
sc->loop.audio_buffer[rp] = f_in[i];
atomic_store(&sc->record_pos, rp + 1);
}
f_out[i] = f_in[i];
}
} else {
memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
}
break;
case STATE_LOOPING: {
int loop_cnt = atomic_load(&sc->loop_count);
if (loop_cnt > 0) {
float *outf = (float *)out;
int pp = atomic_load(&sc->playback_pos);
for (i = 0; i < nframes; i++) {
outf[i] = sc->loop.audio_buffer[pp];
pp = (pp + 1) % loop_cnt;
}
atomic_store(&sc->playback_pos, pp);
} else {
memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
}
break;
}
case STATE_PAUSED:
memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
break;
default: /* IDLE */
if (in) {
memcpy(out, in, sizeof(jack_default_audio_sample_t) * nframes);
} else {
memset(out, 0, sizeof(jack_default_audio_sample_t) * nframes);
}
break;
}
}
atomic_store(&sc->prev_state, state);
}
/* MIDI clock events – affect channel 0 only */
if (midi_clock_port) {
void *midi_clock_buf = jack_port_get_buffer(midi_clock_port, nframes);
if (midi_clock_buf) {
jack_nframes_t n_clock_events = jack_midi_get_event_count(midi_clock_buf);
jack_midi_event_t cev;
for (jack_nframes_t j = 0; j < n_clock_events; j++) {
if (jack_midi_event_get(&cev, midi_clock_buf, j) != 0)
continue;
if (cev.size >= 1) {
unsigned char msg = cev.buffer[0];
switch (msg) {
case 0xFA: {
struct channel_t *cur = atomic_load(&channels);
int sc_idx = atomic_load(&cur[0].current_scene);
int s = atomic_load(&cur[0].scenes[sc_idx].state);
if (s == STATE_IDLE)
atomic_store(&cur[0].scenes[sc_idx].state, STATE_RECORD);
break;
}
case 0xFC: {
struct channel_t *cur = atomic_load(&channels);
int sc_idx = atomic_load(&cur[0].current_scene);
atomic_store(&cur[0].scenes[sc_idx].state, STATE_IDLE);
break;
}
case 0xFB: {
struct channel_t *cur = atomic_load(&channels);
int sc_idx = atomic_load(&cur[0].current_scene);
int s = atomic_load(&cur[0].scenes[sc_idx].state);
if (s == STATE_PAUSED)
atomic_store(&cur[0].scenes[sc_idx].state, STATE_LOOPING);
break;
}
default:
break;
}
}
}
}
}
atomic_fetch_add_explicit(&global_rt_cycles, 1, memory_order_release);
return 0;
}
/* ----------------------------------------------------------------
* shutdown callback
* ---------------------------------------------------------------- */
void jack_shutdown_cb(void *arg) {
(void)arg;
fprintf(stderr, "JACK shutdown\n");
exit(0);
}
/* ----------------------------------------------------------------
* looper initialisation
* ---------------------------------------------------------------- */
int looper_init(jack_client_t *client) {
queue_init(&cmd_queue);
queue_init(&cmd_queue_main_midi);
queue_init(&cmd_queue_main_fifo);
/* allocate initial array for at least one channel */
if (ensure_capacity(client, 0) != 0) {
fprintf(stderr, "Cannot allocate channel array\n");
return -1;
}
struct channel_t *init = atomic_load(&channels);
/* channel 0 */
atomic_store(&init[0].active, 1);
atomic_store(&init[0].scene_count, 1);
atomic_store(&init[0].current_scene, 0);
atomic_store(&init[0].scenes[0].loop_count, 0);
atomic_store(&init[0].scenes[0].record_pos, 0);
atomic_store(&init[0].scenes[0].playback_pos, 0);
atomic_store(&init[0].scenes[0].state, STATE_IDLE);
atomic_store(&init[0].scenes[0].prev_state, -1);
init[0].audio_in = jack_port_register(
client, "input", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
init[0].audio_out = jack_port_register(
client, "output", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
if (!init[0].audio_in || !init[0].audio_out) {
fprintf(stderr, "Could not create audio ports for channel 0\n");
return -1;
}
atomic_store(&channel_count, 1);
midi_control_port = jack_port_register(
client, "control", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
midi_clock_port = jack_port_register(client, "clock", JACK_DEFAULT_MIDI_TYPE,
JackPortIsInput, 0);
if (!midi_control_port || !midi_clock_port) {
fprintf(stderr, "Could not create MIDI ports\n");
return -1;
}
return 0;
}
/* ----------------------------------------------------------------
* main‑loop command processing
* ---------------------------------------------------------------- */
void looper_process_commands(jack_client_t *client) {
/* Drain main‑loop command queues (add/remove) */
command_t cmd;
while (queue_pop(&cmd_queue_main_midi, &cmd)) {
switch (cmd.type) {
case CMD_ADD_CHANNEL: {
int cap = atomic_load(&channel_capacity);
int idx;
for (idx = 0; idx < cap; idx++)
if (!atomic_load(&(get_channels_array()[idx].active)))
break;
if (idx == cap) {
if (ensure_capacity(client, idx) != 0)
break;
}
channel_add(client, idx);
break;
}
case CMD_ADD_MIDI_CHANNEL: {
int cap = atomic_load(&channel_capacity);
int idx;
for (idx = 0; idx < cap; idx++)
if (!atomic_load(&(get_channels_array()[idx].active)))
break;
if (idx == cap) {
if (ensure_capacity(client, idx) != 0)
break;
}
channel_add_midi(client, idx);
break;
}
case CMD_REMOVE_CHANNEL: {
int cap = atomic_load(&channel_capacity);
int remove_idx = -1;
for (int idx = 1; idx < cap; idx++)
if (atomic_load(&(get_channels_array()[idx].active)))
remove_idx = idx;
if (remove_idx != -1) {
channel_remove(client, remove_idx);
pending_unregister_idx = remove_idx;
pending_unregister_cycle = atomic_load(&global_rt_cycles);
}
break;
}
case CMD_ADD_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_add_scene(client, ch);
}
break;
}
case CMD_REMOVE_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_remove_scene(client, ch);
}
break;
}
case CMD_NEXT_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_next_scene(client, ch);
}
break;
}
case CMD_PREV_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_prev_scene(client, ch);
}
break;
}
default:
break;
}
}
while (queue_pop(&cmd_queue_main_fifo, &cmd)) {
switch (cmd.type) {
case CMD_ADD_CHANNEL: {
int cap = atomic_load(&channel_capacity);
int idx;
for (idx = 0; idx < cap; idx++)
if (!atomic_load(&(get_channels_array()[idx].active)))
break;
if (idx == cap) {
if (ensure_capacity(client, idx) != 0)
break;
}
channel_add(client, idx);
break;
}
case CMD_ADD_MIDI_CHANNEL: {
int cap = atomic_load(&channel_capacity);
int idx;
for (idx = 0; idx < cap; idx++)
if (!atomic_load(&(get_channels_array()[idx].active)))
break;
if (idx == cap) {
if (ensure_capacity(client, idx) != 0)
break;
}
channel_add_midi(client, idx);
break;
}
case CMD_REMOVE_CHANNEL: {
int cap = atomic_load(&channel_capacity);
int remove_idx = -1;
for (int idx = 1; idx < cap; idx++)
if (atomic_load(&(get_channels_array()[idx].active)))
remove_idx = idx;
if (remove_idx != -1) {
channel_remove(client, remove_idx);
pending_unregister_idx = remove_idx;
pending_unregister_cycle = atomic_load(&global_rt_cycles);
}
break;
}
case CMD_ADD_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_add_scene(client, ch);
}
break;
}
case CMD_REMOVE_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_remove_scene(client, ch);
}
break;
}
case CMD_NEXT_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_next_scene(client, ch);
}
break;
}
case CMD_PREV_SCENE: {
int cap = atomic_load(&channel_capacity);
int bind = atomic_load(&bind_channel);
int ch = bind;
if (ch < cap) {
channel_prev_scene(client, ch);
}
break;
}
default:
break;
}
}
/* Deferred port unregistration – wait until RT thread has seen active=0 */
if (pending_unregister_idx != -1) {
int current_cycle = atomic_load(&global_rt_cycles);
if (current_cycle - pending_unregister_cycle >= 1) {
int idx = pending_unregister_idx;
struct channel_t *cur = atomic_load(&channels);
if (cur[idx].audio_in)
jack_port_unregister(client, cur[idx].audio_in);
if (cur[idx].audio_out)
jack_port_unregister(client, cur[idx].audio_out);
if (cur[idx].midi_in)
jack_port_unregister(client, cur[idx].midi_in);
if (cur[idx].midi_out)
jack_port_unregister(client, cur[idx].midi_out);
pending_unregister_idx = -1;
}
}
/* Deferred free of old channel array – wait until RT thread has seen new
* pointer */
if (pending_old != NULL) {
int current_cycle = atomic_load(&global_rt_cycles);
if (current_cycle - pending_old_cycle >= 1) {
free(pending_old);
pending_old = NULL;
}
}
}

19
engine/src/looper.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef LOOPER_H
#define LOOPER_H
// cppcheck-suppress missingIncludeSystem
#include <jack/jack.h>
/* Initialisation – must be called after setting process callback */
int looper_init(jack_client_t *client);
/* Process callback – to be called by JACK */
int process_callback(jack_nframes_t nframes, void *arg);
/* Shutdown callback */
void jack_shutdown_cb(void *arg);
/* Main‑loop command processing (add/remove channels) */
void looper_process_commands(jack_client_t *client);
#endif

61
engine/src/main.c Normal file
View File

@@ -0,0 +1,61 @@
// cppcheck-suppress missingIncludeSystem
#include "looper.h"
#include "pipe.h"
#include <jack/jack.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
(void)argc;
(void)argv;
const char *client_name = "looper";
jack_options_t options = JackNullOption;
jack_status_t status;
jack_client_t *client = jack_client_open(client_name, options, &status);
if (client == NULL) {
fprintf(stderr, "jack_client_open() failed, status = 0x%2.0x\n", status);
if (status & JackServerFailed)
fprintf(stderr, "Unable to connect to JACK server\n");
return 1;
}
if (status & JackNameNotUnique)
client_name = jack_get_client_name(client);
jack_set_process_callback(client, process_callback, NULL);
jack_on_shutdown(client, jack_shutdown_cb, NULL);
if (looper_init(client) != 0) {
fprintf(stderr, "looper initialisation failed\n");
jack_client_close(client);
return 1;
}
if (pipe_start_reader() != 0) {
fprintf(stderr, "pipe reader initialisation failed\n");
jack_client_close(client);
return 1;
}
if (jack_activate(client)) {
fprintf(stderr, "Cannot activate client\n");
jack_client_close(client);
return 1;
}
fprintf(stderr, "looper running (client name '%s')\n", client_name);
while (1) {
looper_process_commands(client);
{
struct timespec ts = {.tv_sec = 0, .tv_nsec = 1000000};
nanosleep(&ts, NULL);
} /* check commands every 1 ms */
}
jack_client_close(client);
return 0;
}

124
engine/src/midi.c Normal file
View File

@@ -0,0 +1,124 @@
// cppcheck-suppress missingIncludeSystem
#include "midi.h"
#include "channel.h"
#include "command.h"
#include "queue.h"
#include <jack/jack.h>
#include <jack/midiport.h>
#include <stdatomic.h>
extern atomic_int control_key_active;
extern atomic_int bind_channel;
extern spsc_queue_t cmd_queue;
extern spsc_queue_t cmd_queue_main_midi;
void midi_handle_events(void *port_buffer, jack_nframes_t nframes) {
(void)nframes;
jack_nframes_t nevents = jack_midi_get_event_count(port_buffer);
jack_midi_event_t ev;
for (jack_nframes_t i = 0; i < nevents; i++) {
if (jack_midi_event_get(&ev, port_buffer, i) != 0)
continue;
if (ev.size < 3)
continue;
unsigned char status = ev.buffer[0];
unsigned char note = ev.buffer[1];
unsigned char vel = ev.buffer[2];
/* note‑on */
if ((status & 0xf0) == 0x90 && vel > 0) {
if (note == 64) {
atomic_store(&control_key_active, 1);
} else {
int ck = atomic_load(&control_key_active);
if (ck) {
atomic_store(&control_key_active, 0);
if (note < 16 && note < atomic_load(&channel_capacity)) {
command_t cmd = {
.type = CMD_BIND_CHANNEL, .channel = -1, .data = note};
queue_push(&cmd_queue, cmd);
} else {
switch (note) {
case 60: {
command_t cmd = {
.type = CMD_ADD_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 61: {
command_t cmd = {
.type = CMD_REMOVE_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 62: {
int bch = atomic_load(&bind_channel);
if (bch >= 0 && bch < atomic_load(&channel_capacity)) {
command_t cmd = {.type = CMD_CYCLE, .channel = bch, .data = 0};
queue_push(&cmd_queue, cmd);
}
} break;
case 63: {
command_t cmd = {.type = CMD_UNBIND, .channel = -1, .data = 0};
queue_push(&cmd_queue, cmd);
} break;
case 65: {
command_t cmd = {.type = CMD_STOP, .channel = -1, .data = 0};
queue_push(&cmd_queue, cmd);
} break;
case 66: {
command_t cmd = {
.type = CMD_ADD_MIDI_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 67: {
command_t cmd = {
.type = CMD_NEXT_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 68: {
command_t cmd = {
.type = CMD_PREV_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 69: {
command_t cmd = {
.type = CMD_ADD_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 70: {
command_t cmd = {
.type = CMD_REMOVE_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
default:
break;
}
}
} else {
/* direct mapping */
switch (note) {
case 1: {
command_t cmd = {.type = CMD_CYCLE, .channel = 0, .data = 0};
queue_push(&cmd_queue, cmd);
} break;
case 60: {
command_t cmd = {.type = CMD_ADD_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
case 61: {
command_t cmd = {
.type = CMD_REMOVE_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_midi, cmd);
} break;
default:
break;
}
}
}
} else if ((status & 0xf0) == 0x80 ||
((status & 0xf0) == 0x90 && vel == 0)) {
atomic_store(&control_key_active, 0);
}
}
}

9
engine/src/midi.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef MIDI_H
#define MIDI_H
// cppcheck-suppress missingIncludeSystem
#include <jack/types.h>
void midi_handle_events(void *port_buffer, jack_nframes_t nframes);
#endif

99
engine/src/pipe.c Normal file
View File

@@ -0,0 +1,99 @@
#include "pipe.h"
#include "command.h"
#include "queue.h"
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/stat.h>
#include <unistd.h>
#define FIFO_PATH "/tmp/looper_cmd"
#define LINE_MAX 256
/* forward‑declare the global queues (defined in looper.c) */
extern spsc_queue_t cmd_queue;
extern spsc_queue_t cmd_queue_main_fifo;
static void *pipe_thread_func(void *arg) {
(void)arg;
char line[LINE_MAX];
while (1) {
FILE *fifo = fopen(FIFO_PATH, "r");
if (!fifo) {
perror("fopen fifo");
return NULL;
}
while (fgets(line, sizeof(line), fifo)) {
/* strip newline */
size_t len = strlen(line);
if (len > 0 && line[len - 1] == '\n')
line[len - 1] = '\0';
if (strcmp(line, "add") == 0) {
command_t cmd = {.type = CMD_ADD_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
} else if (strcmp(line, "add_midi") == 0) {
command_t cmd = {.type = CMD_ADD_MIDI_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
} else if (strcmp(line, "remove") == 0) {
command_t cmd = {.type = CMD_REMOVE_CHANNEL, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
} else if (strncmp(line, "record ", 7) == 0) {
int ch = atoi(line + 7);
command_t cmd = {.type = CMD_CYCLE, .channel = ch, .data = 0};
queue_push(&cmd_queue, cmd);
} else if (strcmp(line, "stop") == 0) {
command_t cmd = {.type = CMD_STOP, .channel = -1, .data = 0};
queue_push(&cmd_queue, cmd);
} else if (strncmp(line, "bind ", 5) == 0) {
int ch = atoi(line + 5);
command_t cmd = {.type = CMD_BIND_CHANNEL, .channel = -1, .data = ch};
queue_push(&cmd_queue, cmd);
} else if (strcmp(line, "unbind") == 0) {
command_t cmd = {.type = CMD_UNBIND, .channel = -1, .data = 0};
queue_push(&cmd_queue, cmd);
} else if (strcmp(line, "scene_add") == 0) {
command_t cmd = {.type = CMD_ADD_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
} else if (strcmp(line, "scene_remove") == 0) {
command_t cmd = {.type = CMD_REMOVE_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
} else if (strcmp(line, "scene_next") == 0) {
command_t cmd = {.type = CMD_NEXT_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
} else if (strcmp(line, "scene_prev") == 0) {
command_t cmd = {.type = CMD_PREV_SCENE, .channel = -1, .data = 0};
queue_push(&cmd_queue_main_fifo, cmd);
}
/* ignore unknown lines */
}
/* EOF – all writers closed, reopen for next connection */
fclose(fifo);
{
struct timespec ts = {.tv_sec = 0, .tv_nsec = 50000000};
nanosleep(&ts, NULL);
} /* small pause before retrying */
}
return NULL; /* unreachable */
}
int pipe_start_reader(void) {
/* create FIFO if it doesn't exist */
if (mkfifo(FIFO_PATH, 0666) != 0 && errno != EEXIST) {
perror("mkfifo");
return -1;
}
pthread_t tid;
if (pthread_create(&tid, NULL, pipe_thread_func, NULL) != 0) {
perror("pthread_create");
return -1;
}
pthread_detach(tid); /* we don't need to join */
return 0;
}

9
engine/src/pipe.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef PIPE_H
#define PIPE_H
/* Start the FIFO reader thread.
* Creates /tmp/looper_cmd (or aborts on error).
* Returns 0 on success, -1 on failure. */
int pipe_start_reader(void);
#endif

31
engine/src/queue.c Normal file
View File

@@ -0,0 +1,31 @@
#include "queue.h"
#include <stdatomic.h>
#include <stdbool.h>
void queue_init(spsc_queue_t *q) {
/* nothing to allocate, just ensure head/tail start at 0 */
q->head = 0;
q->tail = 0;
}
bool queue_push(spsc_queue_t *q, command_t cmd) {
int h = atomic_load_explicit(&q->head, memory_order_relaxed);
int t = atomic_load_explicit(&q->tail, memory_order_acquire);
int next = (h + 1) % QUEUE_CAPACITY;
if (next == t)
return false; /* queue full */
q->buffer[h] = cmd;
atomic_store_explicit(&q->head, next, memory_order_release);
return true;
}
bool queue_pop(spsc_queue_t *q, command_t *cmd) {
int t = atomic_load_explicit(&q->tail, memory_order_relaxed);
int h = atomic_load_explicit(&q->head, memory_order_acquire);
if (t == h)
return false; /* queue empty */
*cmd = q->buffer[t];
atomic_store_explicit(&q->tail, (t + 1) % QUEUE_CAPACITY,
memory_order_release);
return true;
}

31
engine/src/queue.h Normal file
View File

@@ -0,0 +1,31 @@
#ifndef QUEUE_H
#define QUEUE_H
#include "command.h"
#include <stdbool.h>
/* Fixed‑size lock‑free SPSC queue (single producer, single consumer).
* The queue is safe for one thread writing (producer) and one thread
* reading (consumer). No locks, no dynamic memory allocation.
* Must be initialised before first use. All operations are RT‑safe. */
#define QUEUE_CAPACITY 256
typedef struct {
command_t buffer[QUEUE_CAPACITY];
/* head: index where next element will be written (producer only)
* tail: index of next element to read (consumer only) */
int head;
int tail;
} spsc_queue_t;
/* Initialise queue (must be called once before any push/pop). */
void queue_init(spsc_queue_t *q);
/* Push a command. Returns true on success, false if queue full. */
bool queue_push(spsc_queue_t *q, command_t cmd);
/* Pop a command. Returns true if a command was retrieved, false if empty. */
bool queue_pop(spsc_queue_t *q, command_t *cmd);
#endif