Files
led-controller/main/envelope.c
T
jimmyandClaude Sonnet 5.5 2543673bd8 feat: sequences v2, bridges, and sim-controller
Rework sequences (engine, seqplay, envelope, API, web UI), add bridge
support, add the host sim-controller and rig simulation tests, and
update docs, presets and project tooling config.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 17:47:27 +13:00

208 lines
5.5 KiB
C

#include "envelope.h"
#include <stdlib.h>
#include <string.h>
void env_blob_init(env_blob_t *b)
{
b->data[0] = 0;
b->len = 1;
b->v3 = false;
}
static bool put(env_blob_t *b, const void *src, size_t n)
{
if (b->len + n > ENV_BLOB_MAX) {
return false;
}
memcpy(b->data + b->len, src, n);
b->len += n;
return true;
}
static bool put_u8(env_blob_t *b, unsigned v)
{
uint8_t x = v;
return put(b, &x, 1);
}
static bool put_le16(env_blob_t *b, unsigned v)
{
uint8_t x[2] = { v & 255, (v >> 8) & 255 };
return put(b, x, 2);
}
// Python truthiness of a JSON value
static bool truthy(const cJSON *v)
{
if (!v || cJSON_IsNull(v) || cJSON_IsFalse(v)) {
return false;
}
if (cJSON_IsNumber(v)) {
return v->valuedouble != 0;
}
if (cJSON_IsString(v)) {
return v->valuestring[0] != 0;
}
return true;
}
static const cJSON *get2(const cJSON *o, const char *a, const char *b)
{
const cJSON *v = cJSON_GetObjectItem(o, a);
return truthy(v) ? v : cJSON_GetObjectItem(o, b);
}
static int clamp(double v, int lo, int hi)
{
int i = (int)v;
return i < lo ? lo : (i > hi ? hi : i);
}
static int num_or(const cJSON *v, int dflt)
{
return cJSON_IsNumber(v) ? (int)v->valuedouble : (cJSON_IsBool(v) ? cJSON_IsTrue(v) : dflt);
}
// Same rule as the Python packer: 6+ hex digits or an [r,g,b] list; anything else is skipped
static bool color_rgb(const cJSON *c, uint8_t rgb[3])
{
if (cJSON_IsString(c)) {
const char *s = c->valuestring;
while (*s == ' ') {
s++;
}
while (*s == '#') {
s++;
}
if (strlen(s) < 6) {
return false;
}
char full[7];
memcpy(full, s, 6);
full[6] = 0;
char *end;
unsigned long v = strtoul(full, &end, 16);
if (*end) {
return false;
}
rgb[0] = v >> 16;
rgb[1] = v >> 8;
rgb[2] = v;
return true;
}
if (cJSON_IsArray(c) && cJSON_GetArraySize(c) >= 3) {
for (int i = 0; i < 3; i++) {
rgb[i] = (uint8_t)num_or(cJSON_GetArrayItem(c, i), 0);
}
return true;
}
return false;
}
bool env_add_preset(env_blob_t *b, const char *name, const cJSON *p)
{
size_t save_len = b->len;
uint8_t save_count = b->data[0];
const cJSON *pat = get2(p, "p", "pattern");
const char *pattern = cJSON_IsString(pat) ? pat->valuestring : "off";
const cJSON *cols = get2(p, "c", "colors");
int ncol = cJSON_IsArray(cols) ? cJSON_GetArraySize(cols) : 0;
size_t nl = strlen(name), pl = strlen(pattern);
if (nl > 250 || pl > 250 || ncol > 255) {
return false;
}
const cJSON *fade = get2(p, "f", "fade"), *tb = get2(p, "tb", "beat_time");
int fade_ms = clamp(num_or(fade, 0), 0, 10000);
bool beat = truthy(tb);
bool ext = fade_ms > 0 || beat;
if (b->data[0] == 0) {
b->v3 = ext;
} else if (b->v3 != ext) {
return false;
}
uint8_t rgbs[255][3];
int nvalid = 0;
for (int i = 0; i < ncol; i++) {
if (color_rgb(cJSON_GetArrayItem(cols, i), rgbs[nvalid])) {
nvalid++;
}
}
bool ok = put_u8(b, nl) && put(b, name, nl) && put_u8(b, pl) && put(b, pattern, pl) && put_u8(b, nvalid);
for (int i = 0; ok && i < nvalid; i++) {
ok = put(b, rgbs[i], 3);
}
const cJSON *d = get2(p, "d", "delay"), *br = get2(p, "b", "brightness");
const cJSON *a = cJSON_GetObjectItem(p, "a");
if (!a) {
a = cJSON_GetObjectItem(p, "auto");
}
int auto_ = a ? truthy(a) : 1;
ok = ok && put_le16(b, clamp(num_or(d, 100), 0, 65535)) && put_u8(b, clamp(num_or(br, 127), 0, 255)) &&
put_u8(b, auto_);
for (int i = 1; ok && i <= 6; i++) {
char key[4] = { 'n', '0' + i, 0 };
ok = put_le16(b, (uint16_t)(int16_t)clamp(num_or(cJSON_GetObjectItem(p, key), 0), -32768, 32767));
}
if (ok && b->v3) {
uint8_t ext_len = (fade_ms ? 4 : 0) + (beat ? 3 : 0);
ok = put_u8(b, ext_len);
if (ok && fade_ms) {
ok = put_u8(b, ENV_EXT_FADE) && put_u8(b, 2) && put_le16(b, fade_ms);
}
if (ok && beat) {
ok = put_u8(b, ENV_EXT_BEAT) && put_u8(b, 1) && put_u8(b, 1);
}
}
if (!ok) {
b->len = save_len;
b->data[0] = save_count;
return false;
}
b->data[0]++;
return true;
}
bool env_add_select(env_blob_t *b, const char *device, const char *preset, int step)
{
size_t save_len = b->len;
size_t dl = strlen(device), pl = strlen(preset);
if (dl > 250 || pl > 250 || (step > 65535)) {
return false;
}
bool ok = put_u8(b, dl) && put(b, device, dl) && put_u8(b, pl) && put(b, preset, pl) && put_u8(b, step >= 0);
if (ok && step >= 0) {
ok = put_le16(b, step);
}
if (!ok) {
b->len = save_len;
return false;
}
b->data[0]++;
return true;
}
size_t env_frame(uint8_t *out, int brightness, const env_blob_t *presets, const env_blob_t *select)
{
size_t lp = presets && presets->data[0] ? presets->len : 0;
size_t ls = select && select->data[0] ? select->len : 0;
int wire = 255;
if (brightness >= 0) {
wire = brightness > 255 ? 127 : (brightness * 127 + 127) / 255; // 0-127 scales to 0-255
}
out[0] = lp && presets->v3 ? 3 : 2;
out[1] = wire;
out[2] = lp;
out[3] = ls;
out[4] = 0;
if (lp) {
memcpy(out + 5, presets->data, lp);
}
if (ls) {
memcpy(out + 5 + lp, select->data, ls);
}
return 5 + lp + ls;
}