diff --git a/CLAUDE.md b/CLAUDE.md index 39a7cd5..6f151b9 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -25,6 +25,11 @@ pi_writer.py → pi_image.py (cloud-init SD card, installs server.py as a system * **`dsp/protocol.py`** – frames, checksum, value scales, model layouts (`MODELS["204"|"408"]`), memory image ↔ state dict (`parse_state` / `build_state_buffer`), parameter → command (`param_command`), link masks, meter/limiter decoding. State values are **raw device values**; conversion to dB/Hz/ms happens in the UI (`SPEC` in `app.js`). +* **Audio test** – `App.audio_test` / `set_test_level` / `check_audio_test` in `server.py`: entering saves the output + gains (`Device.test_saved`, persisted in `config.json` so an interrupted test is undone on the next connect), + lowers every output to −50 dB, flushes the queue and only then starts the generator (`0x39`); leaving switches the + generator off first, then restores the gains. While `Device.test_active`, preset store/recall/import/export are + refused. The state field is `state["test"] = {source, freq}`. * **`dsp/preset.py`** – preset files (`dsp-control-preset` JSON with state + raw image), validation, and the minimal command sequence for an import. Undo backups go to `backups/` next to `config.json` (last 20 per device). * **`dsp/usbhid.py`** – HID via ctypes only: Windows `hid.dll`/SetupAPI, macOS IOKit, Linux `/dev/hidraw*`. @@ -86,6 +91,8 @@ Not verified yet – ask for a log (`python server.py -v`) from real hardware be * USB on Windows and Linux against a real DSP (only tested against a fake HID device) * Where the PEQ bypass flag lives in the memory image; format of the set-command acknowledgement; where the number of preset slots comes from (20 is assumed when the `0x2C` answer carries the lock state) +* Test signal command `0x39` and its position in the memory image – derived from the control software, simulator + only; whether the generator is pre or post input gain is unknown (the app therefore only lowers the outputs) * Device lock (`0x2C` byte 5, `0x2D`, `0x2F`, `0x11`) – implemented from the control software's behaviour and tested against the simulator only; no command to remove a lock is known * Limiter calculator reference level (assumes limiter 0 dB = 0 dBu at the output; adjustable per device) diff --git a/PROTOCOL.md b/PROTOCOL.md index ca9a847..298174b 100644 --- a/PROTOCOL.md +++ b/PROTOCOL.md @@ -87,6 +87,7 @@ All 16-bit words are little endian. | `41` | Mix level (outputs) | `[ch][input][u16 level]` | | `3D` | Channel name | `[ch][name 8]` (printable ASCII) | | `3B` | Link | `[ch][u16 link mask]` (see [Channel links](#channel-links)) | +| `39` | Test signal | `[source][freq]` – source 0 = analog inputs, 1 = pink noise, 2 = white noise, 3 = sine; freq = index 0–30 of the 1/3-octave frequencies 20 Hz…20 kHz (as the GEQ) | | `15` | Delay unit | `[unit]` (display only) | The format of the acknowledgement the DSP sends after a set command is not fully understood yet. @@ -166,7 +167,10 @@ Chunk `n` carries bytes `n·50 … n·50+49` of the device memory image. … comp: ratio, attack, release, knee, threshold (5×u16) … limit: attack, release, knee, threshold (4×u16) … u16 gain, u16 polarity, u16 delay, u16 link mask - u16 input mute bit mask, u16 output mute bit mask, then unknown fields + u16 input mute bit mask, u16 output mute bit mask + u16[nIn + nOut] unknown + u16 test signal source, u16 test signal frequency index (see command 39) + 8 bytes unknown ``` Total size: DSP 204 = 724 bytes (15 chunks), DSP 408 = 1448 bytes (29 chunks). diff --git a/README.md b/README.md index c12a5d7..dd3f24f 100644 --- a/README.md +++ b/README.md @@ -31,6 +31,10 @@ Control both devices at the same time from your phone, tablet or computer – ov * **Settings backup** – devices, amplifier data, PIN and remote access in one file * **Device lock** – DSPs locked with their 4-character code (e.g. `A1BA`) are detected on connect and the app asks for the code; optionally it remembers the code and unlocks automatically. A new code can be set under ⚙ +* **Audio test** – switch the DSP's test generator (pink noise, white noise, sine 20 Hz–20 kHz) on and off. All + outputs drop to −50 dB first and a single test fader raises them together; mute buttons for every output. + Presets can't be saved or recalled meanwhile, and stopping the test switches the noise off before every fader + returns to its previous value. A DSP found playing a test signal on connect goes straight into this mode * **Demo mode** – one switch under ⚙ starts a simulated DSP 204 or 408 inside the app to try everything; the real DSPs are disconnected meanwhile and nothing is sent to them * **Many phones at once** – every change is pushed live to all connected clients diff --git a/dsp/device.py b/dsp/device.py index 3400430..83ba4df 100644 --- a/dsp/device.py +++ b/dsp/device.py @@ -21,7 +21,7 @@ LINK_RESYNC_DELAY = 1.5 # re-read the config this long after the last change on class Device: def __init__(self, dev_id: str, name: str, host: str, port: int = P.PORT, model: str = "auto", addr: int = 1, autoconnect: bool = True, on_event=None, transport: str = "tcp", usb: str = "", - lock_code: str = "", auto_unlock: bool = False): + lock_code: str = "", auto_unlock: bool = False, test_saved: list | None = None): self.id = dev_id self.name = name self.host = host @@ -36,6 +36,10 @@ class Device: self.lock_code = lock_code if P.LOCK_CODE.fullmatch(lock_code or "") else "" self.auto_unlock = auto_unlock self.demo = False # in-process simulator of the demo mode, never saved + # audio test: output gains from before the test (restored when it ends) and the test fader level + self.test_saved: list[int] | None = test_saved if isinstance(test_saved, list) else None + self.test_level = -50.0 + self.on_online = None # async callback(device) once a connection is fully loaded self.status = "disconnected" # disconnected | connecting | loading | locked | online | error self.error = "" @@ -66,11 +70,12 @@ class Device: return {"id": self.id, "name": self.name, "host": self.host, "port": self.port, "model": self.model_key, "addr": self.addr, "autoconnect": self.autoconnect, "transport": self.transport, "usb": self.usb, - "lock_code": self.lock_code, "auto_unlock": self.auto_unlock} + "lock_code": self.lock_code, "auto_unlock": self.auto_unlock, "test_saved": self.test_saved} def snapshot(self) -> dict: cfg = self.config() cfg["lock_code"] = bool(self.lock_code) # clients only learn whether a code is remembered + cfg["test_level"] = self.test_level return {**cfg, "demo": self.demo, "status": self.status, "error": self.error, "info": self.info, "detected_model": self.model_name or None, "n_in": self.model.n_in if self.model else 0, @@ -128,6 +133,26 @@ class Device: await asyncio.sleep(0.3) await self.refresh() + @property + def test_active(self) -> bool: + return bool(self.state and self.state.get("test", {}).get("source")) + + async def set_test_signal(self, source: int, freq: int): + """Switch the inputs to a test generator (1 pink, 2 white, 3 sine) or back to the analog inputs (0).""" + if self.status != "online" or not self.state: + raise RuntimeError("DSP is not connected") + await self.flush() # queued changes (e.g. lowered faders) reach the DSP first + await self._request(P.CMD_TEST_SIGNAL, bytes([source, freq])) + self.state["test"] = {"source": source, "freq": freq} + self.on_event({"type": "test", "device": self.id, "test": self.state["test"]}) + + async def flush(self): + """Wait until every queued parameter change has been sent.""" + while self._pending: + await asyncio.sleep(0.01) + async with self._lock: # the last one may still wait for its answer + pass + async def unlock(self, code: str) -> bool: """Try a lock code while the DSP waits for it. True if the DSP accepted it.""" code = str(code or "").strip().upper() @@ -255,6 +280,8 @@ class Device: self._set_status("online") self._emit_state() self._tasks += [asyncio.create_task(self._write_loop()), asyncio.create_task(self._meter_loop())] + if self.on_online: + asyncio.create_task(self.on_online(self)) done, _ = await asyncio.wait(self._tasks, return_when=asyncio.FIRST_COMPLETED) for t in done: if t.exception(): diff --git a/dsp/protocol.py b/dsp/protocol.py index 7f8b530..e50b3ac 100644 --- a/dsp/protocol.py +++ b/dsp/protocol.py @@ -25,6 +25,7 @@ CMD_PRESET_NAME = 0x29 CMD_PRESET_COUNT = 0x2C # answer: [time lock][4 bytes time lock data][device lock] (see device_locked) CMD_UNLOCK = 0x2D # [0][code 4] -> answer [0][1 = unlocked, 0 = wrong code] CMD_SET_LOCK_CODE = 0x2F # [code 4] +CMD_TEST_SIGNAL = 0x39 # [source][freq index]: 0 = analog input, 1 = pink noise, 2 = white noise, 3 = sine CMD_METER = 0x40 # Parameter commands @@ -45,6 +46,7 @@ CMD_GEQ = 0x48 CMD_LINK = 0x3B # [ch][u16 link mask], see link_masks() CHUNK_SIZE = 50 +TEST_SOURCES = ("analog", "pink", "white", "sine") LOCK_CODE = re.compile(r"[A-Z0-9]{4}") # device lock code: 4 characters, digits and upper-case letters @@ -222,6 +224,11 @@ class Model: def globals_base(self) -> int: return self.out_base + self.n_out * self.out_size + @property + def test_base(self) -> int: + """Test signal (source, sine frequency index), after the mute masks and one word per channel.""" + return self.globals_base + 4 + 2 * self.n_in + 2 * self.n_out + @property def size(self) -> int: return self.globals_base + 4 + 2 * self.n_in + 2 * self.n_out + 12 @@ -315,7 +322,9 @@ def parse_state(model: Model, buf: bytes) -> dict: "link": u16(p + 84), "mute": bool(out_mute >> i & 1), }) - return {"preset_name": _name(buf[2:16]), "inputs": inputs, "outputs": outputs} + source, freq = struct.unpack_from(" bytearray: @@ -359,6 +368,8 @@ def build_state_buffer(model: Model, state: dict) -> bytearray: struct.pack_into("<4H", buf, p + 78, ch["gain"], int(ch["polarity"]), ch["delay"], ch.get("link", 1 << i)) out_mute |= int(ch["mute"]) << i struct.pack_into(" dict: "limit": {"attack": 49, "release": 499, "knee": 0, "threshold": 220}, "gain": 280, "polarity": False, "delay": 0, "mute": False, "link": 1 << i, } for i in range(model.n_out)], + "test": {"source": 0, "freq": 17}, } @@ -500,6 +512,9 @@ def apply_command(model: Model, state: dict, cmd: int, p: bytes): """Update state from an incoming set command (used by the simulator).""" if not p: return + if cmd == CMD_TEST_SIGNAL: + state["test"] = {"source": p[0], "freq": p[1] if len(p) > 1 else 0} + return c = p[0] kind, idx = ("in", c) if c < model.n_in else ("out", c - model.n_in) chans = state["inputs" if kind == "in" else "outputs"] diff --git a/server.py b/server.py index fbcfef4..cc8d960 100644 --- a/server.py +++ b/server.py @@ -23,6 +23,7 @@ from urllib.parse import parse_qs, urlsplit import sim from dsp import preset, usbhid +from dsp import protocol as P from dsp.device import Device ROOT = Path(__file__).resolve().parent @@ -35,6 +36,8 @@ MAX_SESSIONS = 50 COOKIE = "dspsess" CONFIG_FORMAT = "dsp-control-config" MAX_UNDO = 20 # automatic backups kept per DSP before each import +TEST_LEVEL = -50.0 # dB all outputs start at when an audio test begins (noise generators are loud) +TEST_MAX = 0.0 # highest level the test fader can set def _num(v, lo: float, hi: float, default: float = 0.0) -> float: @@ -86,6 +89,13 @@ def clean_limiter(data: dict) -> dict: return {"amps": amps, "assign": assign, "ref": ref} +def clean_gains(v) -> list[int] | None: + """Saved output gains of an interrupted audio test (from config.json).""" + if not isinstance(v, list) or not v or len(v) > 8: + return None + return [int(_num(g, 0, 400, 280)) for g in v] + + def hash_pin(pin: str, salt: str) -> str: return hashlib.pbkdf2_hmac("sha256", pin.encode(), bytes.fromhex(salt), 100_000).hex() @@ -222,7 +232,9 @@ class App: int(d.get("port", 9761)), str(d.get("model", "auto")), int(d.get("addr", 1)), bool(d.get("autoconnect", True)), on_event=self.broadcast, transport="usb" if usb else "tcp", usb=str(d.get("usb") or ""), - lock_code=str(d.get("lock_code") or ""), auto_unlock=bool(d.get("auto_unlock"))) + lock_code=str(d.get("lock_code") or ""), auto_unlock=bool(d.get("auto_unlock")), + test_saved=clean_gains(d.get("test_saved"))) + dev.on_online = self.check_audio_test self.devices[dev_id] = dev if dev.autoconnect: if self.demo["enabled"]: @@ -233,6 +245,60 @@ class App: self.save() return dev + # ------------------------------------------------------------ audio test + + def set_test_level(self, dev: Device, db: float): + """Every output to the same level (the test fader).""" + dev.test_level = _num(db, -60, TEST_MAX, TEST_LEVEL) + raw = P.db_to_gain(dev.test_level) + for i in range(len(dev.state["outputs"])): + dev.set_param("out", i, "gain", raw) + + def restore_gains(self, dev: Device): + for i, g in enumerate((dev.test_saved or [])[: len(dev.state["outputs"])]): + dev.set_param("out", i, "gain", g) + dev.test_saved = None + + async def audio_test(self, dev: Device, body: dict) -> dict: + source = int(_num(body.get("source"), 0, len(P.TEST_SOURCES) - 1, 0)) + freq = int(_num(body.get("freq"), 0, 30, dev.state["test"]["freq"] if dev.state else 17)) + if not dev.state or dev.status != "online": + raise RuntimeError("DSP is not connected") + if source: + if not dev.test_active: # entering: lower every output before the generator starts + if dev.test_saved is None: + dev.test_saved = [ch["gain"] for ch in dev.state["outputs"]] + self.save() + self.set_test_level(dev, TEST_LEVEL) + await dev.set_test_signal(source, freq) + else: # leaving: generator off first, then the faders go back + await dev.set_test_signal(0, freq) + if dev.test_saved is not None: + self.restore_gains(dev) + await dev.flush() + self.save() + self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) + return {"ok": True} + + async def check_audio_test(self, dev: Device): + """On connect: a DSP still playing a test signal goes straight into the audio test (outputs lowered); + one back on its analog inputs gets the faders saved by an interrupted test back.""" + try: + if dev.test_active: + if dev.test_saved is None: + dev.test_saved = [ch["gain"] for ch in dev.state["outputs"]] + self.set_test_level(dev, TEST_LEVEL) + elif dev.test_saved is not None: + self.restore_gains(dev) + else: + return + await dev.flush() + if not dev.demo: + self.save() + self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) + except Exception as e: # noqa: BLE001 - connection lost meanwhile: checked again on the next connect + log.warning("%s: audio test check failed: %s", dev.name, e) + def real_devices(self) -> list[Device]: return [d for d in self.devices.values() if not d.demo] @@ -265,6 +331,7 @@ class App: port = self.demo_server.sockets[0].getsockname()[1] dev = Device("demo", f"Demo DSP {model}", "127.0.0.1", port, model, autoconnect=False, on_event=self.broadcast) dev.demo = True + dev.on_online = self.check_audio_test self.devices[dev.id] = dev self.demo["enabled"] = True self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) @@ -456,6 +523,8 @@ class App: action = "/".join(g for g in m.groups()[1:] if g) if dev.demo and (method in ("DELETE", "PUT") or action in ("unlock", "lockcode")): raise RuntimeError("Not available for the demo device") + if dev.test_active and action in ("preset/recall", "preset/store", "export", "import", "undo"): + raise RuntimeError("Audio test is on – switch it off first") if self.demo["enabled"] and not dev.demo and action == "connect": raise RuntimeError("Demo mode is on – switch it off to connect the real DSPs") if method == "DELETE" and not action: @@ -519,6 +588,13 @@ class App: if action == "refresh": await dev.refresh() return {"ok": True} + if action == "test": + return await self.audio_test(dev, body) + if action == "testlevel": + if not dev.test_active: + raise RuntimeError("Audio test is off") + self.set_test_level(dev, body.get("db")) + return {"ok": True, "db": dev.test_level} if action == "unlock": # hardware lock of the DSP, independent of the app lock code = str(body.get("code") or "").strip().upper() ok = await dev.unlock(code) diff --git a/sim.py b/sim.py index 887ebcd..7c8de33 100644 --- a/sim.py +++ b/sim.py @@ -54,9 +54,11 @@ class SimDSP: if cmd == P.CMD_METER: t = time.monotonic() levels = [0.0] * 12 + noise = self.state.get("test", {}).get("source", 0) # test generator instead of the analog inputs for i in range(m.n_in): ch = self.state["inputs"][i] - lv = 0.0 if ch["mute"] else 0.25 * (1 + math.sin(t * (1.3 + i))) * 10 ** (P.gain_to_db(ch["gain"]) / 20) + src = 0.7 + 0.05 * math.sin(t * 40 + i) if noise else 0.25 * (1 + math.sin(t * (1.3 + i))) + lv = 0.0 if ch["mute"] else src * 10 ** (P.gain_to_db(ch["gain"]) / 20) levels[m.meter_index("in", i)] = lv flags = 0 for o in range(m.n_out): diff --git a/static/app.js b/static/app.js index 79b9e8f..93ef61d 100644 --- a/static/app.js +++ b/static/app.js @@ -520,7 +520,7 @@ function renderTabs() { title: paused ? t("Disconnected while demo mode is on") : d.demo ? t("Demo mode – simulated DSP") : `${d.name} · ${where(d)}`, disabled: paused, onclick: () => { S.cur = id; S.settings = false; store.set("dsp.cur", id); render(); } }, h("span", { class: "dot " + d.status }), h("span", { class: "dn" }, d.name), - d.demo ? h("small", { class: "demo-badge" }, "DEMO") : model ? h("small", {}, model) : null); + testOn(d) ? h("small", { class: "test-badge" }, "TEST") : d.demo ? h("small", { class: "demo-badge" }, "DEMO") : model ? h("small", {}, model) : null); })); $("#btn-settings").classList.toggle("on", S.settings); document.querySelectorAll("#viewtabs button").forEach(b => b.classList.toggle("active", !S.settings && b.dataset.view === S.view)); @@ -712,6 +712,8 @@ function renderStatus() { const presetSel = h("select", { "aria-label": t("Recall preset") }, h("option", { value: "" }, t("Recall preset…")), d.presets.map((p, i) => h("option", { value: i, disabled: !p }, `U${String(i + 1).padStart(2, "0")} ${p || "—"}`))); + const testing = testOn(d); + presetSel.disabled = testing; presetSel.addEventListener("change", async () => { if (presetSel.value === "") return; const i = +presetSel.value; @@ -724,8 +726,8 @@ function renderStatus() { }); bar.replaceChildren( h("div", { class: "preset" }, h("small", {}, d.demo ? t("Demo mode · simulated DSP") : `${d.info || d.name} · ${where(d)}`), h("b", {}, d.state.preset_name || "—")), - h("div", { class: "presetrow" }, presetSel, h("button", { onclick: () => storePresetDialog(d) }, t("Save")), - h("button", { onclick: () => presetFileDialog(d), title: t("Export / import preset"), "data-view-ok": "" }, t("File…")))); + h("div", { class: "presetrow" }, presetSel, h("button", { disabled: testing, title: testing ? t("Not possible during the audio test") : "", onclick: () => storePresetDialog(d) }, t("Save")), + h("button", { disabled: testing, onclick: () => presetFileDialog(d), title: testing ? t("Not possible during the audio test") : t("Export / import preset"), "data-view-ok": "" }, t("File…")))); } // ------------------------------------------------------------------ mixer @@ -1396,6 +1398,68 @@ function viewLimiter(d) { ]; } +// ------------------------------------------------------------------ audio test (test generator of the DSP) + +const testOn = d => !!(d && d.state && d.state.test && d.state.test.source); +const TEST_SRC = () => [[0, t("Analog input"), t("normal operation")], [1, t("Pink noise"), ""], [2, t("White noise"), ""], [3, t("Sine"), ""]]; +const LVL_MIN = -60, LVL_MAX = 0; // test fader range in dB (all outputs at the same level) + +async function setTestSignal(d, source, freq) { + try { await api("POST", `/api/devices/${d.id}/test`, { source, freq: freq ?? d.state.test.freq }); } + catch (e) { toast(t("Error: ") + trMsg(e.message)); } +} + +// one request in flight at a time, always ending with the latest fader position +function sendTestLevel(d, db) { + sendTestLevel.next = db; + if (sendTestLevel.busy) return; + sendTestLevel.busy = true; + (async () => { + while (sendTestLevel.next != null) { + const v = sendTestLevel.next; + sendTestLevel.next = null; + try { await api("POST", `/api/devices/${d.id}/testlevel`, { db: v }); } catch (e) { toast(trMsg(e.message)); } + } + sendTestLevel.busy = false; + })(); +} + +function viewTest(d) { + const on = testOn(d), test = d.state.test; + const freqSel = h("select", { "aria-label": t("Sine frequency"), onchange: () => setTestSignal(d, 3, +freqSel.value) }, + GEQ_FREQS.map((f, i) => h("option", { value: i, selected: i === test.freq }, f.endsWith("k") ? `${f.slice(0, -1)} kHz` : `${f} Hz`))); + const signalCard = h("div", { class: "card" }, + h("h3", {}, t("Input signal")), + h("div", { class: "srcgrid" }, TEST_SRC().map(([v, label, sub]) => + h("button", { class: "src" + (test.source === v ? " on" : "") + (v ? " noise" : ""), "aria-pressed": String(test.source === v), + onclick: () => test.source !== v && setTestSignal(d, v, v === 3 ? +freqSel.value : test.freq) }, + h("b", {}, label), sub ? h("small", {}, sub) : null))), + h("label", { class: "row sinefreq" + (test.source === 3 ? "" : " dim") }, h("span", { class: "grow" }, t("Sine frequency")), freqSel), + h("p", { class: "info" }, t("The test signal replaces the analog inputs of the DSP. When it is switched on, all outputs are lowered to −50 dB first – raise them slowly with the test fader."))); + + const lvl = d.test_level ?? -50; + const val = h("div", { class: "testval" }, on ? `${lvl.toFixed(1)} dB` : "—"); + const f = fader({ min: 0, max: (LVL_MAX - LVL_MIN) * 2, value: Math.round((lvl - LVL_MIN) * 2), label: t("Test fader"), + ticks: [-60, -50, -40, -30, -20, -10, 0].map(db => [(db - LVL_MIN) * 2, String(db)]), + onInput: v => { const db = LVL_MIN + v / 2; d.test_level = db; val.textContent = `${db.toFixed(1)} dB`; sendTestLevel(d, db); } }); + const outs = chans(d, "out").map((ch, i) => { + const m = h("div", { class: "tmeter" + (ch.mute ? " muted" : "") }, ledMeter(d.id, "out", i), h("small", {}, chLabel("out", i)), limLed(d.id, i)); + m.append(toggleBtn("MUTE", "out", i, "mute", "mute small", v => m.classList.toggle("muted", v))); + return m; + }); + const faderCard = h("div", { class: "card testfader" + (on ? "" : " off") }, + h("h3", {}, t("Test fader"), h("span", { class: "info" }, t("all outputs"))), + h("div", { class: "testbody" }, h("div", { class: "tf" }, f, val), h("div", { class: "tmeters" }, outs)), + on ? h("button", { class: "danger-on wide", onclick: () => setTestSignal(d, 0) }, t("Stop test – back to the analog input")) : null, + h("p", { class: "info" }, on + ? t("Saving and recalling presets is blocked during the test. Stopping it switches the noise off first and then puts every fader back where it was.") + : t("Choose a test signal above to start."))); + return [ + on ? h("div", { class: "testbanner" }, t("Audio test running – the DSP plays {signal} instead of its inputs.", { signal: TEST_SRC()[test.source][1] })) : null, + h("div", { class: "cards testcards" }, signalCard, faderCard), + ]; +} + // ------------------------------------------------------------------ settings function deviceForm(d) { @@ -1616,7 +1680,7 @@ function render() { : d.status === "locked" ? h("div", {}, h("p", {}, t("This DSP is locked with a code.")), h("button", { class: "on", onclick: () => unlockDialog(d) }, t("Enter code"))) : S.demo.enabled && !d.demo ? t("Disconnected while demo mode is on") : t("Not connected.")); - else content = ({ mixer: viewMixer, channel: viewChannel, routing: viewRouting, link: viewLink, limiter: viewLimiter }[S.view] || viewMixer)(d); + else content = ({ mixer: viewMixer, channel: viewChannel, routing: viewRouting, link: viewLink, limiter: viewLimiter, test: viewTest }[S.view] || viewMixer)(d); main.replaceChildren(...[content].flat().filter(Boolean)); main.querySelectorAll(H_SCROLL).forEach((e, i) => { if (xs[i]) e.scrollLeft = xs[i]; }); window.scrollTo(0, y); @@ -1709,10 +1773,18 @@ function connectEvents() { S.order.forEach(id => maybeAskUnlock(S.devices[id])); if (!S.order.length) S.settings = true; render(); break; - case "device": + case "device": { if (!S.devices[ev.device]) S.order.push(ev.device); + const was = testOn(S.devices[ev.device]); S.devices[ev.device] = ev.data; + if (!was && testOn(ev.data) && ev.device === S.cur && !S.settings) S.view = "test"; // e.g. DSP found playing noise render(); break; + } + case "test": { + const d = S.devices[ev.device]; + if (d && d.state) { d.state.test = ev.test; render(); } + break; + } case "removed": delete S.devices[ev.device]; S.order = S.order.filter(id => id !== ev.device); render(); break; @@ -1736,7 +1808,8 @@ function connectEvents() { if (JSON.stringify(getPath(ch, ev.param)) === JSON.stringify(ev.value)) break; setPath(ch, ev.param, ev.value); showLive(`${ev.device}|${ev.kind}|${ev.idx}|${ev.param}`, ev.value); // even while a fader is held - if (ev.device === S.cur && !S.settings) render(); + // the test fader moves every output: the audio test view only shows meters, no need to redraw + if (ev.device === S.cur && !S.settings && !(S.view === "test" && ev.param === "gain")) render(); break; } case "lock": diff --git a/static/i18n.js b/static/i18n.js index f51651b..d9a6d02 100644 --- a/static/i18n.js +++ b/static/i18n.js @@ -321,6 +321,25 @@ const DE = { "Try everything with a simulated DSP – nothing is sent to real devices. While demo mode is on, the real DSPs are disconnected.": "Alles gefahrlos mit einem simulierten DSP ausprobieren – an echte Geräte wird nichts gesendet. Solange der Demo-Modus aktiv ist, sind die echten DSPs getrennt.", "Not available for the demo device": "Für das Demo-Gerät nicht verfügbar", "Demo mode is on – switch it off to connect the real DSPs": "Der Demo-Modus ist aktiv – zum Verbinden der echten DSPs bitte ausschalten", + // audio test + "Audio test": "Audiotest", + "Analog input": "Analog-Eingang", + "normal operation": "Normalbetrieb", + "Pink noise": "Rosa Rauschen", + "White noise": "Weißes Rauschen", + "Sine": "Sinus", + "Sine frequency": "Sinus-Frequenz", + "Input signal": "Eingangssignal", + "Test fader": "Testfader", + "all outputs": "alle Ausgänge", + "Audio test running – the DSP plays {signal} instead of its inputs.": "Audiotest läuft – der DSP spielt {signal} statt seiner Eingänge.", + "Choose a test signal above to start.": "Zum Starten oben ein Testsignal wählen.", + "Not possible during the audio test": "Während des Audiotests nicht möglich", + "Saving and recalling presets is blocked during the test. Stopping it switches the noise off first and then puts every fader back where it was.": "Presets speichern und laden ist während des Tests gesperrt. Beim Beenden wird zuerst das Rauschen abgeschaltet, danach gehen alle Fader zurück auf ihren ursprünglichen Wert.", + "Stop test – back to the analog input": "Test beenden – zurück zum Analog-Eingang", + "The test signal replaces the analog inputs of the DSP. When it is switched on, all outputs are lowered to −50 dB first – raise them slowly with the test fader.": "Das Testsignal ersetzt die Analog-Eingänge des DSP. Beim Einschalten werden zuerst alle Ausgänge auf −50 dB abgesenkt – mit dem Testfader langsam hochziehen.", + "Audio test is on – switch it off first": "Der Audiotest läuft – bitte zuerst beenden", + "Audio test is off": "Der Audiotest ist aus", }; const DE_PATTERNS = [ diff --git a/static/index.html b/static/index.html index 3da3bd3..00411ec 100644 --- a/static/index.html +++ b/static/index.html @@ -25,6 +25,7 @@ +