@openmixer/omx-contract 1.2.1 → 2.0.0

package/include/omxcontract/omx_contract_limits.h

@@ -2,6 +2,7 @@
 // Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
 #ifndef OMX_CONTRACT_LIMITS_H
 #define OMX_CONTRACT_LIMITS_H
+#include <math.h>
 /*
  * GENERATED — DO NOT EDIT BY HAND.
  * Produced by `omx-contract render --target c` from FreeMixer/omx-contract's data/, the declaration
@@ -128,13 +129,43 @@
  * is an integer literal, any other a float literal AND its OMX_<macro>_DOUBLE spelling. */
 #define OMX_ALLPASS_UNITY_TOLERANCE 0.0001f
 #define OMX_ALLPASS_UNITY_TOLERANCE_DOUBLE 0.0001
+#define OMX_BAND_DYN_ATTACK_RANGE_DEFAULT 5
+#define OMX_BAND_DYN_ATTACK_RANGE_MAX 100
+#define OMX_BAND_DYN_ATTACK_RANGE_MIN 0.5f
+#define OMX_BAND_DYN_ATTACK_RANGE_MIN_DOUBLE 0.5
+#define OMX_BAND_DYN_ATTACK_RANGE_STEP 0.1f
+#define OMX_BAND_DYN_ATTACK_RANGE_STEP_DOUBLE 0.1
+#define OMX_BAND_DYN_KNEE_DB 6
+#define OMX_BAND_DYN_MAX_BANDS 9
+#define OMX_BAND_DYN_RANGE_RANGE_DEFAULT -6
+#define OMX_BAND_DYN_RANGE_RANGE_MAX 12
+#define OMX_BAND_DYN_RANGE_RANGE_MIN -24
+#define OMX_BAND_DYN_RANGE_RANGE_STEP 0.5f
+#define OMX_BAND_DYN_RANGE_RANGE_STEP_DOUBLE 0.5
+#define OMX_BAND_DYN_RATIO_RANGE_DEFAULT 2
+#define OMX_BAND_DYN_RATIO_RANGE_MAX 20
+#define OMX_BAND_DYN_RATIO_RANGE_MIN 1
+#define OMX_BAND_DYN_RATIO_RANGE_STEP 0.1f
+#define OMX_BAND_DYN_RATIO_RANGE_STEP_DOUBLE 0.1
+#define OMX_BAND_DYN_RELEASE_RANGE_DEFAULT 100
+#define OMX_BAND_DYN_RELEASE_RANGE_MAX 3000
+#define OMX_BAND_DYN_RELEASE_RANGE_MIN 5
+#define OMX_BAND_DYN_RELEASE_RANGE_STEP 1
+#define OMX_BAND_DYN_THRESHOLD_RANGE_DEFAULT -30
+#define OMX_BAND_DYN_THRESHOLD_RANGE_MAX 0
+#define OMX_BAND_DYN_THRESHOLD_RANGE_MIN -60
+#define OMX_BAND_DYN_THRESHOLD_RANGE_STEP 0.5f
+#define OMX_BAND_DYN_THRESHOLD_RANGE_STEP_DOUBLE 0.5
+#define OMX_BUS_INPUT_CAP 128
 #define OMX_BUTTERWORTH_Q 0.7071067811865476f
 #define OMX_BUTTERWORTH_Q_DOUBLE 0.7071067811865476
+#define OMX_CHORUS_BASE_MS 10
 #define OMX_CHORUS_DEPTH_RANGE_DEFAULT 4
 #define OMX_CHORUS_DEPTH_RANGE_MAX 12
 #define OMX_CHORUS_DEPTH_RANGE_MIN 0
 #define OMX_CHORUS_DEPTH_RANGE_STEP 0.1f
 #define OMX_CHORUS_DEPTH_RANGE_STEP_DOUBLE 0.1
+#define OMX_CHORUS_MAX_MS 22
 #define OMX_CHORUS_MIX_RANGE_DEFAULT 35
 #define OMX_CHORUS_MIX_RANGE_MAX 100
 #define OMX_CHORUS_MIX_RANGE_MIN 0
@@ -157,6 +188,7 @@
 #define OMX_CHORUS_VOICES_RANGE_MAX 4
 #define OMX_CHORUS_VOICES_RANGE_MIN 1
 #define OMX_CHORUS_VOICES_RANGE_STEP 1
+#define OMX_DEEP_PLATEAU_FRAMES 20
 #define OMX_DEESS_ATTACK_RANGE_DEFAULT 1
 #define OMX_DEESS_ATTACK_RANGE_MAX 50
 #define OMX_DEESS_ATTACK_RANGE_MIN 0.1f
@@ -193,6 +225,20 @@
 #define OMX_DEESS_WIDTH_RANGE_MIN_DOUBLE 0.25
 #define OMX_DEESS_WIDTH_RANGE_STEP 0.05f
 #define OMX_DEESS_WIDTH_RANGE_STEP_DOUBLE 0.05
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_CONFIRM_FRAMES 2
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MAX_DIP_DB 0.5f
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MAX_DIP_DB_DOUBLE 0.5
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MAX_SINGLE_FRAME_SHARE 0.5f
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MAX_SINGLE_FRAME_SHARE_DOUBLE 0.5
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MIN_DB_PER_FRAME 0.8f
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MIN_DB_PER_FRAME_DOUBLE 0.8
+#define OMX_DEFAULT_THRESHOLDS_GROWTH_MIN_TOTAL_RISE_DB 6
+#define OMX_DEFAULT_THRESHOLDS_PAPR_DB 18
+#define OMX_DEFAULT_THRESHOLDS_PERSIST_FRAMES 5
+#define OMX_DEFAULT_THRESHOLDS_PHPR_DB 9
+#define OMX_DEFAULT_THRESHOLDS_PNPR_DB 12
+#define OMX_DEFAULT_THRESHOLDS_PSHR_MIN_DB 10
+#define OMX_DEFAULT_THRESHOLDS_SUB_CLEAN_FRAMES 5
 #define OMX_DELAY_MIX_RANGE_BY_KIND_FX_RETURN 1
 #define OMX_DELAY_MIX_RANGE_DEFAULT 0.3f
 #define OMX_DELAY_MIX_RANGE_DEFAULT_DOUBLE 0.3
@@ -204,6 +250,8 @@
 #define OMX_DELAY_TONE_RANGE_MAX 1
 #define OMX_DELAY_TONE_RANGE_MIN 0
 #define OMX_DELAY_TONE_RANGE_STEP 0
+#define OMX_DETECTOR_OVERSAMPLE_AUTO_MS 0.5f
+#define OMX_DETECTOR_OVERSAMPLE_AUTO_MS_DOUBLE 0.5
 #define OMX_DRIVE_AMOUNT_RANGE_DEFAULT 0
 #define OMX_DRIVE_AMOUNT_RANGE_MAX 36
 #define OMX_DRIVE_AMOUNT_RANGE_MIN 0
@@ -231,6 +279,18 @@
 #define OMX_DRIVE_TRIM_RANGE_STEP 0.1f
 #define OMX_DRIVE_TRIM_RANGE_STEP_DOUBLE 0.1
 #define OMX_DSP_KNOB_REFERENCE_RATE 96000
+#define OMX_EQ_BAND_COUNTS_CHANNEL_DEFAULT 4
+#define OMX_EQ_BAND_COUNTS_CHANNEL_MAX 24
+#define OMX_EQ_BAND_COUNTS_EQ16_DEFAULT 16
+#define OMX_EQ_BAND_COUNTS_EQ16_MAX 16
+#define OMX_EQ_BAND_COUNTS_EQ32_DEFAULT 32
+#define OMX_EQ_BAND_COUNTS_EQ32_MAX 32
+#define OMX_EQ_BAND_COUNTS_EQ8_DEFAULT 8
+#define OMX_EQ_BAND_COUNTS_EQ8_MAX 8
+#define OMX_EQ_BAND_COUNTS_STRIP_DEFAULT 4
+#define OMX_EQ_BAND_COUNTS_STRIP_MAX 4
+#define OMX_EQ_BAND_DEFAULTS_GAIN_DB 0
+#define OMX_EQ_BAND_DEFAULTS_Q 1
 #define OMX_EQ_FREQ_RANGE_MAX 20000
 #define OMX_EQ_FREQ_RANGE_MIN 20
 #define OMX_EQ_FREQ_RANGE_STEP 10
@@ -243,14 +303,29 @@
 #define OMX_EQ_NOTCH_Q_RANGE_MIN 0.3f
 #define OMX_EQ_NOTCH_Q_RANGE_MIN_DOUBLE 0.3
 #define OMX_EQ_NOTCH_Q_RANGE_STEP 1
+#define OMX_EQ_PASS_FILTER_DEFAULTS_HPF_FREQ_HZ 80
+#define OMX_EQ_PASS_FILTER_DEFAULTS_LPF_FREQ_HZ 18000
 #define OMX_EQ_Q_RANGE_MAX 8
 #define OMX_EQ_Q_RANGE_MIN 0.3f
 #define OMX_EQ_Q_RANGE_MIN_DOUBLE 0.3
 #define OMX_EQ_Q_RANGE_STEP 0.1f
 #define OMX_EQ_Q_RANGE_STEP_DOUBLE 0.1
+#define OMX_FBS_DEFAULT_MAX_AUTO_BANDS 6
+#define OMX_FBS_DEFAULT_NOTCH_Q 116
+#define OMX_FBS_FLOOR_LIN 1e-12f
+#define OMX_FBS_FLOOR_LIN_DOUBLE 1e-12
+#define OMX_FBS_MAX_NOTCH_DEPTH_DB 18
+#define OMX_FBS_PAPR_GUARD_BINS 2
+#define OMX_FBS_PHPR_HARMONICS 3
+#define OMX_FBS_PNPR_GUARD_BINS 1
+#define OMX_FBS_PNPR_RADIUS_BINS 3
+#define OMX_FBS_PSHR_SELF_SKIP_BINS 3
+#define OMX_FBS_TRACK_SLOTS 512
 #define OMX_FDELAY_MOD_READ_ORDER 3
 #define OMX_FDELAY_READ_L1_NORM 1.25f
 #define OMX_FDELAY_READ_L1_NORM_DOUBLE 1.25
+#define OMX_FLANGER_BASE_MS 0.5f
+#define OMX_FLANGER_BASE_MS_DOUBLE 0.5
 #define OMX_FLANGER_DEPTH_RANGE_DEFAULT 2
 #define OMX_FLANGER_DEPTH_RANGE_MAX 5
 #define OMX_FLANGER_DEPTH_RANGE_MIN 0
@@ -264,6 +339,7 @@
 #define OMX_FLANGER_FEEDBACK_RANGE_MIN_DOUBLE -0.95
 #define OMX_FLANGER_FEEDBACK_RANGE_STEP 0.01f
 #define OMX_FLANGER_FEEDBACK_RANGE_STEP_DOUBLE 0.01
+#define OMX_FLANGER_MAX_MS 6
 #define OMX_FLANGER_MIX_RANGE_DEFAULT 50
 #define OMX_FLANGER_MIX_RANGE_MAX 100
 #define OMX_FLANGER_MIX_RANGE_MIN 0
@@ -296,12 +372,35 @@
 #define OMX_GEQ_BAND_RANGE_STEP_DOUBLE 0.5
 #define OMX_GEQ_DESIGN_GAIN_MAX_DB 30
 #define OMX_GEQ_PROTO_DB 12
+#define OMX_GROWTH_CONFIRM_FRAMES 2
+#define OMX_GROWTH_MAX_DIP_DB 0.5f
+#define OMX_GROWTH_MAX_DIP_DB_DOUBLE 0.5
+#define OMX_GROWTH_MAX_SINGLE_FRAME_SHARE 0.5f
+#define OMX_GROWTH_MAX_SINGLE_FRAME_SHARE_DOUBLE 0.5
+#define OMX_GROWTH_MIN_DB_PER_FRAME 0.8f
+#define OMX_GROWTH_MIN_DB_PER_FRAME_DOUBLE 0.8
+#define OMX_GROWTH_MIN_TOTAL_RISE_DB 6
+#define OMX_GROWTH_WINDOW_FRAMES 5
 #define OMX_HPF_FREQ_RANGE_MAX 1000
 #define OMX_HPF_FREQ_RANGE_MIN 20
 #define OMX_HPF_FREQ_RANGE_STEP 10
+#define OMX_HRP_AMOUNT_RANGE_DEFAULT 0.5f
+#define OMX_HRP_AMOUNT_RANGE_DEFAULT_DOUBLE 0.5
+#define OMX_HRP_AMOUNT_RANGE_MAX 1
+#define OMX_HRP_AMOUNT_RANGE_MIN 0
+#define OMX_HRP_AMOUNT_RANGE_STEP 0
+#define OMX_HRP_ATTRIBUTION_CENTS 60
+#define OMX_HRP_BAND_Q 5
+#define OMX_HRP_COLLISION_CENTS 100
+#define OMX_HRP_DEFAULT_MAX_AUTO_BANDS 8
+#define OMX_HRP_EXCESS_THRESHOLD_DB 3
+#define OMX_HRP_GAIN_STEP_DB 2
+#define OMX_HRP_MAX_CUT_DB 6
+#define OMX_HRP_MAX_VOICES 8
 #define OMX_LPF_FREQ_RANGE_MAX 20000
 #define OMX_LPF_FREQ_RANGE_MIN 1000
 #define OMX_LPF_FREQ_RANGE_STEP 10
+#define OMX_OPERATOR_EQ_BANDS_RESERVE 9
 #define OMX_PAN_RANGE_MAX 1
 #define OMX_PAN_RANGE_MIN -1
 #define OMX_PAN_RANGE_STEP 0
@@ -322,6 +421,7 @@
 #define OMX_PHASER_FEEDBACK_RANGE_MIN_DOUBLE -0.9
 #define OMX_PHASER_FEEDBACK_RANGE_STEP 0.01f
 #define OMX_PHASER_FEEDBACK_RANGE_STEP_DOUBLE 0.01
+#define OMX_PHASER_F_TOP_HZ 16000
 #define OMX_PHASER_MIX_RANGE_DEFAULT 50
 #define OMX_PHASER_MIX_RANGE_MAX 100
 #define OMX_PHASER_MIX_RANGE_MIN 0
@@ -349,11 +449,14 @@
 #define OMX_PROGRAM_RELEASE_PROFILES_OPTO_SHARE_DOUBLE 0.5
 #define OMX_PROGRAM_RELEASE_PROFILES_OPTO_SLOW_MAX_MS 1100
 #define OMX_PROGRAM_RELEASE_PROFILES_OPTO_SLOW_MIN_MS 110
+#define OMX_PSHR_MIN_DB 10
 #define OMX_REVERB_DAMPING_RANGE_DEFAULT 0.5f
 #define OMX_REVERB_DAMPING_RANGE_DEFAULT_DOUBLE 0.5
 #define OMX_REVERB_DAMPING_RANGE_MAX 1
 #define OMX_REVERB_DAMPING_RANGE_MIN 0
 #define OMX_REVERB_DAMPING_RANGE_STEP 0
+#define OMX_REVERB_GATE_ATTACK_MS 1.5f
+#define OMX_REVERB_GATE_ATTACK_MS_DOUBLE 1.5
 #define OMX_REVERB_GATE_THRESHOLD_RANGE_DEFAULT -40
 #define OMX_REVERB_GATE_THRESHOLD_RANGE_MAX 0
 #define OMX_REVERB_GATE_THRESHOLD_RANGE_MIN -80
@@ -460,8 +563,12 @@
 #define OMX_ROTARY_RING_FLOATS 256
 #define OMX_ROTARY_STOP_EPS 0.0001f
 #define OMX_ROTARY_STOP_EPS_DOUBLE 0.0001
+#define OMX_RTA_FFT_SIZE_MAX 32768
+#define OMX_RTA_TARGET_BIN_HZ 5.9f
+#define OMX_RTA_TARGET_BIN_HZ_DOUBLE 5.9
 #define OMX_RT_HARD_TARGET_QUANTUM 128
 #define OMX_RT_HARD_TARGET_RATE 192000
+#define OMX_SUBHARMONIC_RADIUS_BINS 2
 #define OMX_TRANSIENT_FAST_ATTACK_MS 0.5f
 #define OMX_TRANSIENT_FAST_ATTACK_MS_DOUBLE 0.5
 #define OMX_TRANSIENT_FAST_RELEASE_MS 20
@@ -492,11 +599,137 @@
 #define OMX_XOVER_PARTITION_TOLERANCE_DOUBLE 0.00001
 
 /* Every list rendered to C, sorted by list: OMX_<LIST>_COUNT and OMX_<LIST>_INIT { a, b, … }. */
+#define OMX_EQ_CENTRE_SERIES_R20_HZ_COUNT 61u
+#define OMX_EQ_CENTRE_SERIES_R20_HZ_INIT { 20, 22.4f, 25, 28, 31.5f, 35.5f, 40, 45, 50, 56, 63, 71, 80, 90, 100, 112, 125, 140, 160, 180, 200, 224, 250, 280, 315, 355, 400, 450, 500, 560, 630, 710, 800, 900, 1000, 1120, 1250, 1400, 1600, 1800, 2000, 2240, 2500, 2800, 3150, 3550, 4000, 4500, 5000, 5600, 6300, 7100, 8000, 9000, 10000, 11200, 12500, 14000, 16000, 18000, 20000 }
+#define OMX_EQ_DEFAULT_CENTRES_FOUR_BAND_HZ_COUNT 4u
+#define OMX_EQ_DEFAULT_CENTRES_FOUR_BAND_HZ_INIT { 100, 400, 2000, 8000 }
+#define OMX_ISO_THIRD_OCTAVE_CENTRES_HZ_COUNT 31u
+#define OMX_ISO_THIRD_OCTAVE_CENTRES_HZ_INIT { 20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000 }
+#define OMX_ORACLE_FLOOR_RATES_COUNT 4u
+#define OMX_ORACLE_FLOOR_RATES_INIT { 44100, 48000, 96000, 192000 }
 #define OMX_PHASER_STAGE_COUNTS_COUNT 6u
 #define OMX_PHASER_STAGE_COUNTS_INIT { 2, 4, 6, 8, 10, 12 }
+#define OMX_RME_RATES_COUNT 9u
+#define OMX_RME_RATES_INIT { 32000, 44100, 48000, 64000, 88200, 96000, 128000, 176400, 192000 }
 #define OMX_STANDARD_SAMPLE_RATES_COUNT 6u
 #define OMX_STANDARD_SAMPLE_RATES_INIT { 44100, 48000, 88200, 96000, 176400, 192000 }
 
+/* Every set rendered to C, sorted by set: an enum of the ids (a named id's position, or a numeric id's number), `OMX_<SET>_COUNT` and,
+ * where the set names a default, `OMX_<SET>_DEFAULT`. */
+enum omx_band_dyn_modes {
+  OMX_BAND_DYN_MODES_ABOVE = 0,
+  OMX_BAND_DYN_MODES_BELOW = 1,
+};
+#define OMX_BAND_DYN_MODES_COUNT 2u
+#define OMX_BAND_DYN_MODES_DEFAULT OMX_BAND_DYN_MODES_ABOVE
+enum omx_deess_modes {
+  OMX_DEESS_MODES_SPLIT = 0,
+  OMX_DEESS_MODES_WIDEBAND = 1,
+};
+#define OMX_DEESS_MODES_COUNT 2u
+enum omx_drive_bands {
+  OMX_DRIVE_BANDS_FULL = 0,
+  OMX_DRIVE_BANDS_LOW = 1,
+  OMX_DRIVE_BANDS_HIGH = 2,
+  OMX_DRIVE_BANDS_TILT = 3,
+};
+#define OMX_DRIVE_BANDS_COUNT 4u
+enum omx_drive_curves {
+  OMX_DRIVE_CURVES_SOFT = 0,
+  OMX_DRIVE_CURVES_TAPE = 1,
+  OMX_DRIVE_CURVES_TUBE = 2,
+  OMX_DRIVE_CURVES_EXCITER = 3,
+};
+#define OMX_DRIVE_CURVES_COUNT 4u
+enum omx_eq_band_types {
+  OMX_EQ_BAND_TYPES_BELL = 0,
+  OMX_EQ_BAND_TYPES_LOW_SHELF = 1,
+  OMX_EQ_BAND_TYPES_HIGH_SHELF = 2,
+  OMX_EQ_BAND_TYPES_NOTCH = 3,
+  OMX_EQ_BAND_TYPES_ALLPASS1 = 4,
+  OMX_EQ_BAND_TYPES_ALLPASS2 = 5,
+};
+#define OMX_EQ_BAND_TYPES_COUNT 6u
+#define OMX_EQ_BAND_TYPES_DEFAULT OMX_EQ_BAND_TYPES_BELL
+enum omx_filter_slopes {
+  OMX_FILTER_SLOPES_12 = 12,
+  OMX_FILTER_SLOPES_24 = 24,
+};
+#define OMX_FILTER_SLOPES_COUNT 2u
+#define OMX_FILTER_SLOPES_DEFAULT OMX_FILTER_SLOPES_12
+enum omx_gate_key_sources {
+  OMX_GATE_KEY_SOURCES_SELF = 0,
+  OMX_GATE_KEY_SOURCES_SIDECHAIN = 1,
+};
+#define OMX_GATE_KEY_SOURCES_COUNT 2u
+enum omx_param_scales {
+  OMX_PARAM_SCALES_LINEAR = 0,
+  OMX_PARAM_SCALES_LOG = 1,
+  OMX_PARAM_SCALES_STEPPED = 2,
+};
+#define OMX_PARAM_SCALES_COUNT 3u
+#define OMX_PARAM_SCALES_DEFAULT OMX_PARAM_SCALES_LINEAR
+enum omx_reverb_algorithms {
+  OMX_REVERB_ALGORITHMS_ROOM = 0,
+  OMX_REVERB_ALGORITHMS_PLATE = 1,
+  OMX_REVERB_ALGORITHMS_HALL = 2,
+  OMX_REVERB_ALGORITHMS_REVERSE = 3,
+  OMX_REVERB_ALGORITHMS_GATED = 4,
+};
+#define OMX_REVERB_ALGORITHMS_COUNT 5u
+enum omx_rotary_speeds {
+  OMX_ROTARY_SPEEDS_STOP = 0,
+  OMX_ROTARY_SPEEDS_SLOW = 1,
+  OMX_ROTARY_SPEEDS_FAST = 2,
+};
+#define OMX_ROTARY_SPEEDS_COUNT 3u
+enum omx_tremolo_modes {
+  OMX_TREMOLO_MODES_TREMOLO = 0,
+  OMX_TREMOLO_MODES_PAN = 1,
+};
+#define OMX_TREMOLO_MODES_COUNT 2u
+#define OMX_TREMOLO_MODES_DEFAULT OMX_TREMOLO_MODES_TREMOLO
+
+/* The default bands of an EQ with `count` bands: THE one rule, for every strip, host and count (omx-contract's
+ * lib/eq-defaults.mjs; the ts render exports the same as eqDefaultCentres and eqDefaultTypes). Needs -lm. */
+static inline unsigned omx_eq_default_centres(unsigned count, float *out) {
+  static const double r10[] = OMX_ISO_THIRD_OCTAVE_CENTRES_HZ_INIT;
+  static const double r20[] = OMX_EQ_CENTRE_SERIES_R20_HZ_INIT;
+  static const double four[] = OMX_EQ_DEFAULT_CENTRES_FOUR_BAND_HZ_INIT;
+  if (count == 0) return 0;
+  if (count == 4) {
+    for (unsigned i = 0; i < 4; i++) out[i] = (float)four[i];
+    return 4;
+  }
+  const double lo = log((double)OMX_EQ_FREQ_RANGE_MIN);
+  const double span = log((double)OMX_EQ_FREQ_RANGE_MAX / (double)OMX_EQ_FREQ_RANGE_MIN);
+  for (unsigned s = 0; s < 2; s++) {
+    const double *series = s ? r20 : r10;
+    const unsigned n = s ? OMX_EQ_CENTRE_SERIES_R20_HZ_COUNT : OMX_ISO_THIRD_OCTAVE_CENTRES_HZ_COUNT;
+    int distinct = count <= n;
+    for (unsigned i = 0; distinct && i < count; i++) {
+      const double t = lo + span * ((double)i + 0.5) / (double)count;
+      unsigned best = 0;
+      double best_d = 1e300;
+      for (unsigned k = 0; k < n; k++) {
+        const double d = fabs(log(series[k]) - t);
+        if (d < best_d) { best_d = d; best = k; }
+      }
+      out[i] = (float)series[best];
+      if (i > 0 && out[i] == out[i - 1]) distinct = 0;
+    }
+    if (distinct) return count;
+  }
+  return 0;
+}
+
+/* The default type of band `index` of an EQ with `count` bands: a low shelf first, a high shelf last, bells
+ * between (a single band is a bell). An OMX_EQ_BAND_TYPES_* member. */
+static inline int omx_eq_default_type(unsigned index, unsigned count) {
+  if (count < 2) return OMX_EQ_BAND_TYPES_BELL;
+  return index == 0 ? OMX_EQ_BAND_TYPES_LOW_SHELF : index == count - 1 ? OMX_EQ_BAND_TYPES_HIGH_SHELF : OMX_EQ_BAND_TYPES_BELL;
+}
+
 #endif /* OMX_CONTRACT_LIMITS_H */
 
 /* The sample rates the console declares (core's STANDARD_SAMPLE_RATES, row-codecs.ts): the set a

package/lib/data.mjs

@@ -34,8 +34,7 @@ export function loadData(dir, texts) {
     let doc;
     try { doc = JSON.parse(text); } catch (e) { throw new Error(`${rel}: not JSON: ${e.message}`); }
     files.push({ rel, text, doc });
-    for (const [name, item] of Object.entries(doc)) {
-      if (name === '$schema') continue;
+    for (const [name, item] of entriesOf(rel, doc)) {
       if (items.has(name)) throw new Error(`${rel}: ${name}: already declared by ${items.get(name).rel}`);
       items.set(name, { name, rel, item });
     }
@@ -43,6 +42,109 @@ export function loadData(dir, texts) {
   return { files, items };
 }
 
+const snakeOf = (n) => n.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+const camelOf = (u) => u.toLowerCase().replace(/_([a-z0-9])/g, (_, x) => x.toUpperCase());
+
+/** The four sections of a kernel file, in their order. */
+export const KERNEL_SECTIONS = ['controls', 'tables', 'aggregates', 'constants'];
+
+/** Whether a data file is a kernel file (`kernels/<kernel>.json`), which holds the four sections, never an item map. */
+export const isKernelFile = (rel) => /(^|\/)kernels\/[^/]+\.json$/.test(rel);
+
+/** The kernel's upper-case prefix, read off its file name: `kernels/band_dyn.json` is BAND_DYN. */
+export const kernelPrefix = (rel) => rel.replace(/^.*\//, '').replace(/\.json$/, '').toUpperCase().replace(/-/g, '_');
+
+/** A control's item name: its `global`, else <KERNEL>_<NAME>_RANGE for a travel and <KERNEL>_<NAME>S for a choice. */
+export const controlGlobal = (rel, c) => c.global ?? `${kernelPrefix(rel)}_${snakeOf(c.name)}${c.kind === 'choice' ? 'S' : '_RANGE'}`;
+
+/**
+ * A data file's items as [name, item] pairs. A kernel file's four sections are expanded into the items the renders
+ * read: a travel control is a `travels` item named by controlGlobal, a choice a `set`; the controls of one `table`
+ * regroup into that table's `travels` item with `fields`; an aggregate is regenerated as fields that reference its
+ * controls; constants pass through. Any other top-level key of a kernel file is not read (validation names it).
+ * rates.json and primitives.json are item maps, read as they are.
+ */
+export function entriesOf(rel, doc) {
+  if (!isKernelFile(rel)) return Object.entries(doc).filter(([name]) => name !== '$schema');
+  const out = [];
+  const controls = Array.isArray(doc.controls) ? doc.controls : [];
+  const tables = new Map(Object.entries(doc.tables ?? {}).map(([n, meta]) => [n, { kind: 'travels', ...meta, fields: {} }]));
+  for (const c of controls) {
+    const { name, kind, global, table, ...rest } = c;
+    if (table) {
+      if (!tables.has(table)) throw new Error(`${rel}: control ${name} names table ${table}, which is not declared`);
+      tables.get(table).fields[name] = rest.travel;
+      continue;
+    }
+    out.push([controlGlobal(rel, c), kind === 'choice' ? { kind: 'set', ...rest } : { kind: 'travels', ...rest }]);
+  }
+  for (const [n, t] of tables) out.push([n, t]);
+  const byName = new Map(controls.map((c) => [c.name, c]));
+  for (const [n, a] of Object.entries(doc.aggregates ?? {})) {
+    const { fields, ...meta } = a;
+    out.push([n, { kind: 'travels', ...meta, fields: Object.fromEntries((fields ?? []).map((f) => {
+      if (!byName.has(f)) throw new Error(`${rel}: aggregate ${n} names control ${f}, which is not declared`);
+      return [f, { ref: controlGlobal(rel, byName.get(f)) }];
+    })) }]);
+  }
+  for (const [n, item] of Object.entries(doc.constants ?? {})) out.push([n, item]);
+  return out;
+}
+
+const isWholeRef = (v) => typeof v === 'object' && v !== null && Object.keys(v).length === 1 && typeof v.ref === 'string' && !v.ref.includes('.');
+
+/**
+ * The kernel file that declares `entries` ([name, item] pairs, the items entriesOf gives back), the inverse of
+ * entriesOf: a single travel is a travel control and a set a choice; a fields table whose every field IS a single
+ * travel of the kernel (`{ ref }`) is an aggregate, and its field names name those controls; any other fields table
+ * is a table whose fields are its controls; every other item is a constant. A control's `global` is written only
+ * when its name does not derive it. `kept`, a kernel file already written, is extended: its declarations stay as
+ * they are and the entries it lacks are added. Empty sections are left out.
+ * @throws naming the item: a fields table that mixes references and travels, an aggregate field whose name is not
+ * its control's.
+ */
+export function kernelDocOf(rel, entries, kept) {
+  const K = kernelPrefix(rel);
+  const doc = kept ? JSON.parse(JSON.stringify(kept)) : {};
+  doc.controls ??= [];
+  for (const s of KERNEL_SECTIONS.slice(1)) doc[s] ??= {};
+  const declared = new Set(entriesOf(rel, kept ?? {}).map(([n]) => n));
+  const singles = new Map(entries.filter(([, it]) => (it.kind === 'travels' && it.travel) || it.kind === 'set'));
+  for (const c of doc.controls) if (!c.table) singles.set(controlGlobal(rel, c), c);
+  const isAggregate = (it) => it.kind === 'travels' && it.fields && Object.values(it.fields).length > 0 && Object.values(it.fields).every((f) => isWholeRef(f) && singles.get(f.ref)?.travel);
+  // an aggregate's field names are its controls' names
+  const named = new Map();
+  for (const [n, it] of entries) if (isAggregate(it)) for (const [f, t] of Object.entries(it.fields)) named.set(t.ref, f);
+  for (const [n, it] of entries) {
+    if (declared.has(n)) continue;
+    if ((it.kind === 'travels' && it.travel) || it.kind === 'set') {
+      const { kind, ...rest } = it;
+      const ck = kind === 'set' ? 'choice' : 'travel';
+      const suffix = ck === 'choice' ? 'S' : '_RANGE';
+      const derived = n.startsWith(`${K}_`) && n.endsWith(suffix) && n.length > K.length + 1 + suffix.length ? camelOf(n.slice(K.length + 1, -suffix.length)) : undefined;
+      const c = { name: named.get(n) ?? derived ?? camelOf(n.endsWith(suffix) ? n.slice(0, -suffix.length) : n), kind: ck };
+      if (controlGlobal(rel, c) !== n) c.global = n;
+      doc.controls.push({ ...c, ...rest });
+    } else if (it.kind === 'travels' && it.fields && isAggregate(it)) {
+      const { kind, fields, ...meta } = it;
+      doc.aggregates[n] = { ...meta, fields: Object.entries(fields).map(([f, t]) => {
+        const c = doc.controls.find((x) => !x.table && controlGlobal(rel, x) === t.ref) ?? { name: named.get(t.ref) };
+        if (c.name !== f) throw new Error(`${rel}: ${n}.${f} refers to ${t.ref}, whose control is named ${c.name}: an aggregate's field is named by its control`);
+        return f;
+      }) };
+    } else if (it.kind === 'travels' && it.fields) {
+      const { kind, fields, ...meta } = it;
+      if (Object.values(fields).some(isWholeRef)) throw new Error(`${rel}: ${n} mixes fields that refer to single travels with travels of its own: declare it as an aggregate of controls, or as a table`);
+      doc.tables[n] = meta;
+      for (const [f, travel] of Object.entries(fields)) doc.controls.push({ name: f, kind: 'travel', table: n, travel });
+    } else {
+      doc.constants[n] = it;
+    }
+  }
+  for (const s of KERNEL_SECTIONS) if (s === 'controls' ? !doc[s].length : !Object.keys(doc[s]).length) delete doc[s];
+  return doc;
+}
+
 /** An item's own value before resolution, by kind. */
 export function rawValue(item) {
   switch (item.kind) {
@@ -50,6 +152,7 @@ export function rawValue(item) {
     case 'travels': return item.fields ?? item.travel;
     case 'sheet': return item.value;
     case 'list': return item.values;
+    case 'set': return item.ids;
     default: return undefined;
   }
 }
@@ -66,6 +169,11 @@ export const DERIVATIONS = {
     if (typeof v !== 'number' || v < 0) throw new Error(`sqrt: ${JSON.stringify(d.of)} is not a non-negative number`);
     return Math.sqrt(v);
   },
+  ceilSum: (d, val) => {
+    const terms = d.of.map((x) => val(x));
+    if (!terms.every((t) => typeof t === 'number' && Number.isFinite(t))) throw new Error(`ceilSum: ${JSON.stringify(d.of)} holds a term that is not a finite number`);
+    return Math.ceil(terms.reduce((a, t) => a + t, 0));
+  },
   lagrangeReadL1: (d, val) => {
     const order = val(d.order);
     if (!Number.isInteger(order) || order < 1) throw new Error(`lagrangeReadL1: order ${order} is not a positive integer`);
@@ -104,7 +212,7 @@ export function lagrangeReadL1(order) {
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 
 /**
- * Resolve every item: `{ name, rel, kind, doc, why?, unit?, c?, shape?, value }`, where `value` has
+ * Resolve every item: `{ name, rel, kind, doc, why?, unit?, c?, shape?, default?, labels?, value }` (default and labels: a set's), where `value` has
  * every `{ref}` and `{derive}` evaluated.
  * @throws naming the item: a reference that does not resolve, a cycle, an unknown derivation.
  */
@@ -142,6 +250,10 @@ export function resolveData(data) {
     if (item.why !== undefined) r.why = item.why;
     if (item.unit !== undefined) r.unit = item.unit;
     if (item.c !== undefined) r.c = item.c;
+    if (item.kind === 'set') {
+      if (item.default !== undefined) r.default = item.default;
+      if (item.labels !== undefined) r.labels = item.labels;
+    }
     if (item.kind === 'travels') r.shape = item.fields ? 'table' : 'travel';
     r.value = val(rawValue(item), name);
     busy.delete(name);

package/lib/eq-defaults.mjs

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * THE default rule for the bands of a fresh EQ, whatever the strip, the host or the band count: one
+ * rule, no override, for the console, omx-plugins and any other host. Per strip type the contract
+ * declares only the band counts (EQ_BAND_COUNTS: default and maximum); the bands come from here.
+ *
+ * Types   the first band is a low shelf and the last a high shelf (each switchable to a bell by the
+ *         operator); every band between is a bell. A single band is a bell.
+ * Gain, Q every band is EQ_BAND_DEFAULTS.gainDb and .q.
+ * Centres
+ *   4 bands   the declared four (EQ_DEFAULT_CENTRES_FOUR_BAND_HZ): 100, 400, 2000, 8000 Hz,
+ *             ISO 266 preferred values.
+ *   N bands   N slots of equal width on a log axis across EQ_FREQ_RANGE; band i sits in the
+ *             middle of slot i (lo * (hi / lo) ** ((i + 0.5) / N)) and takes the nearest preferred
+ *             frequency on that axis, from the ISO 266 R10 series (ISO_THIRD_OCTAVE_CENTRES_HZ);
+ *             when two bands would share a value in R10 the same is done on its R20 refinement
+ *             (EQ_CENTRE_SERIES_R20_HZ). Never a repeated centre: more bands than R20 holds is an
+ *             error.
+ *
+ * The same functions are exported by the ts render (`eqDefaultCentres`, `eqDefaultTypes`,
+ * `eqDefaultBands`) and the c render (`omx_eq_default_centres`, `omx_eq_default_type`); test/eq-defaults.test.mjs holds the three equal for every count.
+ * This file is the one JavaScript spelling: the ts render embeds its source.
+ */
+
+/**
+ * The default band centres (Hz) of an EQ with `count` bands.
+ * @param {number} count how many bands the strip's EQ starts with, a positive integer.
+ * @param {{ four: number[], series: number[][], lo: number, hi: number }} p the declared four-band
+ *   set, the preferred-frequency series from coarsest to finest, and the band frequency travel.
+ * @returns {number[]}
+ */
+export function eqDefaultCentres(count, p) {
+  if (!Number.isInteger(count) || count < 1) throw new RangeError(`eqDefaultCentres: ${count} is not a band count`);
+  if (count === 4) return [...p.four];
+  const targets = [];
+  for (let i = 0; i < count; i++) targets.push(Math.log(p.lo) + (Math.log(p.hi / p.lo) * (i + 0.5)) / count);
+  for (const series of p.series) {
+    const out = targets.map((t) => {
+      let best = series[0];
+      let bestD = Infinity;
+      for (const f of series) {
+        const d = Math.abs(Math.log(f) - t);
+        if (d < bestD) { bestD = d; best = f; }
+      }
+      return best;
+    });
+    if (new Set(out).size === out.length) return out;
+  }
+  throw new RangeError(`eqDefaultCentres: ${count} bands have no distinct preferred centres across ${p.lo}..${p.hi} Hz`);
+}
+
+/**
+ * The band types of an EQ with `count` bands, by EQ_BAND_TYPES id: a low shelf, bells, a high shelf.
+ * @param {number} count
+ * @returns {string[]}
+ */
+export function eqDefaultTypes(count) {
+  if (!Number.isInteger(count) || count < 1) throw new RangeError(`eqDefaultTypes: ${count} is not a band count`);
+  return Array.from({ length: count }, (_, i) => (count === 1 ? 'bell' : i === 0 ? 'lowShelf' : i === count - 1 ? 'highShelf' : 'bell'));
+}
+
+/**
+ * Every default band of an EQ with `count` bands.
+ * @param {number} count
+ * @param {{ four: number[], series: number[][], lo: number, hi: number, gainDb: number, q: number }} p
+ * @returns {{ type: string, freqHz: number, gainDb: number, q: number }[]}
+ */
+export function eqDefaultBands(count, p) {
+  const types = eqDefaultTypes(count);
+  return eqDefaultCentres(count, p).map((freqHz, i) => ({ type: types[i], freqHz, gainDb: p.gainDb, q: p.q }));
+}
+
+/** The parameters of the rule, read off the resolved items. */
+export function eqDefaultParams(resolved) {
+  const v = (name) => {
+    const r = resolved.get(name);
+    if (!r) throw new Error(`the default centre rule needs ${name}`);
+    return r.value;
+  };
+  const range = v('EQ_FREQ_RANGE');
+  const band = v('EQ_BAND_DEFAULTS');
+  return {
+    four: v('EQ_DEFAULT_CENTRES_FOUR_BAND_HZ'), series: [v('ISO_THIRD_OCTAVE_CENTRES_HZ'), v('EQ_CENTRE_SERIES_R20_HZ')],
+    lo: range.min, hi: range.max, gainDb: band.gainDb, q: band.q,
+  };
+}

package/lib/fmt.mjs

@@ -3,12 +3,15 @@
 /**
  * The one formatting of a data file (spec §3.2): two-space indent, one key per line, keys in schema
  * order, a trailing newline. Names (items, fields, sheet keys) keep the order the author gave them:
- * a travels table's field order is its C block order.
+ * a travels table's field order is its C block order. A kernel file's sections come in their order (controls,
+ * tables, aggregates, constants), its controls in the author's order, each control's keys in schema order.
  */
 
 const ORDER = {
-  item: ['kind', 'doc', 'why', 'unit', 'value', 'values', 'fields', 'travel', 'c'],
-  travel: ['min', 'max', 'step', 'unit', 'default', 'defaultFrom', 'byKind', 'doc', 'why'],
+  control: ['name', 'kind', 'global', 'table', 'since', 'doc', 'why', 'unit', 'ids', 'default', 'labels', 'travel', 'c'],
+  sections: ['controls', 'tables', 'aggregates', 'constants'],
+  item: ['kind', 'since', 'doc', 'why', 'unit', 'value', 'values', 'ids', 'default', 'labels', 'fields', 'travel', 'c'],
+  travel: ['min', 'max', 'step', 'unit', 'default', 'defaultFrom', 'scale', 'byKind', 'doc', 'why'],
   c: ['alias', 'render'],
   alias: ['fact', 'field'],
   number: ['ref', 'derive', 'of', 'order'],
@@ -52,10 +55,27 @@ function item(it) {
   return o;
 }
 
+function control(c) {
+  if (!isObj(c)) return c;
+  const o = ordered(c, ORDER.control);
+  if (isObj(o.travel)) o.travel = travel(o.travel);
+  if (isObj(o.c)) o.c = item({ c: o.c }).c;
+  return o;
+}
+
+const items = (m) => (isObj(m) ? Object.fromEntries(Object.entries(m).map(([k, v]) => [k, item(v)])) : m);
+
 /** The canonical text of a parsed data file. */
 export function formatDoc(doc) {
   const out = {};
   if ('$schema' in doc) out.$schema = doc.$schema;
-  for (const [k, v] of Object.entries(doc)) if (k !== '$schema') out[k] = item(v);
+  if (ORDER.sections.some((k) => k in doc)) {
+    for (const [k, v] of Object.entries(ordered(doc, ORDER.sections))) {
+      if (k === '$schema') continue;
+      out[k] = k === 'controls' && Array.isArray(v) ? v.map(control) : ORDER.sections.includes(k) ? items(v) : item(v);
+    }
+  } else {
+    for (const [k, v] of Object.entries(doc)) if (k !== '$schema') out[k] = item(v);
+  }
   return `${JSON.stringify(out, null, 2)}\n`;
 }