Files
led-controller/desktop/port/src/mic_alsa.c
T
jimmyandClaude Opus 5.5 581b751904 feat: browser simulator served by the controller, desktop build, browser bridge
- led-simulator: the rig runs the C++ led-driver as WebAssembly (sim-driver/),
  one single-threaded worker per bar, no cross-origin isolation needed. Rooms
  (one JSON per room) with an on-page editor, and a pattern gallery. The
  Python server, Pyodide boot and ring buffer are removed.
- sim-controller sim_rig.c: serves /sim/ from an embedded pack, the page's
  WebSocket and the rooms/flash API. The desktop build embeds it too.
- bridge.c: a "browser" bridge kind that carries ESP-NOW frames to the page;
  devices announced through it are marked sim.
- UI: Simulator in the Menu, split view with resize and pop-out, swipe
  between controller and rig on phones; SIM/REAL badges in Devices.
- Fades: preset pushes and Wi-Fi driver bodies always carry fade and
  beat_time, so "off" no longer inherits an earlier fade.
- Also the sequences-v2 work in progress: desktop port, bridge firmware,
  serial bridge, Wi-Fi drivers, sequence timeline, audio and API changes.
- led-driver: ESP-NOW link, beat sync, control messages, sim hooks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 19:32:46 +13:00

441 lines
14 KiB
C

/*
* Desktop microphone: captures from a Linux ALSA capture device (a USB mic such as the Blue Snowball) and feeds
* the same level meter, beat detector and /audio.wav stream as the board's I2S mic.c. Only the devices named by
* mic_list_devices() are selectable: plughw:CARD=... capture devices, which convert to 16 kHz mono for us.
*/
#include <alsa/asoundlib.h>
#include <errno.h>
#include <math.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "cJSON.h"
#include "esp_log.h"
#include "beat.h"
#include "bridge.h"
#include "mic.h"
#define BRIDGE_DEVICE "bridge:mic" // the microphone of a bridge board (bridge/, ESP32-S3), see bridge_serial.h
#define BLOCK_FRAMES (MIC_SAMPLE_RATE / 50) // 20 ms per read
#define LEVEL_BLOCKS 5 // 100 ms per level reading
#define RING_SAMPLES MIC_SAMPLE_RATE // 1 s of 16-bit mono for the stream
#define DBFS_FLOOR -120.0f
#define SPL_OFFSET 120.0f // same nominal offset as the I2S mic; not calibrated for USB mics
#define DEVICE_NAME_MAX 128
static const char *TAG = "mic_alsa";
static pthread_mutex_t s_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_cond = PTHREAD_COND_INITIALIZER;
static bool s_open; // capture wanted (set by mic_open / mic_close)
static uint64_t s_gen; // bumped by mic_open so the capture thread reopens the device
static char s_device[DEVICE_NAME_MAX] = "default";
static mic_level_t s_level = { DBFS_FLOOR, DBFS_FLOOR, DBFS_FLOOR + SPL_OFFSET };
static char s_error[160]; // why the last open failed, "" when it works
static bool s_streaming;
static int16_t s_ring[RING_SAMPLES];
static size_t s_ring_fill; // samples waiting in the ring, oldest first from s_ring_head
static size_t s_ring_head;
static float to_dbfs(float x)
{
return x > 0.0f ? fmaxf(20.0f * log10f(x), DBFS_FLOOR) : DBFS_FLOOR;
}
// Called with s_lock held: a block of 16-bit samples for the stream listener, dropped when it is full
static void ring_push_locked(const int16_t *pcm, size_t n)
{
if (!s_streaming || s_ring_fill + n > RING_SAMPLES) {
return;
}
for (size_t i = 0; i < n; i++) {
s_ring[(s_ring_head + s_ring_fill + i) % RING_SAMPLES] = pcm[i];
}
s_ring_fill += n;
pthread_cond_broadcast(&s_cond);
}
static void reset_level_locked(void)
{
s_level.rms_dbfs = DBFS_FLOOR;
s_level.peak_dbfs = DBFS_FLOOR;
s_level.spl_db = DBFS_FLOOR + SPL_OFFSET;
}
// Per-stream state of the level meter and high-pass filter, see process_block
typedef struct {
float hp_in, hp_out;
double sum_sq;
float peak;
size_t frames;
size_t blocks;
} proc_t;
// One block of 16-bit mono at MIC_SAMPLE_RATE: level meter, beat detector and the stream listener's copy
static void process_block(proc_t *p, const int16_t *raw, size_t frames)
{
static float filtered[BLOCK_FRAMES];
static int16_t pcm_out[BLOCK_FRAMES];
const float gain = CONFIG_MIC_STREAM_GAIN;
for (size_t i = 0; i < frames; i++) {
float x = (float)raw[i] / 32768.0f;
float y = x - p->hp_in + 0.995f * p->hp_out; // one-pole high-pass, as in mic.c
p->hp_in = x;
p->hp_out = y;
filtered[i] = y;
p->sum_sq += (double)y * y;
p->peak = fmaxf(p->peak, fabsf(y));
pcm_out[i] = (int16_t)fmaxf(fminf(y * gain * 32767.0f, 32767.0f), -32768.0f);
}
p->frames += frames;
beat_feed(filtered, frames);
pthread_mutex_lock(&s_lock);
ring_push_locked(pcm_out, frames);
if (++p->blocks >= LEVEL_BLOCKS) {
s_level.rms_dbfs = to_dbfs(sqrtf((float)(p->sum_sq / p->frames)));
s_level.peak_dbfs = to_dbfs(p->peak);
s_level.spl_db = s_level.rms_dbfs + SPL_OFFSET;
p->sum_sq = 0.0;
p->peak = 0.0f;
p->frames = p->blocks = 0;
}
pthread_mutex_unlock(&s_lock);
}
// Read blocks from one open device until it fails or mic_open/mic_close changes the request
static void capture_loop(snd_pcm_t *pcm, uint64_t gen)
{
static int16_t raw[BLOCK_FRAMES];
proc_t p = { 0 };
for (;;) {
pthread_mutex_lock(&s_lock);
bool keep = s_open && s_gen == gen;
pthread_mutex_unlock(&s_lock);
if (!keep) {
return;
}
snd_pcm_sframes_t n = snd_pcm_readi(pcm, raw, BLOCK_FRAMES);
if (n < 0) {
if (snd_pcm_recover(pcm, (int)n, 1) < 0) {
ESP_LOGW(TAG, "capture read failed: %s", snd_strerror((int)n));
return;
}
continue;
}
process_block(&p, raw, (size_t)n);
}
}
// Audio from a bridge board: the bridge's link task calls this while the bridge device is selected
static proc_t s_bridge_proc;
static void on_bridge_audio(const int16_t *pcm, size_t n)
{
pthread_mutex_lock(&s_lock);
bool mine = s_open && !strcmp(s_device, BRIDGE_DEVICE);
pthread_mutex_unlock(&s_lock);
if (mine) {
process_block(&s_bridge_proc, pcm, n);
}
}
static void *capture_thread(void *arg)
{
(void)arg;
for (;;) {
pthread_mutex_lock(&s_lock);
bool open = s_open;
uint64_t gen = s_gen;
char name[DEVICE_NAME_MAX];
memcpy(name, s_device, sizeof(name));
pthread_mutex_unlock(&s_lock);
if (!open || !strcmp(name, BRIDGE_DEVICE)) {
usleep(100 * 1000); // idle: a bridge device is fed by on_bridge_audio
continue;
}
// "pulse:<source>" is a PipeWire/PulseAudio source, opened through the pulse ALSA plugin
const char *pcm_name = name;
if (!strncmp(name, "pulse:", 6)) {
setenv("PULSE_SOURCE", name + 6, 1);
pcm_name = "pulse";
}
snd_pcm_t *pcm = NULL;
int err = snd_pcm_open(&pcm, pcm_name, SND_PCM_STREAM_CAPTURE, 0);
if (err < 0) {
ESP_LOGW(TAG, "cannot open %s: %s", name, snd_strerror(err));
pthread_mutex_lock(&s_lock);
snprintf(s_error, sizeof(s_error), "Cannot open %s: %s", name, snd_strerror(err));
pthread_mutex_unlock(&s_lock);
sleep(1);
continue;
}
err = snd_pcm_set_params(pcm, SND_PCM_FORMAT_S16_LE, SND_PCM_ACCESS_RW_INTERLEAVED, 1,
MIC_SAMPLE_RATE, 1, 500000);
if (err < 0) {
ESP_LOGW(TAG, "cannot set %s to %d Hz mono: %s", name, MIC_SAMPLE_RATE, snd_strerror(err));
snd_pcm_close(pcm);
sleep(1);
continue;
}
ESP_LOGI(TAG, "capturing from %s", name);
pthread_mutex_lock(&s_lock);
s_error[0] = '\0';
pthread_mutex_unlock(&s_lock);
capture_loop(pcm, gen);
snd_pcm_drop(pcm);
snd_pcm_close(pcm);
pthread_mutex_lock(&s_lock);
if (s_gen == gen) {
reset_level_locked();
}
pthread_mutex_unlock(&s_lock);
}
return NULL;
}
esp_err_t mic_start(void)
{
esp_err_t err = beat_start(MIC_SAMPLE_RATE);
if (err != ESP_OK) {
return err;
}
bridge_set_audio_cb(on_bridge_audio);
pthread_t t;
if (pthread_create(&t, NULL, capture_thread, NULL) != 0) {
return ESP_ERR_NO_MEM;
}
pthread_detach(t);
return ESP_OK;
}
void mic_get_level(mic_level_t *out)
{
pthread_mutex_lock(&s_lock);
*out = s_level;
pthread_mutex_unlock(&s_lock);
}
esp_err_t mic_open(const char *device)
{
if (!device || !device[0]) {
device = "default";
}
if (strlen(device) >= DEVICE_NAME_MAX) {
return ESP_ERR_INVALID_ARG;
}
bool bridge = !strcmp(device, BRIDGE_DEVICE);
if (bridge && !bridge_has_mic()) {
pthread_mutex_lock(&s_lock);
snprintf(s_error, sizeof(s_error), "No bridge board with a microphone is connected");
pthread_mutex_unlock(&s_lock);
return ESP_ERR_NOT_FOUND;
}
if (bridge && bridge_mic(true) != ESP_OK) {
pthread_mutex_lock(&s_lock);
snprintf(s_error, sizeof(s_error), "The bridge microphone did not start");
pthread_mutex_unlock(&s_lock);
return ESP_ERR_NOT_SUPPORTED;
}
pthread_mutex_lock(&s_lock);
strcpy(s_device, device);
s_open = true;
s_gen++;
s_ring_fill = 0;
s_bridge_proc = (proc_t){ 0 };
s_error[0] = '\0';
reset_level_locked();
pthread_mutex_unlock(&s_lock);
return ESP_OK;
}
void mic_close(void)
{
pthread_mutex_lock(&s_lock);
s_open = false;
s_gen++;
reset_level_locked();
pthread_mutex_unlock(&s_lock);
bridge_mic(false); // harmless when no bridge is attached
}
void mic_error(char *out, size_t len)
{
pthread_mutex_lock(&s_lock);
snprintf(out, len, "%s", s_error);
pthread_mutex_unlock(&s_lock);
}
bool mic_is_open(void)
{
pthread_mutex_lock(&s_lock);
bool open = s_open;
pthread_mutex_unlock(&s_lock);
return open;
}
esp_err_t mic_stream_open(void)
{
pthread_mutex_lock(&s_lock);
if (s_streaming) {
pthread_mutex_unlock(&s_lock);
return ESP_ERR_INVALID_STATE;
}
s_streaming = true;
s_ring_fill = 0;
pthread_mutex_unlock(&s_lock);
return ESP_OK;
}
size_t mic_stream_read(void *buf, size_t len, TickType_t timeout)
{
struct timespec deadline;
clock_gettime(CLOCK_REALTIME, &deadline);
long ms = (long)(timeout * portTICK_PERIOD_MS);
deadline.tv_sec += ms / 1000;
deadline.tv_nsec += (ms % 1000) * 1000000L;
if (deadline.tv_nsec >= 1000000000L) {
deadline.tv_sec++;
deadline.tv_nsec -= 1000000000L;
}
pthread_mutex_lock(&s_lock);
while (s_ring_fill == 0) {
if (pthread_cond_timedwait(&s_cond, &s_lock, &deadline) == ETIMEDOUT) {
break;
}
}
size_t want = len / sizeof(int16_t);
size_t n = want < s_ring_fill ? want : s_ring_fill;
uint8_t *out = buf;
for (size_t i = 0; i < n; i++) {
int16_t v = s_ring[(s_ring_head + i) % RING_SAMPLES];
out[2 * i] = (uint8_t)(v & 0xFF);
out[2 * i + 1] = (uint8_t)((uint16_t)v >> 8);
}
s_ring_head = (s_ring_head + n) % RING_SAMPLES;
s_ring_fill -= n;
pthread_mutex_unlock(&s_lock);
return n * sizeof(int16_t);
}
void mic_stream_close(void)
{
pthread_mutex_lock(&s_lock);
s_streaming = false;
pthread_mutex_unlock(&s_lock);
}
// Input sources the desktop can record from. On a PipeWire/PulseAudio desktop the USB mic is shared through the
// sound server, so it is listed as a pulse source (pactl). Otherwise the raw ALSA plughw:CARD=... inputs are used.
static int list_alsa_devices(mic_device_t *out, int max);
static int list_pulse_sources(mic_device_t *out, int max)
{
FILE *p = popen("pactl -f json list sources 2>/dev/null", "r");
if (!p) {
return 0;
}
char *buf = NULL;
size_t cap = 0, len = 0;
for (;;) {
if (len + 4096 > cap) {
cap = cap ? cap * 2 : 8192;
buf = realloc(buf, cap);
if (!buf) {
pclose(p);
return 0;
}
}
size_t got = fread(buf + len, 1, cap - len - 1, p);
if (got == 0) {
break;
}
len += got;
}
pclose(p);
buf[len] = '\0';
int count = 0;
cJSON *list = cJSON_Parse(buf);
free(buf);
for (const cJSON *src = list ? list->child : NULL; src && count < max; src = src->next) {
const cJSON *name = cJSON_GetObjectItem(src, "name");
const cJSON *desc = cJSON_GetObjectItem(src, "description");
if (!cJSON_IsString(name) || strncmp(name->valuestring, "alsa_input.", 11) != 0) {
continue; // monitors and other sources
}
mic_device_t *d = &out[count];
if (strlen(name->valuestring) + 6 >= sizeof(d->id)) {
continue;
}
snprintf(d->id, sizeof(d->id), "pulse:%s", name->valuestring);
snprintf(d->name, sizeof(d->name), "%s", cJSON_IsString(desc) ? desc->valuestring : name->valuestring);
snprintf(d->label, sizeof(d->label), "%s", name->valuestring);
count++;
}
cJSON_Delete(list);
return count;
}
int mic_list_devices(mic_device_t *out, int max)
{
int count = 0;
if (bridge_has_mic() && max > 0) {
mic_device_t *d = &out[count++];
snprintf(d->id, sizeof(d->id), "%s", BRIDGE_DEVICE);
snprintf(d->name, sizeof(d->name), "I2S microphone on the bridge board");
snprintf(d->label, sizeof(d->label), "%s", BRIDGE_DEVICE);
}
int more = list_pulse_sources(out + count, max - count);
if (more == 0) {
more = list_alsa_devices(out + count, max - count);
}
return count + more;
}
// Raw ALSA capture devices: each plughw:CARD=... input (ALSA converts to our format)
static int list_alsa_devices(mic_device_t *out, int max)
{
void **hints = NULL;
int count = 0;
if (snd_device_name_hint(-1, "pcm", &hints) < 0) {
return 0;
}
for (void **h = hints; *h && count < max; h++) {
char *name = snd_device_name_get_hint(*h, "NAME");
char *desc = snd_device_name_get_hint(*h, "DESC");
char *ioid = snd_device_name_get_hint(*h, "IOID");
bool input = !ioid || !strcmp(ioid, "Input");
if (name && input && !strncmp(name, "plughw:CARD=", 12) && strlen(name) < sizeof(out[count].id)) {
mic_device_t *d = &out[count];
strcpy(d->id, name);
strcpy(d->label, name);
// The description runs over several lines; the first is the device's name
const char *first = desc ? desc : name;
size_t len = strcspn(first, "\n");
if (len >= sizeof(d->name)) {
len = sizeof(d->name) - 1;
}
memcpy(d->name, first, len);
d->name[len] = '\0';
count++;
}
free(name);
free(desc);
free(ioid);
}
snd_device_name_free_hint(hints);
return count;
}