Files
BetterDSPControl/tools/dsp_measure.py
T
GivouandClaude Opus 5.5 63b3c17fb7 DJ Brake: use the offset measured on a real DSP 204
Measured: limiter threshold minus output meter is about 26 dB when the limiter
starts (25.1 to 27.7, one DSP 204, one output, one piece of music), and the meter
is after the output gain. So the distance is right before the first hit.
The limiter flag also stayed on after raising a threshold, which would have
taught a false value: only limiters starting by themselves teach now.
The measuring tool no longer draws conclusions the data doesn't carry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 21:54:29 +01:00

278 lines
13 KiB
Python

"""Finds out how a real DSP's output meter relates to its limiter threshold and output gain.
Play steady music into the DSP, close every other control software and run:
python tools/dsp_measure.py --usb
python tools/dsp_measure.py --host 192.168.1.101
It only ever lowers one output's gain (by 6 dB) and limiter threshold, never raises anything above where it was, stores
nothing in a preset slot and puts both back at the end, also on Ctrl+C. A preset export is written first as a backup.
Takes about two minutes. The result goes to dsp-measure-<time>.json.
"""
import argparse
import asyncio
import json
import math
import signal
import statistics
import sys
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from dsp import preset # noqa: E402
from dsp import protocol as P # noqa: E402
from dsp.device import Device # noqa: E402
SIGNAL_MIN_DB = -50.0
THRESHOLD_FLOOR = 60 # raw, -60 dB: below that something is wrong
def db(power: float) -> float:
return 10 * math.log10(power) if power > 1e-12 else -120.0
class Run:
def __init__(self, dev: Device):
self.dev = dev
self.polls: list[dict] = []
self.o = 0
self.ins: list[int] = []
self.gain = None # known once the output is chosen
self.thr = None
def on_event(self, ev: dict):
if ev["type"] == "meters" and self.dev.state:
self.polls.append({"t": time.monotonic(), "out": ev["out"], "in": ev["in"], "limit": ev["limit"],
"gain": self.gain, "thr": self.thr})
async def set(self, gain: int | None = None, thr: int | None = None):
if gain is not None:
self.gain = gain
self.dev.set_param("out", self.o, "gain", gain)
if thr is not None:
self.thr = thr
self.dev.set_param("out", self.o, "limit.threshold", thr)
await self.dev.flush()
def window(self, since: float) -> list[dict]:
return [p for p in self.polls if p["t"] >= since]
def level(self, polls: list[dict]) -> dict:
"""Mean power and upper percentile of the output, and the mean power of the inputs feeding it."""
out = [p["out"][self.o] for p in polls]
loud = sorted(20 * math.log10(v) if v > 0 else -120.0 for v in out) or [-120.0]
inp = [sum(p["in"][i] ** 2 for i in self.ins) for p in polls]
return {"mean_db": round(db(statistics.fmean(v * v for v in out)) if out else -120.0, 2),
"p95_db": round(loud[int(len(loud) * 0.95) - 1 if len(loud) > 1 else 0], 2), "max_db": round(loud[-1], 2),
"in_db": round(db(statistics.fmean(inp)) if inp else -120.0, 2), "polls": len(polls),
"limit_share": round(sum(bool(p["limit"][self.o]) for p in polls) / max(1, len(polls)), 2)}
async def hold(self, seconds: float, settle: float = 1.0) -> dict:
await asyncio.sleep(settle)
since = time.monotonic()
await asyncio.sleep(seconds)
return self.level(self.window(since))
async def find_limit(self, start: int, gain: int) -> dict:
"""Lowers the threshold step by step until the limiter acts, then goes back up to where it was."""
await self.set(gain=gain)
await asyncio.sleep(1.0)
raw = start
result = {"gain_db": P.gain_to_db(gain), "hit": False}
while raw >= THRESHOLD_FLOOR:
await self.set(thr=raw)
since = time.monotonic()
await asyncio.sleep(0.45)
if any(p["limit"][self.o] for p in self.window(since)):
before = self.level(self.window(since - 3.0))
result.update(hit=True, threshold_db=P.threshold_to_db(raw), before=before,
offset_p95_db=round(P.threshold_to_db(raw) - before["p95_db"], 2),
offset_max_db=round(P.threshold_to_db(raw) - before["max_db"], 2))
break
raw -= 2
await self.set(thr=self.start_thr, gain=self.start_gain)
result["flag_after_raise_s"] = await self.flag_clear()
return result
async def flag_clear(self) -> float:
"""The flag was seen staying on for 4 s after raising the threshold: the next round must not take that for a hit."""
start = time.monotonic()
await asyncio.sleep(3.0)
while time.monotonic() - start < 15:
recent = self.window(time.monotonic() - 0.8)
if recent and not any(p["limit"][self.o] for p in recent):
break
await asyncio.sleep(0.2)
on = [p["t"] for p in self.window(start) if p["limit"][self.o]]
return round(on[-1] - start, 2) if on else 0.0
def conclude(res: dict) -> list[str]:
lines = []
d = res.get("gain_test", {}).get("meter_change_db")
if d is not None:
if abs(d + 6) < 1.5:
lines.append(f"Meter is AFTER the output gain: -6 dB gain moved it by {d:+.1f} dB.")
elif abs(d) < 1.5:
lines.append(f"Meter is BEFORE the output gain: -6 dB gain moved it by {d:+.1f} dB.")
else:
lines.append(f"Meter and gain: unclear, -6 dB gain moved it by {d:+.1f} dB.")
hits = [r for r in res.get("limit_rounds", []) if r.get("hit")]
plain = [r["offset_p95_db"] for r in hits if r["gain_db"] == res["start"]["gain_db"]]
if plain:
lines.append(f"Threshold minus meter at the moment the limiter starts: {statistics.fmean(plain):+.1f} dB "
f"(rounds: {plain}, spread {max(plain) - min(plain):.1f} dB).")
low = [r for r in hits if r["gain_db"] != res["start"]["gain_db"]]
if plain and low:
# the threshold alone moves with the music between rounds, threshold minus meter doesn't
a = statistics.fmean(r["offset_max_db"] for r in hits if r["gain_db"] == res["start"]["gain_db"])
b = statistics.fmean(r["offset_max_db"] for r in low)
lines.append(f"Threshold minus loudest meter reading: {a:+.1f} dB, with -6 dB gain {b:+.1f} dB. "
+ ("About the same, so meter and limiter seem to see the same level." if abs(a - b) < 2 else "They differ: compare with another run before concluding anything."))
c = res.get("limiting")
if c:
drop = (c["limiting"]["mean_db"] - c["limiting"]["in_db"]) - (c["free"]["mean_db"] - c["free"]["in_db"])
lines.append(f"Holding the threshold 6 dB below the start of limiting changed the meter by {drop:+.1f} dB against the input: "
+ ("the meter shows the level AFTER the limiter." if drop < -3 else "too little to say whether the meter is before or after the limiter."))
lines.append(f"While limiting, threshold minus meter: p95 {c['threshold_db'] - c['limiting']['p95_db']:+.1f} dB, "
f"mean {c['threshold_db'] - c['limiting']['mean_db']:+.1f} dB.")
return lines
async def measure(run: Run, args) -> dict:
dev = run.dev
print("Listening for music ...", flush=True)
since = time.monotonic()
await asyncio.sleep(5)
polls = run.window(since)
if not polls:
raise RuntimeError("no meter readings from the DSP")
outs = dev.state["outputs"]
power = [statistics.fmean(p["out"][i] ** 2 for p in polls) for i in range(len(outs))]
if args.output:
run.o = args.output - 1
else:
run.o = max((i for i in range(len(outs)) if not outs[i]["mute"]), key=lambda i: power[i], default=0)
ch = outs[run.o]
run.ins = [i for i in range(len(dev.state["inputs"])) if ch["matrix"] >> i & 1] or list(range(len(dev.state["inputs"])))
if ch["mute"] or db(power[run.o]) < SIGNAL_MIN_DB:
raise RuntimeError(f"Out {run.o + 1} has no signal ({db(power[run.o]):.0f} dB) or is muted: play music into the DSP and run again")
run.gain = run.start_gain = ch["gain"]
run.thr = run.start_thr = ch["limit"]["threshold"]
gain6 = P.db_to_gain(P.gain_to_db(run.gain) - 6)
print(f"Using Out {run.o + 1}: gain {P.gain_to_db(run.gain):+.1f} dB, limiter threshold {P.threshold_to_db(run.thr):+.1f} dB, "
f"level {db(power[run.o]):.1f} dB", flush=True)
res = {"device": dev.info, "model": dev.model_name, "output": run.o + 1, "inputs_feeding": [i + 1 for i in run.ins],
"start": {"gain_db": P.gain_to_db(run.gain), "threshold_db": P.threshold_to_db(run.thr), "limit": ch["limit"],
"level_mean_db": round(db(power[run.o]), 2)}}
print("1/3 Output gain -6 dB, three times ...", flush=True)
rows = []
for _ in range(3):
await run.set(gain=run.start_gain)
a = await run.hold(5)
await run.set(gain=gain6)
b = await run.hold(5)
rows.append({"normal": a, "lowered": b, "change_db": round((b["mean_db"] - b["in_db"]) - (a["mean_db"] - a["in_db"]), 2)})
await run.set(gain=run.start_gain)
res["gain_test"] = {"rounds": rows, "meter_change_db": round(statistics.fmean(r["change_db"] for r in rows), 2)}
print("2/3 Lowering the limiter threshold until it acts, several rounds ...", flush=True)
rounds, start = [], run.start_thr
for gain in (run.start_gain, run.start_gain, run.start_gain, gain6, gain6):
r = await run.find_limit(start, gain)
rounds.append(r)
print(" ", {k: r.get(k) for k in ("gain_db", "hit", "threshold_db", "offset_p95_db")}, flush=True)
if r["hit"]: # no need to walk all the way down again
start = min(run.start_thr, int(r["threshold_db"] * 2 + 180) + 12)
res["limit_rounds"] = rounds
hits = [r for r in rounds if r["hit"] and r["gain_db"] == res["start"]["gain_db"]]
if hits:
print("3/3 Holding the limiter on for a moment ...", flush=True)
hit_db = statistics.fmean(r["threshold_db"] for r in hits)
raw = max(THRESHOLD_FLOOR, round((hit_db - 6) * 2 + 180))
free = await run.hold(6)
await run.set(thr=raw)
limiting = await run.hold(8)
await run.set(thr=run.start_thr)
res["limiting"] = {"threshold_db": P.threshold_to_db(raw), "free": free, "limiting": limiting}
res["conclusions"] = conclude(res)
return res
async def main(args):
run: Run | None = None
dev = Device("m", "measure", args.host or "", args.port, args.model, autoconnect=False, transport="usb" if args.usb else "tcp",
on_event=lambda ev: run.on_event(ev))
run = Run(dev)
task = asyncio.current_task()
if sys.platform != "win32":
for sig in (signal.SIGTERM, signal.SIGHUP):
asyncio.get_running_loop().add_signal_handler(sig, task.cancel)
stamp = time.strftime("%Y%m%d-%H%M%S")
outdir = Path(args.dir)
res, error = {}, ""
dev.start()
try:
for _ in range(100):
if dev.status == "online" and dev.state:
break
await asyncio.sleep(0.2)
else:
raise RuntimeError(f"DSP not reached ({dev.status}: {dev.error}). Is other control software still open?")
doc = await dev.export_preset()
backup = outdir / f"dsp-measure-{stamp}-backup.json"
backup.write_text(json.dumps(doc), encoding="utf-8")
before = json.loads(json.dumps(dev.state))
print(f"Connected: {dev.info}. Backup: {backup}", flush=True)
try:
res = await measure(run, args)
except RuntimeError as e:
error = str(e)
except asyncio.CancelledError:
error = "interrupted"
finally:
# always back to where it was, whatever happened above
if hasattr(run, "start_gain"):
await run.set(gain=run.start_gain, thr=run.start_thr)
await asyncio.sleep(0.5)
await dev.refresh()
diffs = preset.differences(before, dev.state)
res["restored"] = not diffs
if diffs:
res["not_restored"] = diffs[:20]
finally:
await dev.stop()
res["error"] = error
res["polls"] = [[round(p["t"] - run.polls[0]["t"], 2), round(db(p["out"][run.o] ** 2), 1), round(db(sum(p["in"][i] ** 2 for i in run.ins)), 1),
int(p["limit"][run.o]), None if p["gain"] is None else P.gain_to_db(p["gain"]),
None if p["thr"] is None else P.threshold_to_db(p["thr"])] for p in run.polls] if run.ins else []
out = outdir / f"dsp-measure-{stamp}.json"
out.write_text(json.dumps(res), encoding="utf-8")
print("\nResult:", out)
for line in res.get("conclusions", []):
print(" *", line)
if error:
print(" ! Stopped:", error)
print(" * Settings restored:", "yes" if res["restored"] else f"NO, import the backup: {res.get('not_restored')}")
return 0 if res["restored"] and not error else 1
if __name__ == "__main__":
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--usb", action="store_true", help="connect over USB")
ap.add_argument("--host", help="IP address of the DSP")
ap.add_argument("--port", type=int, default=P.PORT)
ap.add_argument("--model", default="auto", help="auto, 204 or 408")
ap.add_argument("--output", type=int, help="output number to use, default: the loudest one")
ap.add_argument("--dir", default=".", help="where to write the files")
a = ap.parse_args()
if not a.usb and not a.host:
ap.error("say --usb or --host")
sys.exit(asyncio.run(main(a)))