feat: add mock JACK test target and unit tests for carla host

engine/src/channel.c

@@ -7,9 +7,9 @@
 
 /* Helper: zero a scene and set its state to IDLE */
 static void init_scene(scene_t *sc) {
-  memset(sc, 0, sizeof(scene_t));
+    memset(sc, 0, sizeof(scene_t));
-  atomic_store(&sc->state, STATE_IDLE);
+    atomic_store(&sc->state, STATE_IDLE);
-  atomic_store(&sc->prev_state, -1);
+    atomic_store(&sc->prev_state, -1);
 }
 
 void channel_add(jack_client_t *client, int idx) {
@@ -76,61 +76,61 @@ void channel_remove(jack_client_t *client, int idx) {
 }
 
 void channel_add_scene(jack_client_t *client, int idx) {
-  (void)client;
+    (void)client;
-  struct channel_t *cur = get_channels_array();
+    struct channel_t *cur = get_channels_array();
-  if (atomic_load(&cur[idx].scene_count) >= MAX_SCENES)
+    if (atomic_load(&cur[idx].scene_count) >= MAX_SCENES)
-    return;
+        return;
-  int ns = atomic_load(&cur[idx].scene_count);
+    int ns = atomic_load(&cur[idx].scene_count);
-  init_scene(&cur[idx].scenes[ns]);
+    init_scene(&cur[idx].scenes[ns]);
-  atomic_fetch_add(&cur[idx].scene_count, 1);
+    atomic_fetch_add(&cur[idx].scene_count, 1);
 }
 
 void channel_remove_scene(jack_client_t *client, int idx) {
-  (void)client;
+    (void)client;
-  struct channel_t *cur = get_channels_array();
+    struct channel_t *cur = get_channels_array();
-  int sc = atomic_load(&cur[idx].scene_count);
+    int sc = atomic_load(&cur[idx].scene_count);
-  if (sc <= 1)
+    if (sc <= 1)
-    return;
+        return;
-  int cs = atomic_load(&cur[idx].current_scene);
+    int cs = atomic_load(&cur[idx].current_scene);
-  /* shift remaining scenes down (atomic copy of fields) */
+    /* shift remaining scenes down (atomic copy of fields) */
-  for (int i = cs; i < sc - 1; i++) {
+    for (int i = cs; i < sc - 1; i++) {
-    atomic_store(&cur[idx].scenes[i].loop_count,
+        atomic_store(&cur[idx].scenes[i].loop_count,
-                 atomic_load(&cur[idx].scenes[i + 1].loop_count));
+                     atomic_load(&cur[idx].scenes[i+1].loop_count));
-    atomic_store(&cur[idx].scenes[i].record_pos,
+        atomic_store(&cur[idx].scenes[i].record_pos,
-                 atomic_load(&cur[idx].scenes[i + 1].record_pos));
+                     atomic_load(&cur[idx].scenes[i+1].record_pos));
-    atomic_store(&cur[idx].scenes[i].playback_pos,
+        atomic_store(&cur[idx].scenes[i].playback_pos,
-                 atomic_load(&cur[idx].scenes[i + 1].playback_pos));
+                     atomic_load(&cur[idx].scenes[i+1].playback_pos));
-    atomic_store(&cur[idx].scenes[i].state,
+        atomic_store(&cur[idx].scenes[i].state,
-                 atomic_load(&cur[idx].scenes[i + 1].state));
+                     atomic_load(&cur[idx].scenes[i+1].state));
-    atomic_store(&cur[idx].scenes[i].prev_state,
+        atomic_store(&cur[idx].scenes[i].prev_state,
-                 atomic_load(&cur[idx].scenes[i + 1].prev_state));
+                     atomic_load(&cur[idx].scenes[i+1].prev_state));
-    /* copy loop data (may race with RT thread; acceptable for this release) */
+        /* copy loop data (may race with RT thread; acceptable for this release) */
-    memcpy(cur[idx].scenes[i].loop.audio_buffer,
+        memcpy(cur[idx].scenes[i].loop.audio_buffer,
-           cur[idx].scenes[i + 1].loop.audio_buffer,
+               cur[idx].scenes[i+1].loop.audio_buffer,
-           LOOP_BUF_SIZE * sizeof(float));
+               LOOP_BUF_SIZE * sizeof(float));
-  }
+    }
-  atomic_fetch_sub(&cur[idx].scene_count, 1);
+    atomic_fetch_sub(&cur[idx].scene_count, 1);
-  int new_sc = atomic_load(&cur[idx].scene_count);
+    int new_sc = atomic_load(&cur[idx].scene_count);
-  if (cs >= new_sc)
+    if (cs >= new_sc)
-    atomic_store(&cur[idx].current_scene, new_sc - 1);
+        atomic_store(&cur[idx].current_scene, new_sc - 1);
 }
 
 void channel_next_scene(jack_client_t *client, int idx) {
-  (void)client;
+    (void)client;
-  struct channel_t *cur = get_channels_array();
+    struct channel_t *cur = get_channels_array();
-  int sc = atomic_load(&cur[idx].scene_count);
+    int sc = atomic_load(&cur[idx].scene_count);
-  if (sc > 1) {
+    if (sc > 1) {
-    int cs = atomic_load(&cur[idx].current_scene);
+        int cs = atomic_load(&cur[idx].current_scene);
-    atomic_store(&cur[idx].current_scene, (cs + 1) % sc);
+        atomic_store(&cur[idx].current_scene, (cs + 1) % sc);
-  }
+    }
 }
 
 void channel_prev_scene(jack_client_t *client, int idx) {
-  (void)client;
+    (void)client;
-  struct channel_t *cur = get_channels_array();
+    struct channel_t *cur = get_channels_array();
-  int sc = atomic_load(&cur[idx].scene_count);
+    int sc = atomic_load(&cur[idx].scene_count);
-  if (sc > 1) {
+    if (sc > 1) {
-    int cs = atomic_load(&cur[idx].current_scene);
+        int cs = atomic_load(&cur[idx].current_scene);
-    atomic_store(&cur[idx].current_scene, (cs - 1 + sc) % sc);
+        atomic_store(&cur[idx].current_scene, (cs - 1 + sc) % sc);
-  }
+    }
 }

engine/src/looper.c

@@ -4,56 +4,48 @@
 #include "command.h"
 #include "midi.h"
 #include "queue.h"
-#include <fcntl.h>
 #include <jack/jack.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
 #include <jack/midiport.h>
 #include <math.h>
 #include <stdatomic.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
 
 #define STATUS_FIFO "/tmp/looper_status"
 
 static void looper_write_status(void) {
-  int fd = open(STATUS_FIFO, O_WRONLY | O_NONBLOCK);
+    int fd = open(STATUS_FIFO, O_WRONLY | O_NONBLOCK);
-  if (fd < 0)
+    if (fd < 0)
-    return;
+        return;
-  struct channel_t *cur = get_channels_array();
+    struct channel_t *cur = get_channels_array();
-  int cap = atomic_load(&channel_capacity);
+    int cap = atomic_load(&channel_capacity);
-  char buf[256];
+    char buf[256];
-  for (int ch = 0; ch < cap; ch++) {
+    for (int ch = 0; ch < cap; ch++) {
-    if (!atomic_load(&cur[ch].active))
+        if (!atomic_load(&cur[ch].active))
-      continue;
+            continue;
-    int sc_idx = atomic_load(&cur[ch].current_scene);
+        int sc_idx = atomic_load(&cur[ch].current_scene);
-    int state = atomic_load(&cur[ch].scenes[sc_idx].state);
+        int state = atomic_load(&cur[ch].scenes[sc_idx].state);
-    const char *state_str;
+        const char *state_str;
-    switch (state) {
+        switch (state) {
-    case STATE_IDLE:
+            case STATE_IDLE:    state_str = "IDLE";    break;
-      state_str = "IDLE";
+            case STATE_RECORD:  state_str = "RECORD";  break;
-      break;
+            case STATE_LOOPING: state_str = "LOOPING"; break;
-    case STATE_RECORD:
+            case STATE_PAUSED:  state_str = "PAUSED";  break;
-      state_str = "RECORD";
+            default:            state_str = "UNKNOWN";
-      break;
+        }
-    case STATE_LOOPING:
+        int n = snprintf(buf, sizeof(buf),
-      state_str = "LOOPING";
+                         "CH=%d SC=%d STATE=%s\n",
-      break;
+                         ch, sc_idx, state_str);
-    case STATE_PAUSED:
+        if (n > 0) {
-      state_str = "PAUSED";
+            int ret = write(fd, buf, n);
-      break;
+            (void)ret;
-    default:
+        }
-      state_str = "UNKNOWN";
     }
-    int n = snprintf(buf, sizeof(buf), "CH=%d SC=%d STATE=%s\n", ch, sc_idx,
+    close(fd);
-                     state_str);
-    if (n > 0) {
-      int ret = write(fd, buf, n);
-      (void)ret;
-    }
-  }
-  close(fd);
 }
 
 /* Global state (shared across files) */
@@ -260,7 +252,8 @@ int process_callback(jack_nframes_t nframes, void *arg) {
             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].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);
@@ -302,22 +295,23 @@ int process_callback(jack_nframes_t nframes, void *arg) {
         /* no output */
         break;
       default: /* IDLE */
-      {
+        {
-        void *midi_in_buf =
+          void *midi_in_buf =
-            jack_port_get_buffer(active_channels[c].midi_in, nframes);
+              jack_port_get_buffer(active_channels[c].midi_in, nframes);
-        void *midi_out_buf =
+          void *midi_out_buf =
-            jack_port_get_buffer(active_channels[c].midi_out, nframes);
+              jack_port_get_buffer(active_channels[c].midi_out, nframes);
-        if (midi_in_buf && midi_out_buf) {
+          if (midi_in_buf && midi_out_buf) {
-          jack_midi_clear_buffer(midi_out_buf);
+            jack_midi_clear_buffer(midi_out_buf);
-          jack_nframes_t nevents = jack_midi_get_event_count(midi_in_buf);
+            jack_nframes_t nevents = jack_midi_get_event_count(midi_in_buf);
-          jack_midi_event_t ev;
+            jack_midi_event_t ev;
-          for (jack_nframes_t j = 0; j < nevents; j++) {
+            for (jack_nframes_t j = 0; j < nevents; j++) {
-            if (jack_midi_event_get(&ev, midi_in_buf, j) != 0)
+              if (jack_midi_event_get(&ev, midi_in_buf, j) != 0)
-              continue;
+                continue;
-            jack_midi_event_write(midi_out_buf, ev.time, ev.buffer, ev.size);
+              jack_midi_event_write(midi_out_buf, ev.time, ev.buffer, ev.size);
+            }
           }
         }
-      } break;
+        break;
       }
       if (state == STATE_LOOPING) {
         atomic_store(&sc->loop_count, atomic_load(&sc->record_pos));

engine/src/midi.c

@@ -82,7 +82,8 @@ void midi_handle_events(void *port_buffer, jack_nframes_t nframes) {
               queue_push(&cmd_queue_main_midi, cmd);
             } break;
             case 69: {
-              command_t cmd = {.type = CMD_ADD_SCENE, .channel = -1, .data = 0};
+              command_t cmd = {
+                  .type = CMD_ADD_SCENE, .channel = -1, .data = 0};
               queue_push(&cmd_queue_main_midi, cmd);
             } break;
             case 70: {

engine/src/pipe.c

@@ -7,8 +7,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/stat.h>
 #include <time.h>
+#include <sys/stat.h>
 #include <unistd.h>
 
 #define FIFO_PATH "/tmp/looper_cmd"
@@ -39,8 +39,7 @@ static void *pipe_thread_func(void *arg) {
         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 = {
+        command_t cmd = {.type = CMD_ADD_MIDI_CHANNEL, .channel = -1, .data = 0};
-            .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};