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>
278 lines
13 KiB
Python
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)))
|