@openmixer/omx-dsp 0.30.1 → 0.32.0

package/dist/meter.js

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * The meter view law, the twin of mix/omx_meter_view.h: how a measured value is drawn, the same on every surface.
+ * The fill of a dB scale from the floor to 0 dBFS, the peak marker that takes a louder value at once and falls by
+ * elapsed time (the same seconds give the same fall at any draw rate, and it falls on silence), the clip word that
+ * stays lit until cleared, the stepped count of an LED ladder with its hysteresis (a bar has no release), the
+ * gain-reduction reading recovered by the time elapsed at the reader's tick (the twin of omx_meter_gr_step), and what a
+ * decimating subscriber keeps. The numbers are METER_VIEW, declared in data/primitives/meter.json. Pinned by
+ * test/meter.test.mjs: against the kernel through the oracle at the nine oracle rates, and against
+ * vectors/meter-view.json, the file every copy of the law reads.
+ */
+import { LIN_TO_DB_FLOOR, METER_DECIMATION, METER_KINDS, METER_MEASUREMENTS, METER_UNITS_LABELS, METER_VIEW } from './definitions.js';
+/** The wire words of the meter sets, in value order: `gain-reduction`, `true-peak`, `lufs-m`…; units as labelled. */
+export const METER_WORDS = {
+    kinds: METER_KINDS.map((id) => id.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)),
+    measurements: METER_MEASUREMENTS.map((id) => id.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)),
+    units: [...METER_UNITS_LABELS],
+};
+/** `x` held to 0..1; NaN reads 0. */
+const unit = (x) => (x > 0 ? (x < 1 ? x : 1) : 0);
+/** The fill of a dB level, linear in dB from `floorDb` (0) to 0 dBFS (1); NaN and -Infinity read 0. Twin of omx_meter_view_fill_db. */
+export function meterFillDb(db, floorDb = METER_VIEW.floorDb) {
+    if (!(db > floorDb))
+        return 0;
+    if (db >= 0)
+        return 1;
+    return (db - floorDb) / -floorDb;
+}
+/** The fill of a linear peak (1 is 0 dBFS) on the same dB scale. Twin of omx_meter_view_fill. */
+export function meterFill(level, floorDb = METER_VIEW.floorDb) {
+    if (!(level > 0))
+        return 0;
+    if (level >= 1)
+        return 1;
+    return meterFillDb(20 * Math.log10(level), floorDb);
+}
+/** A fresh marker: empty. */
+export const METER_MARKER_EMPTY = { peak: 0, elapsedS: 0, live: 0, marker: 0 };
+/**
+ * One draw tick of the peak marker: a fill at or above it is taken at once; below it the marker falls
+ * `fallDbPerSecond` for each second elapsed since it took its value, never under the live fill. `dtS` is the time
+ * since the last tick (negative or NaN counts as 0). Twin of omx_meter_view_step.
+ */
+export function meterMarker(prev, fill, dtS, fallDbPerSecond = METER_VIEW.fallDbPerSecond, floorDb = METER_VIEW.floorDb) {
+    const p = prev ?? METER_MARKER_EMPTY;
+    const f = unit(fill);
+    const elapsedS = p.elapsedS + (dtS > 0 ? dtS : 0);
+    const m = p.peak - (fallDbPerSecond * elapsedS) / -floorDb;
+    if (!(m > f))
+        return { peak: f, elapsedS: 0, live: f, marker: f };
+    return { peak: p.peak, elapsedS, live: f, marker: m };
+}
+/** The clip word for one tick: lit by a clip, and lit until the surface clears it (sets it false). Twin of omx_meter_view_clip. */
+export function meterClip(lit, clip) {
+    return lit || clip;
+}
+/**
+ * A stepped display's count (an LED ladder of `steps` segments) with hysteresis against the count it showed last: it
+ * holds while the unrounded value stays within `0.5 + hysteresis` steps of it. `prevStep` undefined (or negative) is a
+ * fresh or reset strip: plain rounding. Twin of omx_meter_view_ladder.
+ */
+export function meterStep(prevStep, fill, steps, hysteresis = METER_VIEW.stepHysteresis) {
+    const raw = unit(fill) * steps;
+    if (prevStep !== undefined && prevStep >= 0 && Math.abs(raw - prevStep) <= 0.5 + hysteresis)
+        return prevStep;
+    return Math.floor(raw + 0.5);
+}
+/** A stepped BAR for one tick: a linear peak to its fill, then its count against the last one. No release. Twin of omx_meter_view_bar_step. */
+export function meterBarStep(prevStep, level, steps, hysteresis = METER_VIEW.stepHysteresis) {
+    return meterStep(prevStep, meterFill(level), steps, hysteresis);
+}
+/** What a decimating subscriber keeps of two frames (METER_DECIMATION): a level the peak, a gain reduction the deepest; a NaN frame is never kept. Twin of omx_meter_view_decimate. */
+export function meterDecimate(kind, kept, value) {
+    if (METER_DECIMATION[METER_KINDS.indexOf(kind)] === 'deepest')
+        return value < kept ? value : kept;
+    return value > kept ? value : kept;
+}
+const UNIT_OF = { peak: 'dbfs', truePeak: 'dbtp', lufsM: 'lufs', lufsS: 'lufs', lufsI: 'lufs', lra: 'lu' };
+/** The unit a meter's values are in: a level's from its measurement, a gain reduction's dB. Twin of omx_meter_view_unit_of. */
+export function meterUnitOf(kind, measurement) {
+    return kind === 'gainReduction' ? 'db' : UNIT_OF[measurement];
+}
+/** The gain-reduction reading's hold, ms: OMX_METER_GR_HOLD_MS of mix/omx_meter.h (the oracle pins it). */
+export const METER_GR_HOLD_MS = 300;
+/** No reduction, no hold. */
+export const METER_GR_EMPTY = { db: 0, holdLeftS: 0 };
+const f32 = Math.fround;
+/**
+ * One step of a gain-reduction reading over `n` frames at `sr`: a block as deep or deeper replaces it and restarts the
+ * hold; a shallower one spends the hold, then the reading closes on it as a linear gain by `releasePole^n`, and lands
+ * within 0.001 dB. Float arithmetic, as the kernel's. Twin of omx_meter_gr_step.
+ */
+export function meterGrStep(m, blockDb, n, sr, releasePole) {
+    const dt = f32(f32(n) / f32(sr));
+    const b = f32(blockDb);
+    if (b <= m.db)
+        return { db: b, holdLeftS: f32(f32(METER_GR_HOLD_MS) * f32(0.001)) };
+    if (m.holdLeftS > 0)
+        return { db: m.db, holdLeftS: f32(m.holdLeftS - dt) };
+    const pole = f32(releasePole);
+    const k = pole >= 0 && pole < 1 ? f32(Math.pow(pole, f32(n))) : 0;
+    const lin = (db) => f32(Math.pow(10, f32(db * f32(0.05))));
+    const want = lin(b);
+    const g = f32(want + f32(f32(lin(m.db) - want) * k));
+    let db = f32(f32(20) * f32(Math.log10(g < f32(LIN_TO_DB_FLOOR.lin) ? f32(LIN_TO_DB_FLOOR.lin) : g)));
+    if (!(db < f32(b - f32(0.001))))
+        db = b;
+    return { db, holdLeftS: m.holdLeftS };
+}
+/** The gain-reduction reading at the reader's tick: meterGrStep over the frames `dtS` seconds cover at `sr`. Twin of omx_meter_view_gr. */
+export function meterGrView(m, deepestDb, dtS, sr, releasePole) {
+    return meterGrStep(m, deepestDb, dtS > 0 ? Math.floor(dtS * sr + 0.5) : 0, sr, releasePole);
+}

package/oracle/ts-twin-oracle.c

@@ -31,9 +31,11 @@
 #include <omxdsp/analysis/omx_room.h>
 #include <omxdsp/analysis/omx_rta.h>
 #include <omxdsp/fx/omx_eq_instance.h>
+#include <omxdsp/mix/omx_meter_view.h>
 #include <omxdsp/mix/omx_pan_law.h>
 #include <omxdsp/omx_balance_law.h>
 #include <omxdsp/omx_contract.h>
+#include <omxdsp/omx_curve.h>
 #include <omxdsp/omx_dyn.h>
 #include <omxdsp/omx_eq_design.h>
 #include <omxdsp/omx_magnitude.h>
@@ -136,6 +138,108 @@ static int h_eq_magnitude_sum_db(const double *in, int n, double *out) {
   return 1;
 }
 
+/* curve_points: kind family rate points has_extents x_min x_max nterms { role index value unit shape }*nterms
+ *               -> code count { x y }*count (shape -1 for none; the enums are omx_curve.h's, by value) */
+static int h_curve_points(const double *in, int n, double *out) {
+  if (n < 8) return -1;
+  const int nt = (int)in[7];
+  if (nt < 0 || nt > 512 || n != 8 + 5 * nt) return -1;
+  static struct omx_curve_term terms[512];
+  for (int i = 0; i < nt; i++) {
+    const double *t = in + 8 + 5 * i;
+    terms[i].role = (enum omx_curve_roles)(int)t[0];
+    terms[i].index = (uint32_t)t[1];
+    terms[i].value = t[2];
+    terms[i].unit = (enum omx_curve_units)(int)t[3];
+    terms[i].shape = (int)t[4];
+    terms[i].origin = OMX_CURVE_ORIGINS_USER;
+  }
+  const struct omx_curve_request rq = {(enum omx_curve_displays)(int)in[0], (enum omx_curve_families)(int)in[1], in[2],
+                                       (uint32_t)in[3], in[4] != 0.0, in[5], in[6], terms, (uint32_t)nt, 0};
+  double x[OMX_CURVE_POINTS_MAX], y[OMX_CURVE_POINTS_MAX];
+  int code = -1;
+  const uint32_t cnt = omx_curve_points(&rq, x, y, OMX_CURVE_POINTS_MAX, &code);
+  out[0] = code;
+  out[1] = cnt;
+  for (uint32_t i = 0; i < cnt; i++) {
+    out[2 + 2 * i] = x[i];
+    out[3 + 2 * i] = y[i];
+  }
+  return 2 + 2 * (int)cnt;
+}
+
+/* curve_points_marked: kind family rate points has_extents x_min x_max user_only nterms
+ *                      { role index value unit shape origin }*nterms
+ *                      -> code count { x y }*count nmarks { freq depth_db q origin }*nmarks [{ y_user }*count] */
+static int h_curve_points_marked(const double *in, int n, double *out) {
+  if (n < 9) return -1;
+  const int nt = (int)in[8];
+  if (nt < 0 || nt > 512 || n != 9 + 6 * nt) return -1;
+  static struct omx_curve_term terms[512];
+  for (int i = 0; i < nt; i++) {
+    const double *t = in + 9 + 6 * i;
+    terms[i].role = (enum omx_curve_roles)(int)t[0];
+    terms[i].index = (uint32_t)t[1];
+    terms[i].value = t[2];
+    terms[i].unit = (enum omx_curve_units)(int)t[3];
+    terms[i].shape = (int)t[4];
+    terms[i].origin = (enum omx_curve_origins)(int)t[5];
+  }
+  const struct omx_curve_request rq = {(enum omx_curve_displays)(int)in[0], (enum omx_curve_families)(int)in[1], in[2],
+                                       (uint32_t)in[3], in[4] != 0.0, in[5], in[6], terms, (uint32_t)nt, in[7] != 0.0};
+  double x[OMX_CURVE_POINTS_MAX], y[OMX_CURVE_POINTS_MAX], yu[OMX_CURVE_POINTS_MAX];
+  struct omx_curve_mark marks[OMX_CURVE_BANDS_MAX];
+  struct omx_curve_extra ex = {yu, marks, OMX_CURVE_BANDS_MAX, 0u};
+  int code = -1;
+  const uint32_t cnt = omx_curve_points_marked(&rq, x, y, OMX_CURVE_POINTS_MAX, &ex, &code);
+  int k = 0;
+  out[k++] = code;
+  out[k++] = cnt;
+  for (uint32_t i = 0; i < cnt; i++) {
+    out[k++] = x[i];
+    out[k++] = y[i];
+  }
+  out[k++] = cnt ? ex.nmarks : 0;
+  for (uint32_t i = 0; cnt && i < ex.nmarks; i++) {
+    out[k++] = marks[i].freq_hz;
+    out[k++] = marks[i].depth_db;
+    out[k++] = marks[i].q;
+    out[k++] = marks[i].origin;
+  }
+  if (cnt && rq.user_only)
+    for (uint32_t i = 0; i < cnt; i++) out[k++] = yu[i];
+  return k;
+}
+
+/* gaincomp_db: mode thresh_db ratio knee_db range_db level_db -> dB (float, the per-sample form) */
+static int h_gaincomp_db(const double *in, int n, double *out) {
+  if (n != 6) return -1;
+  const struct omx_gaincomp_params p = {(int)in[0], (float)in[1], (float)in[2], (float)in[3], (float)in[4], 1.0f};
+  out[0] = omx_gaincomp_db(&p, (float)in[5]);
+  return 1;
+}
+
+/* gaincomp_db_shifted: thresh_db ratio knee_db range_db shift_db level_db -> dB (float, BELOW mode) */
+static int h_gaincomp_db_shifted(const double *in, int n, double *out) {
+  if (n != 6) return -1;
+  const struct omx_gaincomp_params p = {OMX_DYN_BELOW, (float)in[0], (float)in[1], (float)in[2], (float)in[3], 1.0f};
+  out[0] = omx_gaincomp_db_shifted(&p, (float)in[4], (float)in[5]);
+  return 1;
+}
+
+/* gate_knee: thresh_db knee_start_db knee_end_db -> knee_db shift_db (float) */
+static int h_gate_knee(const double *in, int n, double *out) {
+  if (n != 3) return -1;
+  struct omx_dyn d;
+  memset(&d, 0, sizeof d);
+  d.gc.mode = OMX_DYN_BELOW;
+  d.gc.thresh_db = (float)in[0];
+  omx_gate_knee(&d, (float)in[1], (float)in[2]);
+  out[0] = d.gc.knee_db;
+  out[1] = d.knee_shift_db;
+  return 2;
+}
+
 /* hrp_cut_db: excess_db amount max_cut_db -> cut_db (float) */
 static int h_hrp_cut_db(const double *in, int n, double *out) {
   if (n != 3) return -1;
@@ -300,6 +404,86 @@ static int h_room_mode_set_stable(const double *in, int n, double *out) {
   return 1;
 }
 
+/* meter_view_fill_db: db floor_db -> fill */
+static int h_meter_view_fill_db(const double *in, int n, double *out) {
+  if (n != 2) return -1;
+  out[0] = omx_meter_view_fill_db(in[0], in[1]);
+  return 1;
+}
+
+/* meter_view_fill: level floor_db -> fill */
+static int h_meter_view_fill(const double *in, int n, double *out) {
+  if (n != 2) return -1;
+  out[0] = omx_meter_view_fill(in[0], in[1]);
+  return 1;
+}
+
+/* meter_view_step: fall_db_per_s floor_db { fill dt_s }*k -> the marker at each tick, from a fresh view */
+static int h_meter_view_step(const double *in, int n, double *out) {
+  if (n < 2 || (n - 2) % 2 != 0) return -1;
+  struct omx_meter_view v = {0};
+  const int k = (n - 2) / 2;
+  for (int i = 0; i < k; i++) out[i] = omx_meter_view_step(&v, in[2 + 2 * i], in[3 + 2 * i], in[0], in[1]);
+  return k;
+}
+
+/* meter_view_clip: { clip clear }*k -> the clip word at each tick (a clear is taken before the tick's clip) */
+static int h_meter_view_clip(const double *in, int n, double *out) {
+  if (n % 2 != 0) return -1;
+  struct omx_meter_view v = {0};
+  for (int i = 0; i < n / 2; i++) {
+    if (in[2 * i + 1] != 0.0) omx_meter_view_clip_clear(&v);
+    out[i] = omx_meter_view_clip(&v, in[2 * i] != 0.0);
+  }
+  return n / 2;
+}
+
+/* meter_view_ladder: steps hysteresis prev fill -> count (prev negative: none) */
+static int h_meter_view_ladder(const double *in, int n, double *out) {
+  if (n != 4) return -1;
+  out[0] = omx_meter_view_ladder((int32_t)in[2], in[3], (uint32_t)in[0], in[1]);
+  return 1;
+}
+
+/* meter_view_bar_step: steps prev level -> count */
+static int h_meter_view_bar_step(const double *in, int n, double *out) {
+  if (n != 3) return -1;
+  out[0] = omx_meter_view_bar_step((int32_t)in[1], in[2], (uint32_t)in[0]);
+  return 1;
+}
+
+/* meter_view_decimate: kind kept value -> kept */
+static int h_meter_view_decimate(const double *in, int n, double *out) {
+  if (n != 3) return -1;
+  out[0] = omx_meter_view_decimate((enum omx_meter_kinds)(int)in[0], in[1], in[2]);
+  return 1;
+}
+
+/* meter_view_gr: rate pole { deepest_db dt_s }*k -> the reading at each tick, from no reduction */
+static int h_meter_view_gr(const double *in, int n, double *out) {
+  if (n < 2 || (n - 2) % 2 != 0) return -1;
+  struct omx_meter_gr m = {0.0f, 0.0f};
+  const int k = (n - 2) / 2;
+  for (int i = 0; i < k; i++)
+    out[i] = (double)omx_meter_view_gr(&m, (float)in[2 + 2 * i], in[3 + 2 * i], (float)in[0], (float)in[1]);
+  return k;
+}
+
+/* meter_view_unit_of: kind measurement -> unit (METER_UNITS position; the count for none) */
+static int h_meter_view_unit_of(const double *in, int n, double *out) {
+  if (n != 2) return -1;
+  out[0] = (double)omx_meter_view_unit_of((enum omx_meter_kinds)(int)in[0], (enum omx_meter_measurements)(int)in[1]);
+  return 1;
+}
+
+/* meter_gr_hold_ms: -> OMX_METER_GR_HOLD_MS */
+static int h_meter_gr_hold_ms(const double *in, int n, double *out) {
+  (void)in;
+  if (n != 0) return -1;
+  out[0] = (double)OMX_METER_GR_HOLD_MS;
+  return 1;
+}
+
 static const struct {
   const char *name;
   handler fn;
@@ -312,6 +496,11 @@ static const struct {
     {"eq_pass", h_eq_pass},
     {"eq_band_magnitude_db", h_eq_band_magnitude_db},
     {"eq_magnitude_sum_db", h_eq_magnitude_sum_db},
+    {"curve_points", h_curve_points},
+    {"curve_points_marked", h_curve_points_marked},
+    {"gaincomp_db", h_gaincomp_db},
+    {"gaincomp_db_shifted", h_gaincomp_db_shifted},
+    {"gate_knee", h_gate_knee},
     {"hrp_cut_db", h_hrp_cut_db},
     {"hrp_resonance_score", h_hrp_resonance_score},
     {"hrp_cents_between", h_hrp_cents_between},
@@ -327,6 +516,16 @@ static const struct {
     {"room_mode_eq_proposals", h_room_mode_eq_proposals},
     {"room_mode_residual_db", h_room_mode_residual_db},
     {"room_mode_set_stable", h_room_mode_set_stable},
+    {"meter_view_fill_db", h_meter_view_fill_db},
+    {"meter_view_fill", h_meter_view_fill},
+    {"meter_view_step", h_meter_view_step},
+    {"meter_view_clip", h_meter_view_clip},
+    {"meter_view_ladder", h_meter_view_ladder},
+    {"meter_view_bar_step", h_meter_view_bar_step},
+    {"meter_view_decimate", h_meter_view_decimate},
+    {"meter_view_gr", h_meter_view_gr},
+    {"meter_view_unit_of", h_meter_view_unit_of},
+    {"meter_gr_hold_ms", h_meter_gr_hold_ms},
 };
 
 /* The kernels the table answers, for a test that asks "is the oracle really here". */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmixer/omx-dsp",
-  "version": "0.30.1",
+  "version": "0.32.0",
   "description": "The TypeScript twins of omx-dsp kernels, each pinned to its C kernel by an agreement test, and the oracle that pins them",
   "type": "module",
   "license": "GPL-3.0-or-later",

package/src/curve.ts

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * curvePoints, the twin of omx_curve_points (omx_curve.h): a panel description's display, bound to the current
+ * values and a rate, to its points. The same words (the description's display, family, role, unit and shape
+ * words) and the same codes (CURVE_CODES), checked in the same order. Pinned by test/agreement.test.mjs at the
+ * nine oracle rates: the EQ through the magnitude twins, the transfer curves through the gain computer twins.
+ */
+import {
+  COMP_KNEE_DB_RANGE,
+  COMP_RATIO_RANGE,
+  CURVE_CODES,
+  CURVE_DISPLAYS,
+  CURVE_EXTENTS,
+  CURVE_FAMILIES,
+  CURVE_ORIGINS,
+  CURVE_POINTS_MAX,
+  CURVE_ROLES,
+  CURVE_SHAPES,
+  CURVE_UNITS,
+  EQ_BAND_DEFAULTS,
+  GATE_RANGE_DB_RANGE,
+  GATE_RATIO_RANGE,
+  LIN_TO_DB_FLOOR,
+} from './definitions.js';
+import { clampEqQFor, magnitudeSumDb, octavesToQ, type BiquadBand, type BiquadType } from './eq.js';
+import { gaincompDb, gaincompDbShifted, gateKnee } from './gaincomp.js';
+
+/** A set id as the description spells it: `eqResponse` is `eq_response`; the unshaped band is `-`. */
+const wordOf = (id: string): string => (id === 'unshaped' ? '-' : id.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`));
+
+/** The wire words of each set, in value order. */
+export const CURVE_WORDS = {
+  displays: CURVE_DISPLAYS.map(wordOf),
+  families: CURVE_FAMILIES.map(wordOf),
+  roles: CURVE_ROLES.map(wordOf),
+  units: CURVE_UNITS.map(wordOf),
+  shapes: CURVE_SHAPES.map(wordOf),
+  /** fbs-fixed and fbs-live: the origins are spelt with a hyphen */
+  origins: CURVE_ORIGINS.map((id) => id.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)),
+} as const;
+
+/** What curvePoints answers when it draws nothing: a CURVE_CODES id other than `ok`. */
+export type CurveCode = Exclude<(typeof CURVE_CODES)[number], 'ok'>;
+
+/** One bound term: a role of the description, its value now, in the unit the description gives it. */
+export interface CurveTerm {
+  /** The role word: `band_freq`, `threshold`, `knee_start`… */
+  readonly role: string;
+  /** The band's index for a `band_*` role; 0 (or absent) for any other. */
+  readonly index?: number;
+  /** The control's plain value. */
+  readonly value: number;
+  /** The unit token: `hz`, `khz`, `db`, `coef`, `oct`, `none`… */
+  readonly unit: string;
+  /** For `band_type`, the shape its value selects (from the role's `shapes`); for `band_freq`, the fixed shape. */
+  readonly shape?: string;
+  /** Where the band comes from: `user` (the default), `fbs-fixed` or `fbs-live`. A band's is its band_freq term's. */
+  readonly origin?: string;
+}
+
+/** A curve request: one display of the description, bound. */
+export interface CurveRequest {
+  /** The display's kind: `eq_response` or `transfer_curve`. */
+  readonly kind: string;
+  /** The family: `eq`, `dynamics`, `limiter`, `gate` or `deesser`. */
+  readonly family: string;
+  /** The instance's rate, Hz. */
+  readonly sampleRate: number;
+  /** The grid points, 2 to CURVE_POINTS_MAX (an EQ's anchors on top). */
+  readonly points: number;
+  /** The x extents; CURVE_EXTENTS when absent. */
+  readonly extents?: { readonly min: number; readonly max: number };
+  /** The terms; a later term of one role and index replaces an earlier. */
+  readonly terms: readonly CurveTerm[];
+  /** Also answer the curve over the `user` bands alone, at the same x. */
+  readonly userOnly?: boolean;
+}
+
+/** A band whose origin is not `user`: its centre (Hz), its own magnitude there (dB), its Q and its origin. */
+export interface CurveMark {
+  readonly freq: number;
+  readonly depthDb: number;
+  readonly q: number;
+  readonly origin: string;
+}
+
+/** One point: Hz and dB for an EQ, input dB and output dB for a transfer curve. */
+export interface CurvePoint {
+  readonly x: number;
+  readonly y: number;
+}
+
+/** The answer: the points, ascending in x, or the code of what is missing or refused. */
+export type CurveAnswer =
+  | {
+      readonly points: readonly CurvePoint[];
+      /** One per drawn band whose origin is not `user`, in band order; none for a transfer curve. */
+      readonly marks: readonly CurveMark[];
+      /** With `userOnly`: the curve over the user bands (and the head filters) alone, at the same x. */
+      readonly userPoints?: readonly CurvePoint[];
+    }
+  | { readonly code: CurveCode };
+
+/** The units each role converts from (omx_curve_unit_accepted). */
+const ACCEPTS: Readonly<Record<string, readonly string[]>> = {
+  band_freq: ['hz', 'khz'], hpf_freq: ['hz', 'khz'], lpf_freq: ['hz', 'khz'],
+  band_gain: ['db', 'coef'],
+  band_q: ['none', 'coef', 'oct'],
+  band_type: ['none'], band_on: ['none'], hpf_on: ['none'], lpf_on: ['none'],
+  hpf_slope: ['none', 'db'], lpf_slope: ['none', 'db'],
+  threshold: ['db', 'dbfs', 'dbu', 'lufs'],
+  ratio: ['ratio', 'coef'],
+  knee: ['db'], makeup: ['db'], range: ['db'], knee_start: ['db'], knee_end: ['db'],
+};
+
+/** omx_lin_to_db: a linear factor to dB, floored at LIN_TO_DB_FLOOR. */
+const linToDb = (lin: number): number => {
+  const v = Math.fround(lin);
+  return Math.fround(20 * Math.log10(v < Math.fround(LIN_TO_DB_FLOOR.lin) ? Math.fround(LIN_TO_DB_FLOOR.lin) : v));
+};
+
+/** A term's value in the model's unit (omx_curve_term_value). */
+const valueOf = (t: CurveTerm): number => {
+  switch (t.unit) {
+    case 'khz': return t.value * 1000;
+    case 'coef': return t.role === 'band_gain' ? linToDb(t.value) : t.value;
+    case 'oct': return octavesToQ(t.value);
+    default: return t.value;
+  }
+};
+
+const SHAPE_TYPE: Readonly<Record<string, BiquadType>> = {
+  bell: 'bell', lowshelf: 'lowshelf', highshelf: 'highshelf', highpass: 'highpass', lowpass: 'lowpass', notch: 'notch',
+  allpass1: 'allpass1', allpass2: 'allpass2',
+};
+
+/** The Q of each section of a Butterworth head filter (omx_eq_butterworth_qs): 12 dB/oct one at 1/sqrt(2), 24 dB/oct
+ *  two whose product is maximally flat, the kernel's own digits. */
+export function butterworthQs(slope24: boolean): readonly number[] {
+  return slope24 ? [0.5411961, 1.306563] : [Math.SQRT1_2];
+}
+
+/** The frequencies a drawn curve is sampled at (omx_eq_curve_freqs): the log grid and the bands' anchors inside it,
+ *  ascending. */
+function curveFreqs(bands: readonly BiquadBand[], fMin: number, fMax: number, points: number): number[] {
+  const g = Math.max(points, 2);
+  const out: number[] = [];
+  for (let i = 0; i < g; i++) out.push(fMin * Math.pow(fMax / fMin, i / (g - 1)));
+  for (const b of bands) {
+    const half = b.freq / (2 * (b.q > 0.1 ? b.q : 0.1));
+    for (const a of [b.freq - half, b.freq, b.freq + half]) if (a > fMin && a < fMax) out.push(a);
+  }
+  for (let i = 1; i < out.length; i++) {
+    const v = out[i];
+    let j = i;
+    for (; j > 0 && out[j - 1] > v; j--) out[j] = out[j - 1];
+    out[j] = v;
+  }
+  return out;
+}
+
+/**
+ * The points of one display of a panel description: the twin of omx_curve_points, the same checks in the same
+ * order, the same codes.
+ * @param rq The request.
+ */
+export function curvePoints(rq: CurveRequest): CurveAnswer {
+  const eq = rq.kind === 'eq_response';
+  if (!(eq ? rq.family === 'eq' : rq.kind === 'transfer_curve' && rq.family !== 'eq' && CURVE_WORDS.families.includes(rq.family)))
+    return { code: 'kindUnknown' };
+  if (!Number.isInteger(rq.points) || rq.points < 2 || rq.points > CURVE_POINTS_MAX) return { code: 'pointsRange' };
+  if (!Number.isFinite(rq.sampleRate) || !(rq.sampleRate > 0) || (rq.extents && !(Number.isFinite(rq.extents.min) && Number.isFinite(rq.extents.max))))
+    return { code: 'valueNotFinite' };
+  if (rq.terms.some((t) => !Number.isFinite(t.value))) return { code: 'valueNotFinite' };
+  if (rq.terms.some((t) => !ACCEPTS[t.role]?.includes(t.unit) || !CURVE_WORDS.origins.includes(t.origin ?? 'user')))
+    return { code: 'unitRefused' };
+  let lo: number, hi: number;
+  if (rq.extents) [lo, hi] = [rq.extents.min, rq.extents.max];
+  else if (eq) [lo, hi] = [CURVE_EXTENTS.freqMinHz, Math.min(CURVE_EXTENTS.freqMaxHz, (CURVE_EXTENTS.nyquistFraction * rq.sampleRate) / 2)];
+  else [lo, hi] = [CURVE_EXTENTS.levelMinDb, CURVE_EXTENTS.levelMaxDb];
+  if (!(hi > lo) || (eq && !(lo > 0))) return { code: 'pointsRange' };
+  const find = (role: string, index = 0): CurveTerm | undefined => {
+    let found: CurveTerm | undefined;
+    for (const t of rq.terms) if (t.role === role && (t.index ?? 0) === index) found = t;
+    return found;
+  };
+  return eq ? eqPoints(rq, find, lo, hi) : transferPoints(rq, find, lo, hi);
+}
+
+type Find = (role: string, index?: number) => CurveTerm | undefined;
+
+const BANDS_MAX = Math.floor((CURVE_POINTS_MAX - 2) / 3);
+const BAND_ROLES = ['band_type', 'band_freq', 'band_gain', 'band_q', 'band_on'];
+
+function eqPoints(rq: CurveRequest, find: Find, lo: number, hi: number): CurveAnswer {
+  let nb = 0;
+  for (const t of rq.terms) {
+    if (!BAND_ROLES.includes(t.role)) continue;
+    const i = t.index ?? 0;
+    if (i >= BANDS_MAX) return { code: 'pointsRange' };
+    nb = Math.max(nb, i + 1);
+  }
+  const bands: BiquadBand[] = [];
+  const origin: string[] = [];
+  for (let b = 0; b < nb; b++) {
+    const type = find('band_type', b), freq = find('band_freq', b), gain = find('band_gain', b), q = find('band_q', b), on = find('band_on', b);
+    if (!type && !freq && !gain && !q && !on) continue;
+    if (!freq) return { code: 'termMissing' };
+    const shape = type?.shape ?? freq.shape;
+    if (shape === undefined) return { code: 'termMissing' };
+    const kind = SHAPE_TYPE[shape];
+    if (!kind) continue; // off, or a choice with no shape (`-`): not drawn
+    const gains = kind === 'bell' || kind === 'lowshelf' || kind === 'highshelf';
+    if (gains && !gain) return { code: 'termMissing' };
+    if (on && valueOf(on) === 0) continue;
+    bands.push({ type: kind, freq: valueOf(freq), gainDb: gains && gain ? valueOf(gain) : 0,
+      // no Q control: the declared default (EQ_BAND_DEFAULTS), clamped for the shape as the kernel clamps it
+      q: q ? valueOf(q) : Math.fround(clampEqQFor(kind === 'notch' ? 'notch' : 'bell', EQ_BAND_DEFAULTS.q)) });
+    origin.push(freq.origin ?? 'user');
+  }
+  const pass: BiquadBand[] = [];
+  let present = false;
+  for (const [type, pre] of [['highpass', 'hpf'], ['lowpass', 'lpf']] as const) {
+    const fr = find(`${pre}_freq`), sl = find(`${pre}_slope`), on = find(`${pre}_on`);
+    if (!fr && !sl && !on) continue;
+    present = true;
+    // the slope in dB per octave, from the role's declared enumeration or a dB control; a bare choice value is none
+    if (!fr || !sl || sl.unit !== 'db') return { code: 'termMissing' };
+    const slope = valueOf(sl);
+    if (slope !== 12 && slope !== 24) return { code: 'kindUnknown' };
+    if (on && valueOf(on) === 0) continue;
+    const corner = valueOf(fr);
+    if (corner > 0) for (const q of butterworthQs(slope === 24)) pass.push({ type, freq: corner, gainDb: 0, q });
+  }
+  if (nb === 0 && !present) return { code: 'termMissing' };
+  const drawn = [...bands, ...pass];
+  if (rq.points + 3 * drawn.length > CURVE_POINTS_MAX) return { code: 'pointsRange' };
+  const top = (rq.sampleRate / 2) * 0.999;
+  const xs = curveFreqs(drawn, lo, hi, rq.points);
+  const sum = (set: readonly BiquadBand[]) =>
+    xs.map((x) => ({ x, y: magnitudeSumDb(set, x < top ? x : top, rq.sampleRate, CURVE_EXTENTS.eqFloorDb) }));
+  const marks = bands.flatMap((b, i) =>
+    origin[i] === 'user' ? [] : [{ freq: b.freq, depthDb: magnitudeSumDb([b], b.freq, rq.sampleRate, CURVE_EXTENTS.eqFloorDb), q: b.q, origin: origin[i] }]);
+  const points = sum(drawn);
+  if (!rq.userOnly) return { points, marks };
+  return { points, marks, userPoints: sum([...bands.filter((_, i) => origin[i] === 'user'), ...pass]) };
+}
+
+function transferPoints(rq: CurveRequest, find: Find, lo: number, hi: number): CurveAnswer {
+  const below = rq.family === 'gate';
+  const thr = find('threshold'), ratio = find('ratio'), knee = find('knee'), makeup = find('makeup'), range = find('range');
+  const ks = find('knee_start'), ke = find('knee_end');
+  // a limiter has no ratio role: the dynamics form at ratio infinity, a hard corner at the threshold
+  const limiter = rq.family === 'limiter';
+  if (!thr || (!ratio && !limiter) || (below && !range) || (below && !ks !== !ke)) return { code: 'termMissing' };
+  const f = Math.fround;
+  const r = ratio ? f(valueOf(ratio)) : Infinity, k = knee ? f(valueOf(knee)) : 0;
+  const rmin = f(below ? GATE_RATIO_RANGE.min : COMP_RATIO_RANGE.min);
+  const thresh = f(valueOf(thr));
+  let kneeDb = k < COMP_KNEE_DB_RANGE.min ? COMP_KNEE_DB_RANGE.min : k;
+  let shiftDb = 0;
+  let rangeDb = 0;
+  if (below && range) {
+    const rg = f(valueOf(range));
+    rangeDb = rg > GATE_RANGE_DB_RANGE.max ? GATE_RANGE_DB_RANGE.max : rg;
+    if (ks && ke) ({ kneeDb, shiftDb } = gateKnee(thresh, valueOf(ks), valueOf(ke)));
+  }
+  const p = { mode: below ? ('below' as const) : ('above' as const), threshDb: thresh, ratio: r < rmin ? rmin : r, kneeDb, rangeDb };
+  const mk = makeup ? valueOf(makeup) : 0;
+  const n = rq.points;
+  const points: CurvePoint[] = [];
+  for (let i = 0; i < n; i++) {
+    const lv = i + 1 === n ? hi : lo + ((hi - lo) * i) / (n - 1);
+    const g = below ? gaincompDbShifted(p, shiftDb, lv) : gaincompDb(p, lv);
+    points.push({ x: lv, y: lv + g + mk });
+  }
+  return rq.userOnly ? { points, marks: [], userPoints: points } : { points, marks: [] };
+}