From fe13f261f7271f2aad43be4508190e4692704836 Mon Sep 17 00:00:00 2001 From: Givou Date: Sun, 1 Nov 2026 20:24:33 +0100 Subject: [PATCH] Add BetterDSPControl: web UI, desktop app and Pi writer for t.racks DSP 204/408 - Python stdlib server with SSE live updates, PIN login, remote access - Vanilla JS web UI (English/German): mixer, channel, routing, links, limiter calculator - Preset file export/import with undo, settings backup, lock for the desktop app - Network (TCP 9761) and USB HID transport (Windows, macOS, Linux) - Desktop app via pywebview, Raspberry Pi SD card writer, simulator and protocol tests - README with import guide for Claude Code, CLAUDE.md, protocol documentation Co-Authored-By: Claude Opus 5.5 --- .claude/launch.json | 8 + .gitattributes | 5 + .gitignore | 15 + CLAUDE.md | 89 ++ PROTOCOL.md | 163 ++++ README.md | 214 +++++ desktop.py | 172 ++++ dsp/__init__.py | 0 dsp/device.py | 365 ++++++++ dsp/preset.py | 172 ++++ dsp/protocol.py | 536 +++++++++++ dsp/usbhid.py | 431 +++++++++ packaging/build.py | 63 ++ packaging/dsp-control.icns | Bin 0 -> 126528 bytes packaging/dsp-control.ico | Bin 0 -> 10362 bytes packaging/dsp-control.png | Bin 0 -> 1553 bytes packaging/make_icons.py | 53 ++ packaging/pi-writer.icns | Bin 0 -> 148211 bytes packaging/pi-writer.ico | Bin 0 -> 16076 bytes packaging/pi-writer.png | Bin 0 -> 1771 bytes pi_image.py | 304 +++++++ pi_writer.py | 262 ++++++ server.py | 646 ++++++++++++++ sim.py | 108 +++ start.bat | 4 + static/app.js | 1729 ++++++++++++++++++++++++++++++++++++ static/i18n.js | 323 +++++++ static/index.html | 42 + static/style.css | 444 +++++++++ tests/test_protocol.py | 127 +++ win_disk.py | 170 ++++ 31 files changed, 6445 insertions(+) create mode 100644 .claude/launch.json create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 CLAUDE.md create mode 100644 PROTOCOL.md create mode 100644 desktop.py create mode 100644 dsp/__init__.py create mode 100644 dsp/device.py create mode 100644 dsp/preset.py create mode 100644 dsp/protocol.py create mode 100644 dsp/usbhid.py create mode 100644 packaging/build.py create mode 100644 packaging/dsp-control.icns create mode 100644 packaging/dsp-control.ico create mode 100644 packaging/dsp-control.png create mode 100644 packaging/make_icons.py create mode 100644 packaging/pi-writer.icns create mode 100644 packaging/pi-writer.ico create mode 100644 packaging/pi-writer.png create mode 100644 pi_image.py create mode 100644 pi_writer.py create mode 100644 server.py create mode 100644 sim.py create mode 100644 start.bat create mode 100644 static/app.js create mode 100644 static/i18n.js create mode 100644 static/index.html create mode 100644 static/style.css create mode 100644 tests/test_protocol.py create mode 100644 win_disk.py diff --git a/.claude/launch.json b/.claude/launch.json new file mode 100644 index 0000000..2af2843 --- /dev/null +++ b/.claude/launch.json @@ -0,0 +1,8 @@ +{ + "version": "0.0.1", + "configurations": [ + {"name": "sim-204", "runtimeExecutable": "python", "runtimeArgs": ["sim.py", "--model", "204", "--port", "9761"], "port": 9761}, + {"name": "sim-408", "runtimeExecutable": "python", "runtimeArgs": ["sim.py", "--model", "408", "--port", "9762"], "port": 9762}, + {"name": "webui", "runtimeExecutable": "python", "runtimeArgs": ["server.py", "--port", "8080"], "port": 8080} + ] +} diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..8588454 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +* text=auto eol=lf +*.bat text eol=crlf +*.png binary +*.ico binary +*.icns binary diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ea596dc --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +# local data – contains the PIN hash, logins and personal presets +config.json +backups/ +Sicherungen/ + +# build output and tools +.venv/ +build/ +dist/ +__pycache__/ +*.pyc +.DS_Store + +# personal Claude Code settings +.claude/settings.local.json diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..44ca17c --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,89 @@ +# CLAUDE.md – guide for AI coding assistants + +BetterDSPControl controls t.racks DSP 204 / DSP 408 loudspeaker processors. Read `README.md` (features, usage) and +`PROTOCOL.md` (wire protocol) first. This file explains how the code is built and what to watch out for. + +## Architecture + +``` +browser / phone ──HTTP + SSE──► server.py (asyncio, stdlib only) ──► dsp/device.py ──TCP 9761 or USB HID──► DSP + ▲ +desktop.py (pywebview window, logs in with a one-time token, no PIN) +pi_writer.py → pi_image.py (cloud-init SD card, installs server.py as a systemd service on a Raspberry Pi) +``` + +* **`server.py`** – own HTTP server on `asyncio.start_server` (no framework). JSON API under `/api/…`, live updates as + server-sent events on `/api/events` (`App.broadcast`). `App` holds devices, auth, limiter data, remote access, + backups. Config is one JSON file (`config.json`, gitignored) – `load()` / `apply_config()` / `save()`. +* **Auth** – 4-digit PIN, PBKDF2 hash in `config.json`, session cookie `dspsess` (30 days), lockout after 5 failures. + The desktop app logs in via `/app-login?t=`; app sessions live in memory only, skip the PIN and may + toggle remote access (`/api/remote`) and the lock (`/api/lock`, server answers 423 while locked). Remote clients + always need the PIN. +* **`dsp/device.py`** – one `Device` per DSP: connect (TCP or `usbhid.open_stream`), handshake, config dump + (50-byte chunks), command queue (one request in flight), meter polling (also keepalive), auto-reconnect. + Mirrors changes within link groups locally and re-reads the config ~1.5 s after the last change (resync). +* **`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`). +* **`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*`. + `HidStream` adapts a blocking reader thread to the asyncio stream interface `device.py` expects. +* **`static/`** – single-page app in vanilla JS. `h()` builds DOM, `S` is the global state, `render()` redraws the + current view (`mixer`, `channel`, `routing`, `link`, `limiter`, `settings`). Live widgets register in `live` and are + updated without a full redraw. **All UI text goes through `t("English text", {vars})`**; German lives in + `static/i18n.js` (`DE`, plus `DE_PATTERNS` for server messages with variables, applied by `trMsg()`). +* **`sim.py`** – simulated DSP 204/408 speaking the same protocol (meters, limiter flags, links). Use it for all tests. +* **`desktop.py`** – starts `server.App` on 127.0.0.1 with a random port in a thread and opens a pywebview window. + `Api` exposes native file dialogs to the page (`window.pywebview.api.save_file/open_file`). Single instance via a + named mutex (Windows) or lock file (macOS). Data in `%APPDATA%\DSP Control` / `~/Library/Application Support/DSP Control`. +* **`pi_writer.py` / `pi_image.py` / `win_disk.py`** – Windows-only tkinter tool that downloads Raspberry Pi OS Lite + (official image list), writes it raw to an SD card (`\\.\PhysicalDriveN`, verify by SHA-256) and adds cloud-init + files (`user-data`, `network-config`, `meta-data`) plus an `install.sh` that installs the app on first boot. + +## Conventions + +* **Server and `dsp/` use the Python standard library only.** pywebview/PyInstaller/Pillow are only for the desktop + builds. No build step for the web UI. +* Source texts are English. Every new `t("…")` string needs a German entry in `static/i18n.js`; server error messages + that reach the UI need one too (exact text in `DE`, or a regex in `DE_PATTERNS`). Technical terms (Gain, Threshold, + Mixer, Routing, Link, Limiter) stay English in German too. +* Native/desktop apps never ask for the PIN; the web UI and remote access always do. +* Channel names: max 8 printable ASCII characters (umlauts are transliterated), and they must fit the mixer strip. +* Keep comments sparse and factual, match the surrounding style. +* `README.md` and `PROTOCOL.md` are English. The Pi Writer UI is still German. + +## Testing + +```bash +python tests/test_protocol.py +python sim.py --model 204 --port 9761 +python sim.py --model 408 --port 9762 +python server.py --port 8080 --config .json +``` + +Log in with PIN `1234`, add devices `127.0.0.1:9761` / `:9762`. Check both languages after UI changes (⚙ → +Language / Sprache). For the desktop app run `python desktop.py` (needs `pywebview`). + +**Never change values on a real DSP permanently while testing.** Export a preset file first (File… → Export) and +restore it afterwards; prefer the simulator. The DSP accepts only one connection – close other control software. + +## Verified vs. unverified + +Verified on a real DSP 204 (firmware V0104P, USB on macOS): connect/dump/meters, set commands, link command `0x3B` +and the DSP's own mirroring inside groups, limiter-active bit mask, preset import writing only differences. + +Not verified yet – ask for a log (`python server.py -v`) from real hardware before changing protocol code here: + +* **DSP 408 on real hardware** (layout and frames match published captures, limiter bits for Out 5–8 assumed) +* 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; payload of the + preset-count answer (`0x2C`) +* Limiter calculator reference level (assumes limiter 0 dB = 0 dBu at the output; adjustable per device) +* Pi Writer: raw write to a real SD card and first boot on a real Pi (only tested with an image file) + +## Legal notes for contributors + +Do not add code, binaries, firmware, screenshots, manuals or internal symbol names/addresses from the manufacturer's +software. Document protocol facts only as observed behaviour. Use "t.racks"/"Thomann" only to name the supported +devices and keep the "not affiliated" notice in the README. diff --git a/PROTOCOL.md b/PROTOCOL.md new file mode 100644 index 0000000..b74e40a --- /dev/null +++ b/PROTOCOL.md @@ -0,0 +1,163 @@ +# t.racks DSP 204 / DSP 408 – control protocol + +Documented for interoperability by observing the communication between the devices and their control software +and by testing on real devices. Both models speak the same protocol; only the number of channels and the size +of the memory image differ. Implementation: [`dsp/protocol.py`](dsp/protocol.py). + +Status: the network transport and all commands below are implemented and tested against the simulator; links, +the limiter status bits and USB were verified on a real DSP 204 (firmware V0104P). Points marked *assumed* are +not verified yet. + +## Transport + +* **Network:** TCP, port **9761**. Factory default IP `192.168.1.101`. +* **USB:** HID class device, no driver needed, **VID 0x0168 / PID 0x0821** (both models). See [USB](#usb-hid). +* Request/response: send one command and wait for its answer before sending the next. +* The DSP accepts only **one** connection at a time. + +## Frame + +``` +10 02 SRC DST LEN CMD PAYLOAD… 10 03 CHK +``` + +| Field | Meaning | +|-------|---------| +| SRC/DST | PC→DSP: `00 01`, DSP→PC: `01 00` (`01` = device ID) | +| LEN | `1 + len(PAYLOAD)` (includes CMD) | +| CHK | XOR from `02` to `03`, i.e. `0x01 ^ SRC ^ DST ^ LEN ^ CMD ^ PAYLOAD…` | + +There is **no byte stuffing** – a payload may contain `10 03`, so always parse by LEN. +All 16-bit words are little endian. + +## Read / system commands + +| CMD | Direction | Payload | Meaning | +|-----|-----------|---------|---------| +| `10` | → | – | Handshake | +| `13` | → / ← | – / ASCII | Device info, answer starts with `DSP204` or `DSP408` | +| `2C` | → / ← | – / `[?][count]` | Number of presets (payload meaning partly *assumed*) | +| `22`, `14` | → | – | Init queries (sent during connect, content unknown) | +| `29` | → / ← | `[idx]` / `[idx][name…]` | Preset name (idx 0-based) | +| `20` | → | `[idx+1]` | Recall preset | +| `26` | → | `name[14]` | Set name for the next store | +| `21` | → | `[idx+1]` | Store current state into preset | +| `27` | → | `[chunk]` | Request config chunk | +| `24` | ← | `[chunk][50 bytes]` | Config chunk; 204: chunks 0…14, 408: 0…28 | +| `12` | → | – | Status (sent after the dump) | +| `40` | → / ← | – / meters | Read levels (also serves as keepalive) | + +### Meter answer + +12 entries × 3 bytes `b0 b1 b2`, followed by 2 status bytes. + +* Level = float32 from the bytes `00 b2 b0 b1` (little endian) → linear, dB = 20·log10. +* Positions: 0–3 = In A–D, 4–11 = Out 1–8. The 204 uses 0, 1 and 4–7. +* The level is measured before mute. +* **Limiter active**: the status bytes are a bit mask of the outputs (bit 0 = Out 1). Measured on a DSP 204: + `00 03` while Out 1+2 limit, `00 0C` for Out 3+4. That Out 5–8 of the 408 continue in the same 16-bit value + is *assumed*. + +## Channel numbers + +| Device | Inputs | Outputs | +|--------|--------|---------| +| DSP 204 | In A=0, In B=1 | Out 1–4 = 2–5 | +| DSP 408 | In A–D = 0–3 | Out 1–8 = 4–11 | + +## Set commands + +| CMD | Parameter | Payload | +|-----|-----------|---------| +| `34` | Gain | `[ch][u16 gain]` | +| `35` | Mute | `[ch][0/1]` | +| `36` | Polarity | `[ch][0/1]` | +| `38` | Delay | `[ch][u16 delay]` | +| `32` | High pass (low cut) | `[ch][u16 freq][slope]` | +| `31` | Low pass (high cut) | `[ch][u16 freq][slope]` | +| `33` | PEQ band | `[ch][band][u16 gain][u16 freq][q][type][bypass]` | +| `48` | GEQ band (inputs) | `[ch][band 0–30][u16 gain]` | +| `3E` | Gate (inputs) | `[ch][attack][release][hold][threshold]` (u16 each) | +| `30` | Compressor (outputs) | `[ch][ratio][attack][release][knee][threshold]` | +| `3F` | Limiter (outputs) | `[ch][attack][release][knee][threshold]` | +| `3A` | Routing matrix (outputs) | `[ch][bit mask of inputs]` | +| `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)) | +| `15` | Delay unit | `[unit]` (display only) | + +The format of the acknowledgement the DSP sends after a set command is not fully understood yet. + +## Value encoding + +| Parameter | Raw | Conversion | +|-----------|-----|------------| +| Gain / mix level | 0–400 (mix 0–280) | `r<80: r/2−60 dB`, else `(r−280)/10 dB` → −60…+12 dB | +| Frequency (PEQ, HP, LP) | 0–300 | `1000 · 2^((r−170)/30)` Hz → 19.7 Hz…20.16 kHz (1/30 octave) | +| PEQ/GEQ gain | 0–240 | `(r−120)/10` dB → ±12 dB | +| Q | 0–100 | table 0.4…128 (see `protocol.py`) | +| PEQ type | 0–8 | Peak, Low shelf, High shelf, HPF −6, HPF −12, LPF −6, LPF −12, Allpass 1, Allpass 2 | +| Slope | 0–20 | 0 = bypass, 1–20 = BW−6, BL−6, BW−12, BL−12, LK−12, … LK−48 | +| Delay | 0–65280 | `r/96` ms (max 680 ms) | +| Threshold (gate/comp/limit) | 0–220 | `(r−180)/2` dB (gate max 0 dB, comp/limit max +20 dB) | +| Attack | 0–998 | `r+1` ms | +| Release | 9–2999 | `r+1` ms | +| Hold | 9–998 | `r+1` ms | +| Ratio | 0–15 | 1.0, 1.1, 1.3, 1.5, 1.7, 2.0, 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 8.0, 10, 20, Limit | +| Knee | 0–12 | dB | + +The absolute output level that corresponds to 0 dB limiter threshold is not published; the app assumes 0 dBu. + +## Channel links + +Measured on a DSP 204 (firmware V0104P). Every channel has a u16 mask (bit = channel index within the inputs +or within the outputs): + +| Channel | Mask | +|---------|------| +| not linked | its own bit only (Out 3 = `04`) | +| first channel of a group | bits of all members (Out 3+4 = `0C`) | +| further members | `00` | + +* Set with `3B [ch][mask]` – for every channel of the group (first channel first). +* When a group is formed, the DSP copies the settings of the first channel to the others. +* The DSP itself applies every change on a member to the whole group (gain, delay, polarity, HP/LP, PEQ, GEQ, + gate, compressor, limiter, mute) – but **not** channel name, routing matrix and mix levels. +* A member with mask `00` that is not part of a group ignores changes: when unlinking, give every channel its own + bit again. + +## Config dump = memory image + +Chunk `n` carries bytes `n·50 … n·50+49` of the device memory image. + +``` +0x00 u8[2] ? +0x02 char[14] preset name +0x10 Input[nIn] 140 bytes each + +0 name[8] + +8 gate: attack, release, hold, threshold (4×u16) + +16 geq[31] u16 + +78 peq[8] {u16 gain, u16 freq, u8 q, u8 type} + +126 u16 hp_freq, u16 lp_freq, u8 hp_slope, u8 lp_slope + +132 u16 gain, u16 polarity, u16 delay, u16 link mask + Output[nOut] 96 + 2·nIn bytes each + +0 name[8] + +8 u16 matrix bit mask + +10 u16 mix[nIn] + … u16 hp_freq, u16 lp_freq, u8 hp_slope, u8 lp_slope + … peq[9] {u16 gain, u16 freq, u8 q, u8 type} + … 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 +``` + +Total size: DSP 204 = 724 bytes (15 chunks), DSP 408 = 1448 bytes (29 chunks). +Where the PEQ bypass flag is stored in the image is not known yet. + +## USB (HID) + +* Both models: **VID 0x0168, PID 0x0821**, HID class, no driver. +* Send: report ID `00` + one complete frame (`10 02 … 10 03 CHK`), zero-padded to the output report length. +* Receive: every input report holds exactly one frame starting at byte 0, length = `LEN + 8`, then padding. +* The frames are identical to TCP; the longest (config chunk, 50 data bytes) is 60 bytes and fits a 64-byte report. diff --git a/README.md b/README.md index 9269623..f899762 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,216 @@ # BetterDSPControl +**A modern, phone-friendly control app for the t.racks DSP 204 and DSP 408 loudspeaker processors.** +Control both devices at the same time from your phone, tablet or computer – over the network or USB. + +> **Unofficial project.** BetterDSPControl is an independent open-source project. It is not affiliated with, +> endorsed by or supported by Musikhaus Thomann or the t.racks brand. "Thomann" and "t.racks" are trademarks of +> their respective owner and are used here only to name the devices this software works with. +> Use at your own risk – see [Disclaimer](#disclaimer). + +* Pure Python 3.10+ standard library on the server side – no packages to install +* Vanilla HTML/CSS/JavaScript web UI – no build tools +* Runs on Windows, macOS, Linux and a Raspberry Pi +* English and German user interface + +## Features + +* **Several devices at once** – switch with the tabs at the top; the model is detected automatically +* **Mixer** – faders, mute and live meters for all inputs and outputs, limiter LED on every output (status read + from the DSP) +* **Channel** – name, gain, delay, polarity, high/low pass, 8/9-band PEQ with a draggable curve +* **Inputs** – noise gate, 31-band GEQ · **Outputs** – compressor, limiter, input routing with mix levels +* **Routing matrix**, recall and store presets +* **Channel links** – link channels into groups; the DSP mirrors changes within the group, the app shows them live +* **Preset files** – export the current DSP state to a file and import it again. An import only changes the active + state (stored presets stay untouched), writes only what actually differs and makes an automatic backup first + ("Undo import") +* **Limiter calculator** – enter your amplifiers' datasheet values (power at 8/4/2 Ω, sensitivity or gain), assign + outputs, and see the resulting power when the limiter engages, the clipping headroom and the speaker load. + "Limit to … W" calculates the threshold. Attack/release presets per band (infra, sub, kick, mid, high) +* **Settings backup** – devices, amplifier data, PIN and remote access in one file +* **Many phones at once** – every change is pushed live to all connected clients +* Tap a value to type it in (`-3.5`, `1.2k`, delay in metres `2.5m`); faders snap at 0 dB, double-tap = 0 dB + +## Supported hardware + +| Device | Network | USB | Tested on real hardware | +|--------|---------|-----|-------------------------| +| t.racks DSP 204 | ✓ | ✓ | yes (firmware V0104P, USB on macOS) | +| t.racks DSP 408 | ✓ | ✓ | not yet – frames match published captures | + +The DSPs accept only **one** connection at a time – close any other control software first. + +## Quick start (web UI) + +```bash +git clone https://git.thiemoo.at/Givou/BetterDSPControl.git +``` + +```bash +cd BetterDSPControl +``` + +```bash +python server.py +``` + +Open `http://:8080` in a browser (from a phone: same Wi-Fi/LAN). + +1. Log in with the default PIN **`1234`**. +2. Open ⚙ (settings), enter the IP addresses of your DSPs (or choose *USB cable*) and press *Connect*. +3. **Change the PIN** under ⚙ → Security. +4. Switch the language under ⚙ → *Language / Sprache* (English is the default). + +`config.json` is created on the first start. Options: `--port 8080`, `--host 0.0.0.0`, `--config path/to/config.json`, +`-v` (debug log). On Windows you can also double-click `start.bat`. + +**Forgot the PIN?** Stop the server, delete the `auth` entry from `config.json` and start again – the PIN is `1234` +again. + +### Security + +The PIN protects against accidental access in your own network, nothing more: it has 4 digits, a logged-in device +stays logged in for 30 days, and after 5 wrong attempts the login is blocked (30 s, growing up to 15 min). The server speaks +plain HTTP. **Do not expose it to the internet** (no port forwarding) – use a VPN if you need remote access. + +## Desktop apps (Windows, macOS) + +The desktop app runs the server and the UI in its own window – **no PIN needed** in the app window. +Under ⚙ → *Remote access* you can turn on a web server for phones and tablets (port selectable); other devices +then log in with the PIN. The lock icon (top right) locks the app window (view only); unlock with the PIN. + +Build it yourself (pre-built binaries are not part of the repository): + +```bash +python -m pip install pyinstaller pywebview pillow +``` + +```bash +python packaging/build.py +``` + +* **Windows** → `dist/DSP Control.exe` and `dist/DSP Control Pi Writer.exe`. Data: `%APPDATA%\DSP Control`. +* **macOS** → `dist/DSP Control.app` and `dist/DSP Control.dmg` (use a venv with Python 3.10+, e.g. from Homebrew). + The app is not signed: on the first start right-click → *Open*. Data: `~/Library/Application Support/DSP Control`. + +## Raspberry Pi (always-on web UI) + +`DSP Control Pi Writer.exe` (Windows, user interface currently German only) prepares an SD card for a Raspberry Pi +(Pi 1/2/3/4/5, Zero, Zero 2 W) that serves the web UI permanently: + +* downloads the current Raspberry Pi OS Lite from the official Raspberry Pi servers (with checksum, cached) +* writes and verifies the card, then configures it via cloud-init: hostname, Wi-Fi, user/SSH, web UI PIN, DSP IPs +* installs BetterDSPControl from the card (the Pi needs no internet), as a systemd service on port 80 + +After 2–5 minutes open `http://.local`. Needs administrator rights; only USB/SD drives that are not the +system or boot disk are offered. If Windows then asks to format the Linux partition, click **Cancel**. + +On any other Linux machine: `python3 server.py --port 8080`. For USB access as a normal user add a udev rule for +`hidraw` devices with VID `0168` / PID `0821` (see `INSTALL_SH` in `pi_image.py`). + +## USB + +Choose *USB cable* for a device under ⚙. The DSPs are USB HID devices (VID 0168 / PID 0821) – no driver needed – and +speak the same frames as over the network. Works on Windows (hid.dll), macOS (IOKit) and Linux (hidraw). With two +DSPs on USB, pick the right one in the drop-down. + +## Testing without hardware + +A simulator emulates both models: + +```bash +python sim.py --model 204 --port 9761 +``` + +```bash +python sim.py --model 408 --port 9762 +``` + +```bash +python server.py +``` + +Then add devices with IP `127.0.0.1` and ports 9761 / 9762 in the web UI. Protocol self-test: + +```bash +python tests/test_protocol.py +``` + +## Project layout + +| Path | Contents | +|------|----------| +| `server.py` | Web server (HTTP + server-sent events), device management, auth, backups | +| `dsp/protocol.py` | Frame format, commands, value scales, memory-image parser | +| `dsp/device.py` | Client per DSP (TCP or USB): connect, command queue, meters, auto-reconnect, links | +| `dsp/preset.py` | Preset files: export/import, validation, import command sequence | +| `dsp/usbhid.py` | USB HID without extra packages (Windows hid.dll, macOS IOKit, Linux hidraw) | +| `sim.py` | Simulated DSP 204/408 | +| `desktop.py` | Desktop app (Windows/macOS): server + own window (pywebview) | +| `pi_writer.py`, `pi_image.py`, `win_disk.py` | Raspberry Pi SD card writer: GUI, OS image + cloud-init, raw disk writes | +| `static/` | Web UI (`app.js`, `style.css`, `index.html`), translations in `static/i18n.js` | +| `packaging/` | Build script and icons | +| `tests/` | Protocol tests | +| `PROTOCOL.md` | Protocol documentation | +| `CLAUDE.md` | Guide for AI coding assistants (architecture, conventions, open points) | + +## How to import into your Claude + +This project was built with [Claude Code](https://claude.com/claude-code) and is documented so you can continue +working on it in your own Claude session. `CLAUDE.md` is read automatically by Claude Code and explains the +architecture, conventions and what is still unverified. + +1. Clone the repository (see [Quick start](#quick-start-web-ui)). +2. Open the folder in Claude Code – either the **Claude desktop app** (tab *Code* → choose the folder) or in a + terminal: + + ```bash + cd BetterDSPControl && claude + ``` + +3. Paste this prompt as your first message: + +```text +This is BetterDSPControl, a control app for the t.racks DSP 204 / DSP 408 (Python stdlib server + vanilla JS web UI, +desktop app via pywebview, Raspberry Pi SD card writer). + +Please get familiar with the project first: +1. Read CLAUDE.md, README.md and PROTOCOL.md completely. +2. Look at server.py, dsp/protocol.py, dsp/device.py and static/app.js to understand the structure. +3. Run the tests (python tests/test_protocol.py) and start the simulator test from the README + (sim.py for both models + server.py) to see the app working. +4. Summarise briefly how it is built and which points are still unverified on real hardware. + +Rules: never change values on a real DSP permanently while testing (export a preset file first, use the simulator +whenever possible), keep the server free of third-party packages, and keep English and German texts in sync +(static/i18n.js). Ask me before pushing anything. + +My devices: . +What I want to do: . +``` + +## Contributing + +Issues and pull requests are welcome – especially captures and test results from a real **DSP 408** and anything +listed as unverified in `CLAUDE.md`. Please test with the simulator first and run `python tests/test_protocol.py`. + +## Disclaimer + +This software talks to your audio hardware. Wrong settings (e.g. limiter thresholds, gain, crossover filters) can +damage loudspeakers or amplifiers. The limiter calculator is a planning aid based on datasheet values and an assumed +reference level – verify with a measurement before relying on it. The software is provided "as is", without +warranty of any kind, see [LICENSE](LICENSE). + +The protocol was documented for interoperability purposes only, by observing the communication of the devices and +testing on real hardware. This repository contains no code, binaries, firmware, images or documentation from the +manufacturer. Frame examples in the tests also match the DSP 408 captures published by +[dsp-408-ui](https://github.com/Aeternitaas/dsp-408-ui); no code from that project is used. + +## License + +[MIT](LICENSE) © 2026 Givou + +The desktop builds bundle third-party components under their own licenses (Python – PSF License, pywebview – BSD, +pythonnet – MIT, PyInstaller bootloader – GPL with exception allowing distribution). If you distribute built +binaries, include their license notices. diff --git a/desktop.py b/desktop.py new file mode 100644 index 0000000..864bfe4 --- /dev/null +++ b/desktop.py @@ -0,0 +1,172 @@ +"""DSP Control desktop app: the web server runs inside the app and the UI opens in its own window. + +The window logs in with a one-time token (no PIN). Other devices only get access when +"Fernzugriff" is switched on in the settings - and then they need the PIN. + +Runs on Windows and macOS. Build: python packaging/build.py +""" + +import asyncio +import base64 +import ctypes +import json +import logging +import os +import secrets +import subprocess +import sys +import threading +from pathlib import Path + +import webview + +import server + +APP_NAME = "DSP Control" + + +def data_dir() -> Path: + if sys.platform == "darwin": + d = Path.home() / "Library" / "Application Support" / APP_NAME + else: + d = Path(os.environ.get("APPDATA") or Path.home()) / APP_NAME + d.mkdir(parents=True, exist_ok=True) + return d + + +# texts of this file and pywebview's own (menus, file dialogs); the page itself is translated in static/i18n.js +TEXTS = { + "en": {"running": "DSP Control is already running.", "failed": "DSP Control could not start:\n{error}", + "timeout": "timeout"}, + "de": {"running": "DSP Control läuft bereits.", "failed": "DSP Control konnte nicht starten:\n{error}", + "timeout": "Zeitüberschreitung"}, +} +WEBVIEW_DE = { + "global.quitConfirmation": "Wirklich beenden?", "global.ok": "OK", "global.quit": "Beenden", "global.cancel": "Abbrechen", + "global.saveFile": "Datei speichern", "cocoa.menu.about": "Über", "cocoa.menu.services": "Dienste", + "cocoa.menu.view": "Darstellung", "cocoa.menu.edit": "Bearbeiten", "cocoa.menu.hide": "Ausblenden", + "cocoa.menu.hideOthers": "Andere ausblenden", "cocoa.menu.showAll": "Alle einblenden", "cocoa.menu.quit": "Beenden", + "cocoa.menu.fullscreen": "Vollbild", "cocoa.menu.cut": "Ausschneiden", "cocoa.menu.copy": "Kopieren", + "cocoa.menu.paste": "Einsetzen", "cocoa.menu.selectAll": "Alles auswählen", "windows.fileFilter.allFiles": "Alle Dateien", + "windows.fileFilter.otherFiles": "Andere Dateitypen", +} + + +def ui_lang() -> str: + """Language chosen in the app (kept in config.json by the server), English by default.""" + try: + lang = json.loads((data_dir() / "config.json").read_text(encoding="utf-8")).get("lang") + except (OSError, ValueError, AttributeError): + lang = None + return lang if lang in TEXTS else "en" + + +def text(key: str, **kw) -> str: + return TEXTS[ui_lang()][key].format(**kw) + + +_lock = None + + +def single_instance() -> bool: + """False if the app is already running (Windows named mutex, elsewhere a locked file).""" + global _lock + if sys.platform == "win32": + ctypes.windll.kernel32.CreateMutexW(None, False, "Local\\DSPControlDesktop") + return ctypes.windll.kernel32.GetLastError() != 183 # ERROR_ALREADY_EXISTS + import fcntl + _lock = open(data_dir() / ".lock", "w") # held until the process ends + try: + fcntl.flock(_lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError: + return False + return True + + +def message(text: str): + if sys.platform == "win32": + ctypes.windll.user32.MessageBoxW(None, text, APP_NAME, 0x40) + elif sys.platform == "darwin": + subprocess.run(["osascript", "-e", "on run argv", "-e", + f'display dialog (item 1 of argv) with title "{APP_NAME}" buttons {{"OK"}} default button 1', + "-e", "end run", text], check=False) + else: + print(text) + + +class Api: + """Called from the page (window.pywebview.api): native save/open dialogs for backups and presets.""" + + def __init__(self): + self._window = None # underscore: not exposed to JavaScript + + def save_file(self, name: str, text: str) -> bool: + res = self._window.create_file_dialog(webview.FileDialog.SAVE, save_filename=name) + path = res[0] if isinstance(res, (list, tuple)) else res + if not path: + return False + Path(path).write_text(text, encoding="utf-8") + return True + + def open_file(self) -> dict | None: + res = self._window.create_file_dialog(webview.FileDialog.OPEN) + if not res: + return None + path = Path(res[0] if isinstance(res, (list, tuple)) else res) + if path.stat().st_size > 5_000_000: + raise ValueError("File is too large") + return {"name": path.name, "data": base64.b64encode(path.read_bytes()).decode()} + + +def main(): + if not single_instance(): + message(text("running")) + return + d = data_dir() + logging.basicConfig(filename=d / "dsp-control.log", level=logging.INFO, encoding="utf-8", + format="%(asctime)s %(name)s %(levelname)s %(message)s") + app = server.App(d / "config.json") + app.app_token = secrets.token_urlsafe(24) + + loop = asyncio.new_event_loop() + started = threading.Event() + state: dict = {} + + async def start(): + app.load() + srv = await asyncio.start_server(app.handle, "127.0.0.1", 0) + state["port"] = srv.sockets[0].getsockname()[1] + await app.start_remote() + + def run(): + asyncio.set_event_loop(loop) + try: + loop.run_until_complete(start()) + except Exception as e: # noqa: BLE001 - shown to the user below + logging.exception("start failed") + state["error"] = e + started.set() + loop.run_forever() + + threading.Thread(target=run, daemon=True, name="server").start() + started.wait(20) + if "port" not in state: + message(text("failed", error=state.get("error", text("timeout")))) + return + + api = Api() + api._window = webview.create_window(APP_NAME, f"http://127.0.0.1:{state['port']}/app-login?t={app.app_token}", + width=1280, height=840, min_size=(380, 560), background_color="#0b0c0f", + js_api=api) + webview.start(private_mode=False, storage_path=str(d / "webview"), + localization=WEBVIEW_DE if ui_lang() == "de" else {}) + + # window closed: disconnect the DSPs cleanly so the next connection is accepted right away + try: + asyncio.run_coroutine_threadsafe(app.shutdown(), loop).result(5) + except Exception: # noqa: BLE001 + logging.exception("shutdown") + + +if __name__ == "__main__": + main() diff --git a/dsp/__init__.py b/dsp/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/dsp/device.py b/dsp/device.py new file mode 100644 index 0000000..a6cba10 --- /dev/null +++ b/dsp/device.py @@ -0,0 +1,365 @@ +"""Async client for one t.racks DSP - over the network (TCP) or USB (HID).""" + +import asyncio +import copy +import logging +import struct +import time + +from . import preset +from . import protocol as P +from . import usbhid + +log = logging.getLogger("dsp") + +RESPONSE_TIMEOUT = 0.6 +METER_INTERVAL = 0.15 +RECONNECT_DELAY = 5.0 +LINK_RESYNC_DELAY = 1.5 # re-read the config this long after the last change on a linked channel + + +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 = ""): + self.id = dev_id + self.name = name + self.host = host + self.port = port + self.model_key = model # "auto", "204" or "408" + self.addr = addr + self.autoconnect = autoconnect + self.transport = "usb" if transport == "usb" else "tcp" + self.usb = usb # HID device path, "" = first DSP found + self.on_event = on_event or (lambda ev: None) + + self.status = "disconnected" # disconnected | connecting | loading | online | error + self.error = "" + self.info = "" + self.model: P.Model | None = P.MODELS.get(model) + self.state: dict | None = None + self.raw = b"" # memory image of the last config read + self.presets: list[str] = [] + self.meters: list[float] = [0.0] * 12 + + self._reader = None + self._writer = None + self._parser = P.FrameParser() + self._lock = asyncio.Lock() + self._waiter: asyncio.Future | None = None + self._pending: dict[tuple, tuple[int, bytes]] = {} + self._pending_event = asyncio.Event() + self._tasks: list[asyncio.Task] = [] + self._supervisor: asyncio.Task | None = None + self._want_connected = False + self._resync: asyncio.TimerHandle | None = None + self._changes = 0 # bumped on every local change, so a resync never overwrites newer edits + + # ------------------------------------------------------------ public API + + def config(self) -> dict: + 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} + + def snapshot(self) -> dict: + return {**self.config(), "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, + "n_out": self.model.n_out if self.model else 0, + "presets": self.presets, "state": self.state} + + def start(self): + self._want_connected = True + if not self._supervisor or self._supervisor.done(): + self._supervisor = asyncio.create_task(self._supervise()) + + async def stop(self): + self._want_connected = False + self._resync: asyncio.TimerHandle | None = None + self._changes = 0 # bumped on every local change, so a resync never overwrites newer edits + if self._supervisor: + self._supervisor.cancel() + try: + await self._supervisor + except (asyncio.CancelledError, Exception): + pass + self._supervisor = None + await self._close() + self._set_status("disconnected") + + def set_param(self, kind: str, idx: int, param: str, value): + """Update local state and queue the command (coalesced per parameter).""" + if not self.state or not self.model: + raise RuntimeError("device not loaded") + chans = self.state["inputs" if kind == "in" else "outputs"] + ch = chans[idx] + if param == "name": + value = P.clean_name(value) + P.apply_param(ch, param, value) + cmd, payload = P.param_command(self.model, kind, idx, ch, param) + key = (cmd, payload[0]) + ((payload[1],) if cmd in (P.CMD_PEQ, P.CMD_GEQ, P.CMD_MIX) else ()) + self._pending[key] = (cmd, payload) + self._pending_event.set() + self._changes += 1 + # the DSP applies the change to linked channels itself: show that right away + group = [idx] if param.split(".")[0] in P.LINK_EXCLUDED else P.link_group(chans, idx) + for i in group: + if i != idx: + P.apply_param(chans[i], param, copy.deepcopy(value)) + self.on_event({"type": "param", "device": self.id, "kind": kind, "idx": i, + "param": param, "value": value}) + if len(group) > 1: + self._schedule_resync() + + async def set_links(self, kind: str, groups: list[list[int]]): + """Link channels of one kind. The DSP copies the first channel's settings to the others.""" + if not self.state or not self.model: + raise RuntimeError("device not loaded") + n = self.model.n_in if kind == "in" else self.model.n_out + for i, mask in enumerate(P.link_masks(n, groups)): + await self._request(P.CMD_LINK, bytes([self.model.channel(kind, i)]) + struct.pack(" str: + return next((k for k, m in P.MODELS.items() if m is self.model), "") + + async def export_preset(self) -> dict: + """The DSP's current state, read fresh from the device.""" + await self.refresh() + return preset.export_doc(self.model_name, self.info, self.state, self.raw) + + async def import_preset(self, state: dict) -> list[str]: + """Put the DSP into `state` (working state only). Returns the paths that did not take.""" + if self.status != "online": + raise RuntimeError("DSP is not connected") + if self._resync: + self._resync.cancel() + failed = 0 + for cmd, payload in preset.import_commands(self.model, state, self.state): + if await self._request(cmd, payload) is None: + failed += 1 + await asyncio.sleep(0.3) + await self.refresh() + diffs = preset.differences(state, self.state) + if failed: + log.warning("%s: %d import commands unanswered", self.name, failed) + return diffs + + async def refresh(self): + await self._load_config() + self._emit_state() + + # ------------------------------------------------------------ connection + + async def _supervise(self): + while self._want_connected: + try: + await self._connect_and_run() + except asyncio.CancelledError: + raise + except Exception as e: # noqa: BLE001 - keep reconnecting on any failure + log.warning("%s: %s", self.name, e) + self.error = str(e) or e.__class__.__name__ + self._set_status("error") + await self._close() + if not self._want_connected: + break + await asyncio.sleep(RECONNECT_DELAY) + + async def _connect_and_run(self): + self._set_status("connecting") + self.error = "" + if self.transport == "usb": + self._reader, self._writer = await asyncio.wait_for(usbhid.open_stream(self.usb), timeout=5) + else: + self._reader, self._writer = await asyncio.wait_for( + asyncio.open_connection(self.host, self.port), timeout=5) + self._parser = P.FrameParser() + reader_task = asyncio.create_task(self._read_loop()) + self._tasks = [reader_task] + self._set_status("loading") + await self._initialise() + self._set_status("online") + self._emit_state() + self._tasks += [asyncio.create_task(self._write_loop()), asyncio.create_task(self._meter_loop())] + done, _ = await asyncio.wait(self._tasks, return_when=asyncio.FIRST_COMPLETED) + for t in done: + if t.exception(): + raise t.exception() + raise ConnectionError("connection closed") + + async def _close(self): + if self._resync: + self._resync.cancel() + self._resync = None + for t in self._tasks: + t.cancel() + self._tasks = [] + if self._writer: + try: + self._writer.close() + except Exception: # noqa: BLE001 + pass + self._reader = self._writer = None + if self._waiter and not self._waiter.done(): + self._waiter.cancel() + + async def _read_loop(self): + while True: + data = await self._reader.read(4096) + if not data: + raise ConnectionError("DSP closed the connection") + for frame in self._parser.feed(data): + if self._waiter and not self._waiter.done(): + self._waiter.set_result(frame) + + async def _request(self, cmd: int, payload: bytes = b"", timeout: float = RESPONSE_TIMEOUT, + expect: int | None = None) -> P.Frame | None: + """Send one command and wait for its answer (the DSP is strictly request/response).""" + if not self._writer: + raise ConnectionError("not connected") + async with self._lock: + deadline = time.monotonic() + timeout + self._writer.write(P.build_frame(cmd, payload, self.addr)) + await self._writer.drain() + while True: + remaining = deadline - time.monotonic() + if remaining <= 0: + return None + self._waiter = asyncio.get_running_loop().create_future() + try: + frame = await asyncio.wait_for(self._waiter, remaining) + except asyncio.TimeoutError: + return None + if expect is None or frame.cmd == expect: + return frame + + # ------------------------------------------------------------ init / dump + + async def _initialise(self): + await self._request(P.CMD_HANDSHAKE) + info = await self._request(P.CMD_DEVICE_INFO, expect=P.CMD_DEVICE_INFO) + self.info = info.payload.split(b"\x00")[0].decode("latin1", "replace").strip() if info else "" + detected = P.detect_model(self.info) + if self.model_key == "auto": + if not detected: + raise RuntimeError(f"unknown device '{self.info}' - set the model manually") + self.model = P.MODELS[detected] + else: + self.model = P.MODELS[self.model_key] + if detected and detected != self.model_key: + log.warning("%s: configured as %s but device reports %s", self.name, self.model_key, self.info) + count_frame = await self._request(P.CMD_PRESET_COUNT, expect=P.CMD_PRESET_COUNT) + count = count_frame.payload[-1] if count_frame and count_frame.payload else 20 + count = count if 0 < count <= 60 else 20 + await self._request(P.CMD_INIT_22) + await self._request(P.CMD_INIT_14) + presets = [] + for i in range(count): + f = await self._request(P.CMD_PRESET_NAME, bytes([i]), expect=P.CMD_PRESET_NAME) + presets.append(f.payload[1:].split(b"\x00")[0].decode("latin1", "replace").strip() if f else "") + self.presets = presets + await self._load_config() + + async def _load_config(self): + self.state = await self._read_config() + + async def _read_config(self) -> dict: + model = self.model + buf = bytearray(model.chunks * P.CHUNK_SIZE) + for n in range(model.chunks): + for _attempt in range(3): + f = await self._request(P.CMD_CONFIG_REQUEST, bytes([n]), expect=P.CMD_CONFIG_CHUNK) + if f and f.payload and f.payload[0] == n: + data = f.payload[1 : 1 + P.CHUNK_SIZE] + buf[n * P.CHUNK_SIZE : n * P.CHUNK_SIZE + len(data)] = data + break + else: + raise RuntimeError(f"config chunk {n} not received") + await self._request(P.CMD_STATUS) + self.raw = bytes(buf[: model.size]) + return P.parse_state(model, bytes(buf)) + + # ------------------------------------------------------------ background loops + + async def _write_loop(self): + while True: + await self._pending_event.wait() + while self._pending: + key = next(iter(self._pending)) + cmd, payload = self._pending.pop(key) + await self._request(cmd, payload) + self._pending_event.clear() + + async def _meter_loop(self): + misses = 0 + while True: + await asyncio.sleep(METER_INTERVAL) + if self._pending: + continue + f = await self._request(P.CMD_METER, expect=P.CMD_METER) + if f is None: + misses += 1 + if misses >= 10: + raise ConnectionError("DSP not responding") + continue + misses = 0 + self.meters = P.decode_meters(f.payload) + m = self.model + self.on_event({"type": "meters", "device": self.id, + "in": [self.meters[m.meter_index("in", i)] for i in range(m.n_in)], + "out": [self.meters[m.meter_index("out", i)] for i in range(m.n_out)], + "limit": P.decode_limit_flags(f.payload, m.n_out)}) + + # ------------------------------------------------------------ events + + def _set_status(self, status: str): + self.status = status + self.on_event({"type": "status", "device": self.id, "status": status, "error": self.error, + "info": self.info}) + + def _emit_state(self): + self.on_event({"type": "device", "device": self.id, "data": copy.deepcopy(self.snapshot())}) diff --git a/dsp/preset.py b/dsp/preset.py new file mode 100644 index 0000000..a32c129 --- /dev/null +++ b/dsp/preset.py @@ -0,0 +1,172 @@ +"""Preset files: export the DSP's current state and import it again. + +A file holds the decoded state (readable, see protocol.parse_state) plus the raw memory image. +Importing only changes the DSP's working state - the stored presets (U01...) stay untouched. +""" + +import copy +import time + +from . import protocol as P + +FORMAT = "dsp-control-preset" + +# valid raw ranges (PROTOCOL.md, "Werte-Kodierung") +_GATE = {"attack": (0, 998), "release": (9, 2999), "hold": (9, 998), "threshold": (0, 180)} +_COMP = {"ratio": (0, 15), "attack": (0, 998), "release": (9, 2999), "knee": (0, 12), "threshold": (0, 220)} +_LIMIT = {"attack": (0, 998), "release": (9, 2999), "knee": (0, 12), "threshold": (0, 220)} + + +def export_doc(model_key: str, info: str, state: dict, raw: bytes) -> dict: + return {"format": FORMAT, "version": 1, "model": model_key, "device": info, + "preset_name": state.get("preset_name", ""), + "exported": time.strftime("%Y-%m-%dT%H:%M:%S"), "state": state, "raw": raw.hex()} + + +def _int(v, lo: int, hi: int, default: int) -> int: + try: + v = int(v) + except (TypeError, ValueError): + return default + return min(hi, max(lo, v)) + + +def _filter(src, cur: dict) -> dict: + src = src if isinstance(src, dict) else {} + return {"freq": _int(src.get("freq"), 0, 300, cur["freq"]), "slope": _int(src.get("slope"), 0, 20, cur["slope"])} + + +def _peq(src, cur: list) -> list: + src = src if isinstance(src, list) else [] + out = [] + for i, c in enumerate(cur): + b = src[i] if i < len(src) and isinstance(src[i], dict) else {} + out.append({"gain": _int(b.get("gain"), 0, 240, c["gain"]), "freq": _int(b.get("freq"), 0, 300, c["freq"]), + "q": _int(b.get("q"), 0, 100, c["q"]), "type": _int(b.get("type"), 0, 8, c["type"]), + "bypass": bool(b.get("bypass", c["bypass"]))}) + return out + + +def _group(src, cur: dict, ranges: dict) -> dict: + src = src if isinstance(src, dict) else {} + return {k: _int(src.get(k), lo, hi, cur[k]) for k, (lo, hi) in ranges.items()} + + +def _common(s: dict, c: dict) -> dict: + name = s.get("name", c["name"]) + return {"name": P.clean_name(name).strip(), + "hp": _filter(s.get("hp"), c["hp"]), "lp": _filter(s.get("lp"), c["lp"]), + "gain": _int(s.get("gain"), 0, 400, c["gain"]), "polarity": bool(s.get("polarity", c["polarity"])), + "delay": _int(s.get("delay"), 0, 65280, c["delay"]), "link": _int(s.get("link"), 0, 0xFFFF, c["link"]), + "mute": bool(s.get("mute", c["mute"]))} + + +def clean_state(model: P.Model, src: dict, base: dict) -> dict: + """`src` limited to valid values; anything missing or broken is taken from `base`.""" + st = copy.deepcopy(base) + ins = src.get("inputs") if isinstance(src.get("inputs"), list) else [] + outs = src.get("outputs") if isinstance(src.get("outputs"), list) else [] + for i, c in enumerate(st["inputs"]): + s = ins[i] if i < len(ins) and isinstance(ins[i], dict) else {} + geq = s.get("geq") if isinstance(s.get("geq"), list) else [] + c.update(_common(s, c), peq=_peq(s.get("peq"), c["peq"]), gate=_group(s.get("gate"), c["gate"], _GATE), + geq=[_int(geq[b], 0, 240, v) if b < len(geq) else v for b, v in enumerate(c["geq"])]) + for i, c in enumerate(st["outputs"]): + s = outs[i] if i < len(outs) and isinstance(outs[i], dict) else {} + mix = s.get("mix") if isinstance(s.get("mix"), list) else [] + c.update(_common(s, c), peq=_peq(s.get("peq"), c["peq"]), + comp=_group(s.get("comp"), c["comp"], _COMP), limit=_group(s.get("limit"), c["limit"], _LIMIT), + matrix=_int(s.get("matrix"), 0, (1 << model.n_in) - 1, c["matrix"]), + mix=[_int(mix[k], 0, 400, v) if k < len(mix) else v for k, v in enumerate(c["mix"])]) + if isinstance(src.get("preset_name"), str): + st["preset_name"] = src["preset_name"][:14] + return st + + +def read_file(model_key: str, model: P.Model, current: dict, doc: dict | None = None, + raw: bytes | None = None) -> dict: + """The state to import from an uploaded file: our JSON (`doc`) or a bare memory image (`raw`).""" + if raw is not None: + if len(raw) not in (model.size, model.chunks * P.CHUNK_SIZE): + raise ValueError(f"Unknown file format ({len(raw)} bytes) – expected a DSP Control preset file " + f"or a memory image of the {model.name} ({model.size} bytes)") + return _linked_alike(clean_state(model, P.parse_state(model, raw.ljust(model.chunks * P.CHUNK_SIZE, b"\0")), current)) + if not isinstance(doc, dict) or doc.get("format") != FORMAT: + raise ValueError("Not a DSP Control preset file") + if str(doc.get("model")) != model_key: + raise ValueError(f"The file is for a DSP {doc.get('model')}, the connected device is a {model.name}") + base = current + try: # the raw image fills in anything the readable part lacks + img = bytes.fromhex(doc.get("raw") or "") + if len(img) in (model.size, model.chunks * P.CHUNK_SIZE): + base = clean_state(model, P.parse_state(model, img.ljust(model.chunks * P.CHUNK_SIZE, b"\0")), current) + except ValueError: + pass + return _linked_alike(clean_state(model, doc.get("state") if isinstance(doc.get("state"), dict) else {}, base)) + + +def _linked_alike(st: dict) -> dict: + """Linked channels share their settings on the DSP: take them from each group's first channel.""" + for chans in (st["inputs"], st["outputs"]): + for g in P.link_groups(chans): + for i in g[1:]: + P.copy_linked(chans, g[0], i) + return st + + +def import_commands(model: P.Model, st: dict, current: dict) -> list[tuple[int, bytes]]: + """Commands that take the DSP from `current` to `st` - only values that actually change. + + If the links change, they are dissolved first (otherwise the DSP would copy every value onto + the whole group), then the parameters are set, then the new links are formed. Forming a group + copies the first channel's settings to the others, so names, routing and mix levels (which + links don't share) are sent once more at the end. + """ + kinds = (("in", "inputs"), ("out", "outputs")) + relink = any(P.link_groups(st[key]) != P.link_groups(current[key]) for _, key in kinds) + cmds = [] + if relink: + for kind, key in kinds: + for i in range(len(st[key])): + cmds.append((P.CMD_LINK, bytes([model.channel(kind, i)]) + (1 << i).to_bytes(2, "little"))) + for kind, key in kinds: + for i, ch in enumerate(st[key]): + params = ["name", "gain", "polarity", "delay", "hp", "lp"] + [f"peq.{b}" for b in range(len(ch["peq"]))] + if kind == "in": + params += [f"geq.{b}" for b in range(len(ch["geq"]))] + ["gate"] + else: + params += ["comp", "limit", "matrix"] + [f"mix.{k}" for k in range(len(ch["mix"]))] + for p in params + ["mute"]: + cmd = P.param_command(model, kind, i, ch, p) + if relink or cmd != P.param_command(model, kind, i, current[key][i], p): + cmds.append(cmd) + if relink: + for kind, key in kinds: + chans = st[key] + groups = P.link_groups(chans) + for i, mask in enumerate(P.link_masks(len(chans), groups)): + if mask != 1 << i: + cmds.append((P.CMD_LINK, bytes([model.channel(kind, i)]) + mask.to_bytes(2, "little"))) + for g in groups: + for i in g[1:]: + extra = ["name"] + (["matrix"] + [f"mix.{k}" for k in range(len(chans[i]["mix"]))] if kind == "out" else []) + cmds += [P.param_command(model, kind, i, chans[i], p) for p in extra] + return cmds + + +def differences(target: dict, actual: dict) -> list[str]: + """Paths where the DSP's state differs from the imported one (the preset name is not settable).""" + diffs = [] + + def walk(a, b, path): + if isinstance(a, dict): + for k in a: + walk(a[k], b.get(k) if isinstance(b, dict) else None, f"{path}.{k}" if path else k) + elif isinstance(a, list): + for i, v in enumerate(a): + walk(v, b[i] if isinstance(b, list) and i < len(b) else None, f"{path}.{i}") + elif a != b: + diffs.append(path) + + walk({k: v for k, v in target.items() if k != "preset_name"}, actual, "") + return diffs diff --git a/dsp/protocol.py b/dsp/protocol.py new file mode 100644 index 0000000..5393953 --- /dev/null +++ b/dsp/protocol.py @@ -0,0 +1,536 @@ +"""t.racks DSP 204 / DSP 408 wire protocol (see PROTOCOL.md).""" + +import copy +import math +import struct +from dataclasses import dataclass + +PORT = 9761 + +# Read / system commands +CMD_ACK = 0x01 +CMD_HANDSHAKE = 0x10 +CMD_STATUS = 0x12 +CMD_DEVICE_INFO = 0x13 +CMD_INIT_14 = 0x14 +CMD_PRESET_RECALL = 0x20 +CMD_PRESET_STORE = 0x21 +CMD_INIT_22 = 0x22 +CMD_CONFIG_CHUNK = 0x24 +CMD_PRESET_STORE_NAME = 0x26 +CMD_CONFIG_REQUEST = 0x27 +CMD_PRESET_NAME = 0x29 +CMD_PRESET_COUNT = 0x2C +CMD_METER = 0x40 + +# Parameter commands +CMD_COMP = 0x30 +CMD_LOW_PASS = 0x31 +CMD_HIGH_PASS = 0x32 +CMD_PEQ = 0x33 +CMD_GAIN = 0x34 +CMD_MUTE = 0x35 +CMD_POLARITY = 0x36 +CMD_DELAY = 0x38 +CMD_MATRIX = 0x3A +CMD_CHANNEL_NAME = 0x3D +CMD_GATE = 0x3E +CMD_LIMIT = 0x3F +CMD_MIX = 0x41 +CMD_GEQ = 0x48 +CMD_LINK = 0x3B # [ch][u16 link mask], see link_masks() + +CHUNK_SIZE = 50 + + +def checksum(data: bytes) -> int: + """XOR over 02 .. 03 of the frame; the 02 and 03 bytes fold into the initial 0x01.""" + c = 0x01 + for b in data: + c ^= b + return c + + +def build_frame(cmd: int, payload: bytes = b"", addr: int = 1, src: int = 0) -> bytes: + body = bytes([src, addr, len(payload) + 1, cmd]) + bytes(payload) + return b"\x10\x02" + body + b"\x10\x03" + bytes([checksum(body)]) + + +@dataclass +class Frame: + src: int + dst: int + cmd: int + payload: bytes + checksum_ok: bool = True + + +class FrameParser: + """Reassembles frames from a TCP byte stream (length based, no byte stuffing).""" + + def __init__(self): + self.buf = bytearray() + + def feed(self, data: bytes) -> list[Frame]: + self.buf += data + frames = [] + while True: + start = self.buf.find(b"\x10\x02") + if start < 0: + # keep a trailing 0x10 that might start the next header + del self.buf[: max(0, len(self.buf) - 1)] + return frames + if start: + del self.buf[:start] + if len(self.buf) < 6: + return frames + length = self.buf[4] + total = 5 + length + 3 + if len(self.buf) < total: + return frames + if self.buf[5 + length] != 0x10 or self.buf[6 + length] != 0x03 or length == 0: + del self.buf[:2] # not a real header, resync + continue + body = bytes(self.buf[2 : 5 + length]) + frames.append( + Frame( + src=body[0], + dst=body[1], + cmd=body[3], + payload=body[4:], + checksum_ok=checksum(body) == self.buf[7 + length], + ) + ) + del self.buf[:total] + + +# ---------------------------------------------------------------- value scales + +Q_TABLE = [ + 0.4, 0.42, 0.45, 0.47, 0.5, 0.53, 0.56, 0.59, 0.63, 0.67, 0.71, 0.75, 0.79, 0.84, 0.89, + 0.94, 1.0, 1.06, 1.12, 1.19, 1.26, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.4, + 2.5, 2.7, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.5, 4.8, 5.0, 5.3, 5.7, 6.0, 6.3, 6.7, + 7.1, 7.6, 8.0, 8.5, 9.0, 9.5, 10.1, 10.7, 11.3, 12.0, 12.7, 13.5, 14.0, 15.0, 16.0, 17.0, + 18.0, 19.0, 20.0, 21.0, 23.0, 24.0, 25.0, 27.0, 29.0, 30.0, 32.0, 34.0, 36.0, 38.0, 40.0, + 43.0, 45.0, 48.0, 51.0, 54.0, 57.0, 60.0, 64.0, 68.0, 72.0, 76.0, 81.0, 85.0, 91.0, 96.0, + 102.0, 108.0, 114.0, 121.0, 128.0, +] +RATIO_NAMES = ["1.0", "1.1", "1.3", "1.5", "1.7", "2.0", "2.5", "3.0", "3.5", "4.0", "5.0", + "6.0", "8.0", "10", "20", "Limit"] +PEQ_TYPES = ["Peak", "Low Shelf", "High Shelf", "HPF -6", "HPF -12", "LPF -6", "LPF -12", + "Allpass 1", "Allpass 2"] +SLOPES = ["Bypass", "BW -6", "BL -6", "BW -12", "BL -12", "LK -12", "BW -18", "BL -18", "BW -24", + "BL -24", "LK -24", "BW -30", "BL -30", "BW -36", "BL -36", "LK -36", "BW -42", "BL -42", + "BW -48", "BL -48", "LK -48"] + + +def gain_to_db(raw: int) -> float: + return raw / 2 - 60 if raw < 80 else (raw - 280) / 10 + + +def db_to_gain(db: float) -> int: + raw = round((db + 60) * 2) if db < -20 else round(db * 10 + 280) + return max(0, min(400, raw)) + + +def freq_to_hz(raw: int) -> float: + return 1000.0 * 2 ** ((raw - 170) / 30) + + +def hz_to_freq(hz: float) -> int: + return max(0, min(300, round(170 + 30 * math.log2(max(hz, 1.0) / 1000.0)))) + + +def eq_gain_to_db(raw: int) -> float: + return (raw - 120) / 10 + + +def threshold_to_db(raw: int) -> float: + return (raw - 180) / 2 + + +def delay_to_ms(raw: int) -> float: + return raw / 96 + + +def decode_meters(payload: bytes) -> list[float]: + """12 linear levels (In A-D, Out 1-8) from a 0x40 response payload.""" + levels = [] + for i in range(12): + b = payload[i * 3 : i * 3 + 3] + if len(b) < 3: + levels.append(0.0) + continue + v = struct.unpack(" 0 else 0.0) + return levels + + +def decode_limit_flags(payload: bytes, n_out: int) -> list[bool]: + """Limiter active per output, from the 2 status bytes after the levels (bit i = output i). + + Seen on a DSP 204: 00 03 while Out 1+2 limit, 00 0C for Out 3+4. That outputs 5-8 of the 408 + continue in the same 16-bit value is an assumption. + """ + if len(payload) < 38: + return [False] * n_out + flags = payload[36] << 8 | payload[37] + return [bool(flags >> i & 1) for i in range(n_out)] + + +def encode_meters(levels: list[float], limit_flags: int = 0) -> bytes: + """Inverse of decode_meters / decode_limit_flags (used by the simulator).""" + out = bytearray() + for v in levels: + raw = struct.pack("> 8 & 0xFF, limit_flags & 0xFF]) + + +# ---------------------------------------------------------------- device models + + +@dataclass(frozen=True) +class Model: + name: str + n_in: int + n_out: int + + @property + def in_size(self) -> int: + return 140 + + @property + def out_size(self) -> int: + return 96 + 2 * self.n_in + + @property + def out_base(self) -> int: + return 0x10 + self.n_in * self.in_size + + @property + def globals_base(self) -> int: + return self.out_base + self.n_out * self.out_size + + @property + def size(self) -> int: + return self.globals_base + 4 + 2 * self.n_in + 2 * self.n_out + 12 + + @property + def chunks(self) -> int: + return -(-self.size // CHUNK_SIZE) + + def channel(self, kind: str, idx: int) -> int: + """Wire channel number for input/output index.""" + return idx if kind == "in" else self.n_in + idx + + def meter_index(self, kind: str, idx: int) -> int: + return idx if kind == "in" else 4 + idx + + +MODELS = {"204": Model("DSP 204", 2, 4), "408": Model("DSP 408", 4, 8)} + + +def detect_model(info: str) -> str | None: + for key in MODELS: + if f"DSP{key}" in info.replace(" ", ""): + return key + return None + + +# ---------------------------------------------------------------- state (de)serialisation + + +_UMLAUTS = str.maketrans({"ä": "ae", "ö": "oe", "ü": "ue", "Ä": "Ae", "Ö": "Oe", "Ü": "Ue", "ß": "ss"}) + + +def clean_name(name) -> str: + """Channel name as the DSP stores it: printable ASCII, at most 8 characters.""" + s = str(name or "").translate(_UMLAUTS) + return "".join(c for c in s if " " <= c <= "~")[:8] + + +def _name(b: bytes) -> str: + return b.split(b"\x00")[0].decode("latin1").strip() + + +def _peq(buf: bytes, off: int, n: int) -> list[dict]: + bands = [] + for i in range(n): + gain, freq, q, typ = struct.unpack_from("= 9}) + return bands + + +def parse_state(model: Model, buf: bytes) -> dict: + """Decode the reassembled config dump into a JSON friendly dict (raw values).""" + u16 = lambda off: struct.unpack_from("> i & 1), + }) + outputs = [] + for i in range(model.n_out): + o = model.out_base + i * model.out_size + p = o + 10 + 2 * model.n_in + outputs.append({ + "name": _name(buf[o : o + 8]), + "matrix": u16(o + 8), + "mix": list(struct.unpack_from(f"<{model.n_in}H", buf, o + 10)), + "hp": {"freq": u16(p), "slope": buf[p + 4]}, + "lp": {"freq": u16(p + 2), "slope": buf[p + 5]}, + "peq": _peq(buf, p + 6, 9), + "comp": dict(zip(("ratio", "attack", "release", "knee", "threshold"), + struct.unpack_from("<5H", buf, p + 60))), + "limit": dict(zip(("attack", "release", "knee", "threshold"), + struct.unpack_from("<4H", buf, p + 70))), + "gain": u16(p + 78), + "polarity": u16(p + 80) != 0, + "delay": u16(p + 82), + "link": u16(p + 84), + "mute": bool(out_mute >> i & 1), + }) + return {"preset_name": _name(buf[2:16]), "inputs": inputs, "outputs": outputs} + + +def build_state_buffer(model: Model, state: dict) -> bytearray: + """Inverse of parse_state (used by the simulator).""" + buf = bytearray(model.chunks * CHUNK_SIZE) + pad = lambda s, n: s.encode("latin1")[:n].ljust(n, b" ") + buf[0:2] = b"\xff\xff" + buf[2:16] = pad(state["preset_name"], 14) + + def put_peq(off, bands): + for i, b in enumerate(bands): + struct.pack_into(" dict: + peq = lambda n: [{"gain": 120, "freq": 50 + i * 25, "q": 32, "type": 0, "bypass": False} + for i in range(n)] + return { + "preset_name": "Default", + "inputs": [{ + "name": f"In{chr(65 + i)}", "gate": {"attack": 0, "release": 99, "hold": 99, "threshold": 0}, + "geq": [120] * 31, "peq": peq(8), "hp": {"freq": 0, "slope": 0}, + "lp": {"freq": 300, "slope": 0}, "gain": 280, "polarity": False, "delay": 0, "mute": False, + "link": 1 << i, + } for i in range(model.n_in)], + "outputs": [{ + "name": f"Out{i + 1}", "matrix": 1 << (i % model.n_in), "mix": [280] * model.n_in, + "hp": {"freq": 0, "slope": 0}, "lp": {"freq": 300, "slope": 0}, "peq": peq(9), + "comp": {"ratio": 0, "attack": 49, "release": 499, "knee": 0, "threshold": 220}, + "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)], + } + + +# ---------------------------------------------------------------- channel links +# +# Every channel stores a u16 link mask (bit = channel index within inputs resp. outputs): +# a free channel has only its own bit, the first channel of a group the bits of all members, +# the other members 0. The DSP itself applies a change on any member to the whole group +# (except name, routing and mix levels) and copies the first channel's settings when a group is formed. + +LINK_EXCLUDED = ("name", "mix", "matrix", "link") # per channel even when linked (e.g. Out 1 <- A, Out 2 <- B) + + +def link_groups(chans: list[dict]) -> list[list[int]]: + """Channel indices grouped by link (single channels included), in channel order.""" + seen: set[int] = set() + groups = [] + for i, ch in enumerate(chans): + if i in seen: + continue + mask = ch.get("link", 1 << i) + g = [j for j in range(len(chans)) if (j == i or mask >> j & 1) and j not in seen] + seen.update(g) + groups.append(g) + return groups + + +def link_group(chans: list[dict], idx: int) -> list[int]: + return next(g for g in link_groups(chans) if idx in g) + + +def link_masks(n: int, groups: list[list[int]]) -> list[int]: + """Per-channel link masks for the given groups (channels not mentioned stay free).""" + masks = [1 << i for i in range(n)] + for g in groups: + g = sorted({i for i in g if 0 <= i < n}) + if len(g) < 2: + continue + masks[g[0]] = sum(1 << i for i in g) + for i in g[1:]: + masks[i] = 0 + return masks + + +def copy_linked(chans: list[dict], src: int, dst: int): + for k, v in chans[src].items(): + if k not in LINK_EXCLUDED: + chans[dst][k] = copy.deepcopy(v) + + +# ---------------------------------------------------------------- parameter -> command + + +def _w(v: int) -> bytes: + return struct.pack(" tuple[int, bytes]: + """Build (cmd, payload) for a changed parameter. `ch` is the already-updated channel dict. + + `param` is a dotted path like "gain", "hp.freq", "peq.3.gain", "geq.10", "mix.1". + """ + c = model.channel(kind, idx) + top, *rest = param.split(".") + if top == "gain": + return CMD_GAIN, bytes([c]) + _w(ch["gain"]) + if top == "mute": + return CMD_MUTE, bytes([c, int(ch["mute"])]) + if top == "polarity": + return CMD_POLARITY, bytes([c, int(ch["polarity"])]) + if top == "delay": + return CMD_DELAY, bytes([c]) + _w(ch["delay"]) + if top == "name": + return CMD_CHANNEL_NAME, bytes([c]) + clean_name(ch["name"]).encode("ascii").ljust(8, b" ") + if top in ("hp", "lp"): + f = ch[top] + return (CMD_HIGH_PASS if top == "hp" else CMD_LOW_PASS), bytes([c]) + _w(f["freq"]) + bytes([f["slope"]]) + if top == "peq": + band = int(rest[0]) + b = ch["peq"][band] + return CMD_PEQ, bytes([c, band]) + _w(b["gain"]) + _w(b["freq"]) + bytes( + [b["q"], b["type"], int(b["bypass"])]) + if top == "geq" and kind == "in": + band = int(rest[0]) + return CMD_GEQ, bytes([c, band]) + _w(ch["geq"][band]) + if top == "gate" and kind == "in": + g = ch["gate"] + return CMD_GATE, bytes([c]) + b"".join(_w(g[k]) for k in ("attack", "release", "hold", "threshold")) + if top == "comp" and kind == "out": + g = ch["comp"] + return CMD_COMP, bytes([c]) + b"".join( + _w(g[k]) for k in ("ratio", "attack", "release", "knee", "threshold")) + if top == "limit" and kind == "out": + g = ch["limit"] + return CMD_LIMIT, bytes([c]) + b"".join(_w(g[k]) for k in ("attack", "release", "knee", "threshold")) + if top == "matrix" and kind == "out": + return CMD_MATRIX, bytes([c, ch["matrix"] & 0xFF]) + if top == "mix" and kind == "out": + i = int(rest[0]) + return CMD_MIX, bytes([c, i]) + _w(ch["mix"][i]) + raise ValueError(f"unknown parameter {kind}.{param}") + + +def apply_param(state_ch: dict, param: str, value): + """Write `value` into the channel dict at the dotted `param` path.""" + keys = param.split(".") + node = state_ch + for k in keys[:-1]: + node = node[int(k)] if isinstance(node, list) else node[k] + last = keys[-1] + if isinstance(node, list): + node[int(last)] = value + else: + node[last] = value + + +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 + 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"] + if idx >= len(chans): + return + ch = chans[idx] + w = lambda o: struct.unpack_from("> j & 1: + copy_linked(chans, idx, j) + return + # like the real DSP: a change on a linked channel applies to the whole group + for j in link_group(chans, idx): + if j != idx: + copy_linked(chans, idx, j) diff --git a/dsp/usbhid.py b/dsp/usbhid.py new file mode 100644 index 0000000..1c4c630 --- /dev/null +++ b/dsp/usbhid.py @@ -0,0 +1,431 @@ +"""USB connection to the DSPs (USB HID, no driver needed). + +Both models enumerate as VID 0x0168 / PID 0x0821. +Every HID report carries exactly one protocol frame starting at byte 0 (the same frames as on TCP, +length = LEN + 8), sent with report ID 0 and zero-padded to the report length. + +Windows uses hid.dll via ctypes, macOS IOKit via ctypes, Linux /dev/hidraw* (Raspberry Pi). No extra packages. +""" + +import asyncio +import os +import sys +import threading + +VID, PID = 0x0168, 0x0821 + + +# ------------------------------------------------------------------ Windows (hid.dll) + +if sys.platform == "win32": + import ctypes + from ctypes import wintypes as W + + _hid = ctypes.WinDLL("hid") + _setup = ctypes.WinDLL("setupapi") + _k32 = ctypes.WinDLL("kernel32", use_last_error=True) + + class _GUID(ctypes.Structure): + _fields_ = [("d1", W.DWORD), ("d2", W.WORD), ("d3", W.WORD), ("d4", ctypes.c_ubyte * 8)] + + class _IFDATA(ctypes.Structure): + _fields_ = [("cbSize", W.DWORD), ("guid", _GUID), ("flags", W.DWORD), ("reserved", ctypes.c_void_p)] + + class _ATTR(ctypes.Structure): + _fields_ = [("Size", W.ULONG), ("VendorID", W.USHORT), ("ProductID", W.USHORT), ("Version", W.USHORT)] + + class _CAPS(ctypes.Structure): + _fields_ = [("Usage", W.USHORT), ("UsagePage", W.USHORT), ("InputReportByteLength", W.USHORT), + ("OutputReportByteLength", W.USHORT), ("FeatureReportByteLength", W.USHORT), + ("Reserved", W.USHORT * 17), ("rest", W.USHORT * 10)] + + _k32.CreateFileW.restype = W.HANDLE + _k32.CreateFileW.argtypes = [W.LPCWSTR, W.DWORD, W.DWORD, ctypes.c_void_p, W.DWORD, W.DWORD, W.HANDLE] + _k32.ReadFile.argtypes = [W.HANDLE, ctypes.c_void_p, W.DWORD, ctypes.POINTER(W.DWORD), ctypes.c_void_p] + _k32.WriteFile.argtypes = [W.HANDLE, ctypes.c_void_p, W.DWORD, ctypes.POINTER(W.DWORD), ctypes.c_void_p] + _k32.CloseHandle.argtypes = [W.HANDLE] + _k32.CancelIoEx.argtypes = [W.HANDLE, ctypes.c_void_p] + _setup.SetupDiGetClassDevsW.restype = W.HANDLE + _setup.SetupDiGetClassDevsW.argtypes = [ctypes.POINTER(_GUID), W.LPCWSTR, W.HWND, W.DWORD] + _setup.SetupDiEnumDeviceInterfaces.argtypes = [W.HANDLE, ctypes.c_void_p, ctypes.POINTER(_GUID), W.DWORD, + ctypes.POINTER(_IFDATA)] + _setup.SetupDiGetDeviceInterfaceDetailW.argtypes = [W.HANDLE, ctypes.POINTER(_IFDATA), ctypes.c_void_p, W.DWORD, + ctypes.POINTER(W.DWORD), ctypes.c_void_p] + _setup.SetupDiDestroyDeviceInfoList.argtypes = [W.HANDLE] + _hid.HidD_GetAttributes.argtypes = [W.HANDLE, ctypes.POINTER(_ATTR)] + _hid.HidD_GetProductString.argtypes = [W.HANDLE, ctypes.c_void_p, W.ULONG] + _hid.HidD_GetSerialNumberString.argtypes = [W.HANDLE, ctypes.c_void_p, W.ULONG] + _hid.HidD_GetPreparsedData.argtypes = [W.HANDLE, ctypes.POINTER(ctypes.c_void_p)] + _hid.HidD_FreePreparsedData.argtypes = [ctypes.c_void_p] + _hid.HidP_GetCaps.argtypes = [ctypes.c_void_p, ctypes.POINTER(_CAPS)] + + _INVALID = W.HANDLE(-1).value + _GENERIC_RW, _SHARE_RW, _OPEN_EXISTING = 0xC0000000, 0x3, 3 + + def _open(path: str, access: int = _GENERIC_RW): + h = _k32.CreateFileW(path, access, _SHARE_RW, None, _OPEN_EXISTING, 0, None) + if h in (None, _INVALID): + raise OSError(ctypes.get_last_error(), f"Cannot open USB device (error {ctypes.get_last_error()})") + return h + + def _string(fn, h) -> str: + buf = ctypes.create_unicode_buffer(128) + return buf.value if fn(h, buf, ctypes.sizeof(buf)) else "" + + def _paths() -> list[str]: + guid = _GUID() + _hid.HidD_GetHidGuid(ctypes.byref(guid)) + info = _setup.SetupDiGetClassDevsW(ctypes.byref(guid), None, None, 0x12) # PRESENT | DEVICEINTERFACE + paths = [] + try: + i = 0 + while True: + ifd = _IFDATA(cbSize=ctypes.sizeof(_IFDATA)) + if not _setup.SetupDiEnumDeviceInterfaces(info, None, ctypes.byref(guid), i, ctypes.byref(ifd)): + break + i += 1 + need = W.DWORD() + _setup.SetupDiGetDeviceInterfaceDetailW(info, ctypes.byref(ifd), None, 0, ctypes.byref(need), None) + buf = ctypes.create_string_buffer(need.value) + ctypes.cast(buf, ctypes.POINTER(W.DWORD))[0] = 8 if ctypes.sizeof(ctypes.c_void_p) == 8 else 6 + if _setup.SetupDiGetDeviceInterfaceDetailW(info, ctypes.byref(ifd), buf, need, None, None): + paths.append(ctypes.wstring_at(ctypes.addressof(buf) + 4)) + finally: + _setup.SetupDiDestroyDeviceInfoList(info) + return paths + + def list_devices() -> list[dict]: + found = [] + for path in _paths(): + try: + h = _open(path, 0) # attributes only: works even while another program has it open + except OSError: + continue + try: + a = _ATTR(Size=ctypes.sizeof(_ATTR)) + if _hid.HidD_GetAttributes(h, ctypes.byref(a)) and (a.VendorID, a.ProductID) == (VID, PID): + found.append({"path": path, "product": _string(_hid.HidD_GetProductString, h), + "serial": _string(_hid.HidD_GetSerialNumberString, h)}) + finally: + _k32.CloseHandle(h) + return found + + class HidDevice: + """One opened DSP. Separate read and write handles: a blocking ReadFile would otherwise + serialise every WriteFile behind it on a synchronous handle.""" + + def __init__(self, path: str): + self.rh = _open(path) + try: + self.wh = _open(path) + pp = ctypes.c_void_p() + caps = _CAPS() + if _hid.HidD_GetPreparsedData(self.rh, ctypes.byref(pp)): + _hid.HidP_GetCaps(pp, ctypes.byref(caps)) + _hid.HidD_FreePreparsedData(pp) + self.in_len = caps.InputReportByteLength or 65 + self.out_len = caps.OutputReportByteLength or 65 + except OSError: + _k32.CloseHandle(self.rh) + raise + + def read_report(self) -> bytes: + buf = ctypes.create_string_buffer(self.in_len) + n = W.DWORD() + if not _k32.ReadFile(self.rh, buf, self.in_len, ctypes.byref(n), None): + raise OSError(ctypes.get_last_error(), "USB connection lost") + return buf.raw[1:n.value] # drop the report ID + + def write_report(self, data: bytes): + report = (b"\x00" + data).ljust(self.out_len, b"\x00")[: self.out_len] + n = W.DWORD() + if not _k32.WriteFile(self.wh, report, len(report), ctypes.byref(n), None): + raise OSError(ctypes.get_last_error(), "USB write error") + + def close(self): + _k32.CancelIoEx(self.rh, None) # wakes up the blocked reader thread + for h in (self.rh, self.wh): + _k32.CloseHandle(h) + + +# ------------------------------------------------------------------ Linux (hidraw) + +elif sys.platform.startswith("linux"): + + def list_devices() -> list[dict]: + found = [] + base = "/sys/class/hidraw" + for name in sorted(os.listdir(base)) if os.path.isdir(base) else []: + try: + with open(f"{base}/{name}/device/uevent") as f: + ev = dict(line.strip().split("=", 1) for line in f if "=" in line) + except OSError: + continue + ids = ev.get("HID_ID", "").split(":") + if len(ids) == 3 and int(ids[1], 16) == VID and int(ids[2], 16) == PID: + found.append({"path": f"/dev/{name}", "product": ev.get("HID_NAME", ""), "serial": ev.get("HID_UNIQ", "")}) + return found + + class HidDevice: + def __init__(self, path: str): + self.fd = os.open(path, os.O_RDWR) + self.in_len = self.out_len = 65 + + def read_report(self) -> bytes: + data = os.read(self.fd, 64) # hidraw returns the report without a report ID + if not data: + raise OSError("USB connection lost") + return data + + def write_report(self, data: bytes): + os.write(self.fd, (b"\x00" + data).ljust(self.out_len, b"\x00")) + + def close(self): + try: + os.close(self.fd) + except OSError: + pass + +# ------------------------------------------------------------------ macOS (IOKit IOHIDDevice) + +elif sys.platform == "darwin": + import ctypes + import queue + + _iokit = ctypes.cdll.LoadLibrary("/System/Library/Frameworks/IOKit.framework/IOKit") + _cf = ctypes.cdll.LoadLibrary("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation") + _vp, _i32 = ctypes.c_void_p, ctypes.c_int32 + + _UTF8, _SINT32, _SINT64 = 0x08000100, 3, 4 + _REPORT_OUTPUT = 1 + _ReportCB = ctypes.CFUNCTYPE(None, _vp, _i32, _vp, ctypes.c_int, ctypes.c_uint32, + ctypes.POINTER(ctypes.c_uint8), ctypes.c_long) + _RemovalCB = ctypes.CFUNCTYPE(None, _vp, _i32, _vp) + + for _name, _res, _args in ( + ("CFStringCreateWithCString", _vp, [_vp, ctypes.c_char_p, ctypes.c_uint32]), + ("CFStringGetCString", ctypes.c_bool, [_vp, ctypes.c_char_p, ctypes.c_long, ctypes.c_uint32]), + ("CFNumberCreate", _vp, [_vp, ctypes.c_int, _vp]), + ("CFNumberGetValue", ctypes.c_bool, [_vp, ctypes.c_int, _vp]), + ("CFGetTypeID", ctypes.c_ulong, [_vp]), + ("CFStringGetTypeID", ctypes.c_ulong, []), + ("CFNumberGetTypeID", ctypes.c_ulong, []), + ("CFDictionaryCreateMutable", _vp, [_vp, ctypes.c_long, _vp, _vp]), + ("CFDictionarySetValue", None, [_vp, _vp, _vp]), + ("CFSetGetCount", ctypes.c_long, [_vp]), + ("CFSetGetValues", None, [_vp, _vp]), + ("CFRetain", _vp, [_vp]), + ("CFRelease", None, [_vp]), + ("CFRunLoopGetCurrent", _vp, []), + ("CFRunLoopRunInMode", _i32, [_vp, ctypes.c_double, ctypes.c_bool]), + ("CFRunLoopStop", None, [_vp]), + ): + getattr(_cf, _name).restype, getattr(_cf, _name).argtypes = _res, _args + for _name, _res, _args in ( + ("IOHIDManagerCreate", _vp, [_vp, ctypes.c_uint32]), + ("IOHIDManagerSetDeviceMatching", None, [_vp, _vp]), + ("IOHIDManagerCopyDevices", _vp, [_vp]), + ("IOHIDDeviceGetProperty", _vp, [_vp, _vp]), + ("IOHIDDeviceOpen", _i32, [_vp, ctypes.c_uint32]), + ("IOHIDDeviceClose", _i32, [_vp, ctypes.c_uint32]), + ("IOHIDDeviceSetReport", _i32, [_vp, ctypes.c_int, ctypes.c_long, _vp, ctypes.c_long]), + ("IOHIDDeviceRegisterInputReportCallback", None, [_vp, _vp, ctypes.c_long, _ReportCB, _vp]), + ("IOHIDDeviceRegisterRemovalCallback", None, [_vp, _RemovalCB, _vp]), + ("IOHIDDeviceScheduleWithRunLoop", None, [_vp, _vp, _vp]), + ("IOHIDDeviceUnscheduleFromRunLoop", None, [_vp, _vp, _vp]), + ): + getattr(_iokit, _name).restype, getattr(_iokit, _name).argtypes = _res, _args + + _MODE = _vp.in_dll(_cf, "kCFRunLoopDefaultMode") + _KEY_CB = _vp.in_dll(_cf, "kCFTypeDictionaryKeyCallBacks") + _VAL_CB = _vp.in_dll(_cf, "kCFTypeDictionaryValueCallBacks") + + def _cfstr(s: str): + return _cf.CFStringCreateWithCString(None, s.encode(), _UTF8) + + def _prop(dev, key: str): + k = _cfstr(key) + try: + v = _iokit.IOHIDDeviceGetProperty(dev, k) + finally: + _cf.CFRelease(k) + if not v: + return None + if _cf.CFGetTypeID(v) == _cf.CFNumberGetTypeID(): + n = ctypes.c_int64() + _cf.CFNumberGetValue(v, _SINT64, ctypes.byref(n)) + return n.value + if _cf.CFGetTypeID(v) == _cf.CFStringGetTypeID(): + buf = ctypes.create_string_buffer(256) + return buf.value.decode(errors="replace") if _cf.CFStringGetCString(v, buf, 256, _UTF8) else "" + return None + + def _path(dev) -> str: + # LocationID identifies the USB port, so a saved device is found again after replugging + return f"usb-loc:{(_prop(dev, 'LocationID') or 0) & 0xFFFFFFFF:08x}" + + def _devices() -> list: + """Retained IOHIDDeviceRefs of all connected DSPs (caller releases them).""" + mgr = _iokit.IOHIDManagerCreate(None, 0) + match = _cf.CFDictionaryCreateMutable(None, 0, ctypes.byref(_KEY_CB), ctypes.byref(_VAL_CB)) + try: + for key, val in (("VendorID", VID), ("ProductID", PID)): + k, n = _cfstr(key), ctypes.c_int32(val) + v = _cf.CFNumberCreate(None, _SINT32, ctypes.byref(n)) + _cf.CFDictionarySetValue(match, k, v) + _cf.CFRelease(k) + _cf.CFRelease(v) + _iokit.IOHIDManagerSetDeviceMatching(mgr, match) + devset = _iokit.IOHIDManagerCopyDevices(mgr) + if not devset: + return [] + count = _cf.CFSetGetCount(devset) + arr = (_vp * count)() + _cf.CFSetGetValues(devset, arr) + devs = [_cf.CFRetain(d) for d in arr] + _cf.CFRelease(devset) + return sorted(devs, key=_path) + finally: + _cf.CFRelease(match) + _cf.CFRelease(mgr) + + def list_devices() -> list[dict]: + found = [] + for dev in _devices(): + found.append({"path": _path(dev), "product": _prop(dev, "Product") or "", + "serial": _prop(dev, "SerialNumber") or ""}) + _cf.CFRelease(dev) + return found + + class HidDevice: + """One opened DSP. IOKit delivers input reports through a run loop, so a private thread + runs one and hands the reports to read_report() through a queue.""" + + def __init__(self, path: str): + devs = _devices() + self.dev = next((d for d in devs if _path(d) == path), None) + for d in devs: + if d != self.dev: + _cf.CFRelease(d) + if not self.dev: + raise OSError("USB device not found – check the cable") + ret = _iokit.IOHIDDeviceOpen(self.dev, 0) & 0xFFFFFFFF + if ret: + _cf.CFRelease(self.dev) + raise OSError(ret, "USB device is in use by another program" if ret == 0xE00002C5 + else f"Cannot open USB device (error 0x{ret:08x})") + self.in_len = _prop(self.dev, "MaxInputReportSize") or 64 + self.out_len = _prop(self.dev, "MaxOutputReportSize") or 64 + self.reports: queue.Queue = queue.Queue() + self.closed = False + self.runloop = None + self.buf = (ctypes.c_uint8 * self.in_len)() + self._on_report = _ReportCB(lambda _c, _r, _s, _t, _id, data, n: self.reports.put(ctypes.string_at(data, n))) + self._on_removal = _RemovalCB(lambda _c, _r, _s: self.reports.put(None)) + ready = threading.Event() + threading.Thread(target=self._run, args=(ready,), daemon=True, name="usb-runloop").start() + ready.wait(5) + + def _run(self, ready: threading.Event): + self.runloop = _cf.CFRunLoopGetCurrent() + _iokit.IOHIDDeviceRegisterInputReportCallback(self.dev, self.buf, self.in_len, self._on_report, None) + _iokit.IOHIDDeviceRegisterRemovalCallback(self.dev, self._on_removal, None) + _iokit.IOHIDDeviceScheduleWithRunLoop(self.dev, self.runloop, _MODE) + ready.set() + while not self.closed: + _cf.CFRunLoopRunInMode(_MODE, 0.5, False) + _iokit.IOHIDDeviceUnscheduleFromRunLoop(self.dev, self.runloop, _MODE) + _iokit.IOHIDDeviceClose(self.dev, 0) + _cf.CFRelease(self.dev) + + def read_report(self) -> bytes: + data = self.reports.get() + if data is None: + raise OSError("USB connection lost") + return data # IOKit delivers the report without a report ID + + def write_report(self, data: bytes): + report = data.ljust(self.out_len, b"\x00")[: self.out_len] + ret = _iokit.IOHIDDeviceSetReport(self.dev, _REPORT_OUTPUT, 0, report, len(report)) & 0xFFFFFFFF + if ret: + raise OSError(ret, f"USB write error (0x{ret:08x})") + + def close(self): + if not self.closed: + self.closed = True + self.reports.put(None) # wakes up the blocked reader thread + if self.runloop: + _cf.CFRunLoopStop(self.runloop) + +else: + def list_devices() -> list[dict]: + return [] + + class HidDevice: + def __init__(self, path: str): + raise OSError("USB is not supported on this system") + + +# ------------------------------------------------------------------ asyncio stream adapter + +def frame_bytes(report: bytes, carry: list) -> bytes: + """The protocol bytes in one input report (strips the zero padding after the frame). + `carry` holds the bytes still missing from a frame longer than one report.""" + if carry[0] > 0: + take = report[: carry[0]] + carry[0] -= len(take) + return take + if report[:2] != b"\x10\x02" or len(report) < 5: + return b"" + need = report[4] + 8 + take = report[:need] + carry[0] = need - len(take) + return take + + +class HidStream: + """Gives a HID device the reader/writer interface Device uses for TCP.""" + + def __init__(self, dev): + self.dev = dev + self.loop = asyncio.get_running_loop() + self.queue: asyncio.Queue = asyncio.Queue() + self.closed = False + threading.Thread(target=self._reader, daemon=True, name="usb-read").start() + + def _reader(self): + carry = [0] + try: + while not self.closed: + data = frame_bytes(self.dev.read_report(), carry) + if data: + self.loop.call_soon_threadsafe(self.queue.put_nowait, data) + except OSError: + pass + self.loop.call_soon_threadsafe(self.queue.put_nowait, b"") # EOF + + async def read(self, _n: int = -1) -> bytes: + return await self.queue.get() + + def write(self, data: bytes): + self.dev.write_report(data) + + async def drain(self): + pass + + def close(self): + if not self.closed: + self.closed = True + self.dev.close() + + +async def open_stream(path: str = "") -> tuple[HidStream, HidStream]: + """Open the DSP at `path` (empty = the first one found).""" + if not path: + devs = await asyncio.to_thread(list_devices) + if not devs: + raise ConnectionError("No DSP found via USB – check the cable") + path = devs[0]["path"] + dev = await asyncio.to_thread(HidDevice, path) + s = HidStream(dev) + return s, s diff --git a/packaging/build.py b/packaging/build.py new file mode 100644 index 0000000..5d4ae45 --- /dev/null +++ b/packaging/build.py @@ -0,0 +1,63 @@ +"""Builds the desktop programs into dist/: + + python -m pip install pyinstaller pywebview pillow + python packaging/build.py + +Windows: + dist/DSP Control.exe desktop app (own window, no PIN; optional remote access with PIN) + dist/DSP Control Pi Writer.exe SD card writer for a Raspberry Pi running the WebUI +macOS: + dist/DSP Control.app the same desktop app + dist/DSP Control.dmg disk image with the app and a link to /Applications +""" + +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +SEP = ";" if sys.platform == "win32" else ":" + + +def pyinstaller(*args, onefile=True): + cmd = [sys.executable, "-m", "PyInstaller", "--noconfirm", "--onefile" if onefile else "--onedir", "--windowed", + "--distpath", str(ROOT / "dist"), "--workpath", str(ROOT / "build"), "--specpath", str(ROOT / "build"), *args] + print(">", " ".join(cmd)) + subprocess.run(cmd, cwd=ROOT, check=True) + + +def data(src, dest="."): + return ["--add-data", f"{ROOT / src}{SEP}{dest}"] + + +def build_mac(): + app = ROOT / "dist" / "DSP Control.app" + pyinstaller("--name", "DSP Control", "--icon", str(ROOT / "packaging" / "dsp-control.icns"), + "--osx-bundle-identifier", "at.thiemoo.dspcontrol", *data("static", "static"), + str(ROOT / "desktop.py"), onefile=False) # a .app bundle is always a folder + shutil.rmtree(ROOT / "dist" / "DSP Control", ignore_errors=True) # the loose onedir copy next to the .app + dmg = ROOT / "dist" / "DSP Control.dmg" + dmg.unlink(missing_ok=True) + with tempfile.TemporaryDirectory() as tmp: + shutil.copytree(app, Path(tmp) / app.name, symlinks=True) + (Path(tmp) / "Applications").symlink_to("/Applications") + subprocess.run(["hdiutil", "create", "-volname", "DSP Control", "-srcfolder", tmp, "-ov", + "-format", "UDZO", str(dmg)], check=True) + print("\nDone:", app.name, dmg.name, sep="\n ") + + +subprocess.run([sys.executable, str(ROOT / "packaging" / "make_icons.py")], check=True) + +if sys.platform == "darwin": + build_mac() + sys.exit() + +pyinstaller("--name", "DSP Control", "--icon", str(ROOT / "packaging" / "dsp-control.ico"), + *data("static", "static"), str(ROOT / "desktop.py")) + +pyinstaller("--name", "DSP Control Pi Writer", "--icon", str(ROOT / "packaging" / "pi-writer.ico"), "--uac-admin", + *data("server.py"), *data("dsp", "dsp"), *data("static", "static"), str(ROOT / "pi_writer.py")) + +print("\nDone:", *(p.name for p in (ROOT / "dist").glob("*.exe")), sep="\n ") diff --git a/packaging/dsp-control.icns b/packaging/dsp-control.icns new file mode 100644 index 0000000000000000000000000000000000000000..8c879895912b5ccbac79127819c5eb7e5226e460 GIT binary patch literal 126528 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 z zn|E$$_BXJO=H-|o_E|sELentq?}`nUJeHGR99Y~Ce>X2n`q#FFGq*k6IQ{pL*@d3_ z7MWe=YIRcGVE*1a)lIK?4`0HRE&p?4Roq#d`j`0dfBSATXZGyhJGWjtr8)PU+}7gV zvU8JD)mi8LU%X|*gzZ!F;{LIo%WuCa_v>5}TEaGBU|_YylCVJ?A_s87UX@vRkAZ>Z z4ncy+m!LvGXL&T+h#jGt2w$n18-hGRf2Er1!IP zXYvit+$n#z`~9E$bF1IkzK>mSYT??DtT(T+IL>9QvoN_boBT`%9XP5l1o$B!R})LyMUue_1jU+{~2gN?Hb|4gHg zHrr4B)p3a|cX1KEn5y`z=GC(sFH2u9P}sZ5)a<9?g8S-=qE1%Dnn@U*Q5Al&h3{nb z<;Ratn!eq@ws!8^T#v`zOutT_{kXMt0{5DqYg3BeJX-bm#Ny@4)oqH?|5Y>XRaz9t z`K0P_M_AtdGe=yKo*JGrpSN?bfrGFmR4A_qUb93 z>gt9U)Bjk=OSpafqO@ZhU(9`$lR7sQSstd|FMm3{^TOtxl`aM|<{jaip*D!wn#`C~}(JbstYNhQT50hJWQb#F({$6 zo0rA;gc}Z=&n0=XHO|^JCt6$EoKFa`?9plud}^>t#%=216-5%Ee2Y&dLIn#9mQUQY z_4y;eInyUxkn+n_4vDr-IeTSl?zh{54n_Pf@;WT7haME%v%2T@JD2kSpHX?xjNM

;U#1~+@X-+iF}HRHt(5hD)mRsNYxcpk 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 literal 0 HcmV?d00001 diff --git a/packaging/dsp-control.ico b/packaging/dsp-control.ico new file mode 100644 index 0000000000000000000000000000000000000000..6dbd58636b7a161288f1f6770f968a284c785358 GIT binary patch literal 10362 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 literal 0 HcmV?d00001 diff --git a/packaging/dsp-control.png b/packaging/dsp-control.png new file mode 100644 index 0000000000000000000000000000000000000000..915b75cca9808e4bbc82e5e7cd09a664e80dd666 GIT binary patch literal 1553 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�dcZ^{?-$#?hsrjqF8ACp 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℞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 literal 0 HcmV?d00001 diff --git a/packaging/pi-writer.ico b/packaging/pi-writer.ico new file mode 100644 index 0000000000000000000000000000000000000000..c4e663db2e81853db6d57715dd3a905565ca2efe GIT binary patch literal 16076 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 literal 0 HcmV?d00001 diff --git a/packaging/pi-writer.png b/packaging/pi-writer.png new file mode 100644 index 0000000000000000000000000000000000000000..5c4595ac5c49f302748b50561d20b273f2898c75 GIT binary patch literal 1771 zcmeAS@N?(olHy`uVBq!ia0y~yU}OMc4mJh`hM1xiX$%Z(n><|{Ln`LHy=z+}6Drd7 z@T31m7WS?=3mXELt=+)BSz!Bcue6z)@M5a|w|IUTrs}~}9 zcI}LC_RnwQOA7eK#A{n^DAMbAvfJp#o2vmjEKBu{J(!%NA=GreU5Uru^PcF>u+q<5 zp+B7*9+_PzVK(?vkYUB{dn) zrDx{4Z)Xt531gV^FW~%~om&_kHk@QE_~jfM{QUFVs_B=upD!<8tFL(M?8h6wgpzi$ zF0kDAR)yhO{WT?~(=&~hn=zacXnf1bu(ZSBB16Rgn_V0+d2jaIV$kqp*`~-aMU}~w zDdF#OQNbDcXYSl$(C}xurp!>{$Z}1Qp~RVG+VgbAuuo4PpI>bM?bqRWyXz;`Uzgu6 z%eVjEzsrB>4SjAi>|yjUHEaBM?(F(#hFvO5rv(^xsWMF$X4s|1G+mHkmpapDPKMnI zOrJRzb}KSn=49Bd#B`a1VYf2VV@`(MDol?#7fkuls)eyL??{neG)82FB+9U*2;w^50=<;rV~1U$GhFi5n9&)pzSQ2qS#s zpmCq;i3`Y&EJeRQADG-Q<-x|MW-JZMY_{E*7R@m0-Sgs>#EiGMhP^u zt=Yfjnb-os*ZQIy3@pM8Y=5rEg>o?X`cwv=mu`412n`*n4gZ2#L6)M1+_UA3JAW9a z`M>&ln(aW6{XU<1mWIG{ygNC*crsXIzbWW;sE3F0v)c_HPAoUS-k!C-`1kkeSJxe8 zJCOA4gUx}rU5CRyR)N)t+-2IfgAeQ>*6j^z~yc1xq}N>o6xx!_^u-Cq-v85`W3Z&&^B2ODl;u~&P}KXoQh z%$wOAT@7U`Oo)HDb|94?{;FR3H>(+<)91b6aE7o4F>OH^v+WgbUHpwwI zu+Fi*t33~Dg4m}^n(<%1*b6p1+V8x6d4KNTUq0##8x|~IUi%bej+A8aslej?_Og>yWV5@^$ALsVUHx3vIVCg!0I@a5bN~PV literal 0 HcmV?d00001 diff --git a/pi_image.py b/pi_image.py new file mode 100644 index 0000000..4e080e1 --- /dev/null +++ b/pi_image.py @@ -0,0 +1,304 @@ +"""Raspberry Pi OS images and first-boot setup for the DSP Control SD card writer. + +The current Raspberry Pi OS Lite images are configured with cloud-init: files in the FAT boot +partition (user-data, network-config, meta-data) plus a NoCloud entry in cmdline.txt - the same +layout Raspberry Pi Imager writes. Our user-data then installs DSP Control from the boot partition +as a systemd service on port 80, so the Pi needs no internet connection. +""" + +import hashlib +import json +import re +import secrets +import shutil +import time +import urllib.request +from pathlib import Path + +import server + +OS_LIST_URL = "https://downloads.raspberrypi.com/os_list_imagingutility_v4.json" +IMAGE_NAMES = {64: "Raspberry Pi OS Lite (64-bit)", 32: "Raspberry Pi OS Lite (32-bit)"} +APP_FILES = ["server.py", "dsp", "static"] # what gets installed on the Pi +USER_AGENT = "DSP-Control-Pi-Writer/1.0" + +# Pi models offered in the writer: (name, description, os bits) +MODELS = [ + ("Raspberry Pi 5", "Pi 5, Pi 500, CM5", 64), + ("Raspberry Pi 4", "Pi 4 B, Pi 400, CM4", 64), + ("Raspberry Pi 3", "Pi 3 A+/B/B+, CM3", 64), + ("Raspberry Pi Zero 2 W", "Zero 2 W", 64), + ("Raspberry Pi 2", "Pi 2 B", 32), + ("Raspberry Pi 1", "Pi 1 A/A+/B/B+", 32), + ("Raspberry Pi Zero", "Zero, Zero W, Zero WH", 32), +] + + +# ------------------------------------------------------------------ OS list / download + +def fetch_os_list() -> dict: + req = urllib.request.Request(OS_LIST_URL, headers={"User-Agent": USER_AGENT}) + with urllib.request.urlopen(req, timeout=30) as r: + return json.loads(r.read()) + + +def find_image(os_list: dict, bits: int) -> dict: + """The Raspberry Pi OS Lite entry for 32 or 64 bit.""" + want = IMAGE_NAMES[bits] + + def walk(items): + for it in items: + if it.get("name") == want and it.get("url"): + return it + found = walk(it.get("subitems") or []) + if found: + return found + return None + + img = walk(os_list.get("os_list", [])) + if not img: + raise RuntimeError(f"„{want}“ nicht in der Raspberry-Pi-Liste gefunden") + if img.get("init_format") not in ("cloudinit", "cloudinit-rpi"): + raise RuntimeError(f"Unbekanntes Einrichtungsformat „{img.get('init_format')}“ – Writer aktualisieren") + return img + + +def download(img: dict, cache_dir: Path, progress) -> Path: + """Download (or reuse) the compressed image and check its SHA-256. progress(done, total).""" + cache_dir.mkdir(parents=True, exist_ok=True) + name = img["url"].rsplit("/", 1)[-1] + dest = cache_dir / name + want = (img.get("image_download_sha256") or "").lower() + if dest.exists() and want and sha256_file(dest) == want: + return dest + for old in cache_dir.glob("*.img.xz"): # keep only the current image + old.unlink(missing_ok=True) + tmp = dest.with_suffix(dest.suffix + ".part") + req = urllib.request.Request(img["url"], headers={"User-Agent": USER_AGENT}) + h = hashlib.sha256() + with urllib.request.urlopen(req, timeout=60) as r, open(tmp, "wb") as f: + total = int(r.headers.get("Content-Length") or img.get("image_download_size") or 0) + done = 0 + while chunk := r.read(1 << 20): + f.write(chunk) + h.update(chunk) + done += len(chunk) + progress(done, total) + if want and h.hexdigest() != want: + tmp.unlink(missing_ok=True) + raise RuntimeError("Download beschädigt (Prüfsumme stimmt nicht) – bitte nochmal versuchen") + tmp.replace(dest) + return dest + + +def sha256_file(path: Path) -> str: + h = hashlib.sha256() + with open(path, "rb") as f: + while chunk := f.read(1 << 20): + h.update(chunk) + return h.hexdigest() + + +# ------------------------------------------------------------------ password hash + +_ITOA = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + + +def sha512_crypt(password: str, salt: str | None = None, rounds: int = 5000) -> str: + """glibc SHA-512 crypt ("$6$..."), accepted by Linux login/PAM. Python has no crypt module on Windows.""" + if salt is None: + salt = "".join(secrets.choice(_ITOA) for _ in range(16)) + p, s = password.encode(), salt.encode()[:16] + rep = lambda block, n: (block * (n // len(block) + 1))[:n] + b = hashlib.sha512(p + s + p).digest() + a = hashlib.sha512(p + s + rep(b, len(p))) + i = len(p) + while i: + a.update(b if i & 1 else p) + i >>= 1 + c = a.digest() + pp = rep(hashlib.sha512(p * len(p)).digest(), len(p)) + ss = rep(hashlib.sha512(s * (16 + c[0])).digest(), len(s)) + for r in range(rounds): + d = hashlib.sha512(pp if r & 1 else c) + if r % 3: + d.update(ss) + if r % 7: + d.update(pp) + d.update(c if r & 1 else pp) + c = d.digest() + out = [] + + def b64(v, n): + for _ in range(n): + out.append(_ITOA[v & 63]) + v >>= 6 + + for x, y, z in ((0, 21, 42), (22, 43, 1), (44, 2, 23), (3, 24, 45), (25, 46, 4), (47, 5, 26), (6, 27, 48), + (28, 49, 7), (50, 8, 29), (9, 30, 51), (31, 52, 10), (53, 11, 32), (12, 33, 54), (34, 55, 13), + (56, 14, 35), (15, 36, 57), (37, 58, 16), (59, 17, 38), (18, 39, 60), (40, 61, 19), (62, 20, 41)): + b64(c[x] << 16 | c[y] << 8 | c[z], 4) + b64(c[63], 2) + return "$6$" + ("" if rounds == 5000 else f"rounds={rounds}$") + s.decode() + "$" + "".join(out) + + +# ------------------------------------------------------------------ first-boot files + +def yq(v: str) -> str: + """YAML double-quoted scalar.""" + return '"' + str(v).replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n").replace("\r", "") + '"' + + +def validate(cfg: dict) -> list[str]: + errs = [] + if not re.fullmatch(r"[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?", cfg["hostname"]): + errs.append("Hostname: nur Kleinbuchstaben, Ziffern und „-“") + if not re.fullmatch(r"[a-z_][a-z0-9_-]{0,31}", cfg["user"]) or cfg["user"] in ("root", "dspctl"): + errs.append("Benutzername: Kleinbuchstaben/Ziffern, nicht „root“") + if len(cfg["password"]) < 4: + errs.append("Passwort: mindestens 4 Zeichen") + if cfg["ssid"] and cfg["wifi_password"] and not 8 <= len(cfg["wifi_password"]) <= 63: + errs.append("WLAN-Passwort: 8 bis 63 Zeichen (leer = offenes WLAN)") + if cfg["ssid"] and not re.fullmatch(r"[A-Za-z]{2}", cfg["country"]): + errs.append("WLAN-Land: zweistelliger Code, z. B. AT") + if not re.fullmatch(r"\d{4}", cfg["pin"]): + errs.append("PIN: 4 Ziffern") + for k in ("dsp204", "dsp408"): + if cfg.get(k) and not re.fullmatch(r"\d{1,3}(\.\d{1,3}){3}", cfg[k]): + errs.append(f"IP-Adresse {k[3:]}: ungültig") + return errs + + +def user_data(cfg: dict) -> str: + lines = [ + "#cloud-config", + "manage_resolv_conf: false", + "", + f"hostname: {yq(cfg['hostname'])}", + "manage_etc_hosts: true", + f"timezone: {yq(cfg.get('timezone') or 'Europe/Vienna')}", + "", + "user:", + f" name: {yq(cfg['user'])}", + " shell: /bin/bash", + " lock_passwd: false", + f" passwd: {yq(sha512_crypt(cfg['password']))}", + " sudo: null", + "", + ] + if cfg.get("ssh"): + lines += ["ssh_pwauth: true", ""] + lines.append("runcmd:") + if cfg.get("ssh"): + lines.append(" - [ systemctl, enable, --now, ssh ]") + if not cfg["ssid"] and cfg.get("country"): + lines.append(" - [ rfkill, unblock, wifi ]") + lines.append(" - [ sh, /boot/firmware/dsp-control/install.sh ]") + return "\n".join(lines) + "\n" + + +def network_config(cfg: dict) -> str | None: + if not cfg["ssid"]: + return None # Ethernet works by default + lines = [ + "network:", + " version: 2", + " ethernets:", + " eth0:", + " dhcp4: true", + " dhcp6: true", + " optional: true", + " wifis:", + " wlan0:", + " dhcp4: true", + f" regulatory-domain: {yq(cfg['country'].upper())}", + " access-points:", + f" {yq(cfg['ssid'])}:", + ] + if cfg["wifi_password"]: + lines.append(f" password: {yq(cfg['wifi_password'])}") + else: + lines += [" auth:", " key-management: none"] + lines.append(" optional: true") + return "\n".join(lines) + "\n" + + +INSTALL_SH = """#!/bin/sh +# DSP Control first-boot install (run once by cloud-init) +set -e +SRC=/boot/firmware/dsp-control +id dspctl >/dev/null 2>&1 || useradd --system --no-create-home --shell /usr/sbin/nologin dspctl +mkdir -p /opt/dsp-control +cp -r "$SRC/app/." /opt/dsp-control/ +install -d -o dspctl -g dspctl -m 700 /var/lib/dsp-control +if [ -f "$SRC/config.json" ]; then + [ -f /var/lib/dsp-control/config.json ] || install -o dspctl -g dspctl -m 600 "$SRC/config.json" /var/lib/dsp-control/config.json + rm -f "$SRC/config.json" +fi +# DSPs on USB (HID, VID 0168 / PID 0821): let the service user open them +echo 'SUBSYSTEM=="hidraw", ATTRS{idVendor}=="0168", ATTRS{idProduct}=="0821", MODE="0666"' > /etc/udev/rules.d/60-dsp-control.rules +udevadm control --reload-rules || true +udevadm trigger --subsystem-match=hidraw || true +install -m 644 "$SRC/dsp-control.service" /etc/systemd/system/dsp-control.service +systemctl daemon-reload +systemctl enable --now dsp-control.service +""" + +SERVICE = """[Unit] +Description=DSP Control WebUI for t.racks DSP 204/408 +After=network-online.target +Wants=network-online.target + +[Service] +User=dspctl +ExecStart=/usr/bin/python3 /opt/dsp-control/server.py --port 80 --config /var/lib/dsp-control/config.json +AmbientCapabilities=CAP_NET_BIND_SERVICE +Restart=always +RestartSec=3 + +[Install] +WantedBy=multi-user.target +""" + + +def initial_config(cfg: dict) -> dict: + salt = secrets.token_hex(16) + devices = [] + for key, name, model in (("dsp204", "DSP 204", "204"), ("dsp408", "DSP 408", "408")): + if cfg.get(key): + devices.append({"id": key, "name": name, "host": cfg[key], "port": 9761, "model": model, + "addr": 1, "autoconnect": True}) + return {"devices": devices, "auth": {"salt": salt, "hash": server.hash_pin(cfg["pin"], salt)}, "sessions": {}} + + +def write_boot_files(boot: Path, cfg: dict, app_root: Path): + """Put the first-boot setup and the DSP Control files onto the mounted boot partition.""" + if not (boot / "cmdline.txt").exists(): + raise RuntimeError(f"{boot} ist keine Raspberry-Pi-Bootpartition (cmdline.txt fehlt)") + target = boot / "dsp-control" + if target.exists(): + shutil.rmtree(target) + (target / "app").mkdir(parents=True) + for name in APP_FILES: + src = app_root / name + if src.is_dir(): + shutil.copytree(src, target / "app" / name, ignore=shutil.ignore_patterns("__pycache__", "*.pyc")) + else: + shutil.copy2(src, target / "app" / name) + lf = lambda p, text: p.write_text(text, encoding="utf-8", newline="\n") + lf(target / "install.sh", INSTALL_SH) + lf(target / "dsp-control.service", SERVICE) + lf(target / "config.json", json.dumps(initial_config(cfg), indent=2)) + + instance = f"dsp-control-{int(time.time() * 1000)}" + lf(boot / "meta-data", f"instance-id: {instance}\n") + lf(boot / "user-data", user_data(cfg)) + net = network_config(cfg) + if net: + lf(boot / "network-config", net) + cmdline = (boot / "cmdline.txt").read_text(encoding="utf-8").strip() + cmdline = re.sub(r"\s*ds=nocloud;i=\S+", "", cmdline) + cmdline += f" ds=nocloud;i={instance}" + if not cfg["ssid"] and cfg.get("country") and "cfg80211.ieee80211_regdom" not in cmdline: + cmdline += f" cfg80211.ieee80211_regdom={cfg['country'].upper()}" + lf(boot / "cmdline.txt", cmdline + "\n") diff --git a/pi_writer.py b/pi_writer.py new file mode 100644 index 0000000..49582c4 --- /dev/null +++ b/pi_writer.py @@ -0,0 +1,262 @@ +"""DSP Control Pi Writer: prepares a bootable SD card with Raspberry Pi OS Lite + DSP Control. + +After the first boot (2-5 minutes) the WebUI is at http://.local - no monitor, +keyboard or internet needed on the Pi. + +Build: pyinstaller packaging/pi-writer.spec +""" + +import json +import os +import queue +import sys +import threading +import tkinter as tk +import traceback +from pathlib import Path +from tkinter import messagebox, ttk + +import pi_image +import win_disk + +APP = "DSP Control Pi Writer" +ROOT = Path(getattr(sys, "_MEIPASS", Path(__file__).resolve().parent)) # bundled app files +SETTINGS = Path(os.environ.get("APPDATA") or Path.home()) / "DSP Control" / "pi-writer.json" +CACHE = Path(os.environ.get("LOCALAPPDATA") or Path.home()) / "DSP Control" / "pi-images" +REMEMBER = ("model", "hostname", "ssid", "country", "user", "ssh", "dsp204", "dsp408", "verify") + + +class Writer(tk.Tk): + def __init__(self): + super().__init__() + self.title(APP) + self.minsize(560, 640) + self.events: queue.Queue = queue.Queue() + self.busy = False + self.disks: list[dict] = [] + saved = self.load_settings() + + self.v = { + "model": tk.StringVar(value=saved.get("model", pi_image.MODELS[1][0])), + "disk": tk.StringVar(), + "hostname": tk.StringVar(value=saved.get("hostname", "dsp-control")), + "ssid": tk.StringVar(value=saved.get("ssid", "")), + "wifi_password": tk.StringVar(), + "country": tk.StringVar(value=saved.get("country", "AT")), + "user": tk.StringVar(value=saved.get("user", "dsp")), + "password": tk.StringVar(), + "ssh": tk.BooleanVar(value=saved.get("ssh", True)), + "pin": tk.StringVar(value="1234"), + "dsp204": tk.StringVar(value=saved.get("dsp204", "")), + "dsp408": tk.StringVar(value=saved.get("dsp408", "")), + "verify": tk.BooleanVar(value=saved.get("verify", True)), + } + self.build() + self.after(100, self.poll) + self.after(200, self.refresh_disks) + + # ------------------------------------------------------------ layout + + def build(self): + pad = {"padx": 12, "pady": 4} + root = ttk.Frame(self, padding=(8, 8)) + root.pack(fill="both", expand=True) + root.columnconfigure(0, weight=1) + + ttk.Label(root, text="Raspberry Pi für DSP Control", font=("Segoe UI", 14, "bold")).grid(sticky="w", **pad) + ttk.Label(root, text="Schreibt Raspberry Pi OS Lite mit vorinstallierter DSP-Control-WebUI auf eine SD-Karte.", + foreground="#555").grid(sticky="w", padx=12) + + def section(title): + f = ttk.LabelFrame(root, text=title, padding=(10, 6)) + f.grid(sticky="ew", padx=12, pady=6) + f.columnconfigure(0, minsize=110) + f.columnconfigure(1, weight=1) + return f + + def row(f, r, label, widget, hint=None): + ttk.Label(f, text=label).grid(row=r, column=0, sticky="w", pady=3, padx=(0, 10)) + widget.grid(row=r, column=1, sticky="ew", pady=3) + if hint: + ttk.Label(f, text=hint, foreground="#777").grid(row=r, column=2, sticky="w", padx=(8, 0)) + + f = section("1 · Gerät") + models = [f"{n} ({d})" for n, d, _ in pi_image.MODELS] + cur = next((m for m in models if m.startswith(self.v["model"].get())), models[1]) + self.model_box = ttk.Combobox(f, values=models, state="readonly") + self.model_box.set(cur) + row(f, 0, "Raspberry Pi", self.model_box) + disk_row = ttk.Frame(f) + disk_row.columnconfigure(0, weight=1) + self.disk_box = ttk.Combobox(disk_row, textvariable=self.v["disk"], state="readonly") + self.disk_box.grid(row=0, column=0, sticky="ew") + ttk.Button(disk_row, text="↻", width=3, command=self.refresh_disks).grid(row=0, column=1, padx=(6, 0)) + row(f, 1, "SD-Karte", disk_row) + + f = section("2 · Netzwerk") + row(f, 0, "Hostname", ttk.Entry(f, textvariable=self.v["hostname"]), ".local") + row(f, 1, "WLAN-Name", ttk.Entry(f, textvariable=self.v["ssid"]), "leer = nur LAN-Kabel") + row(f, 2, "WLAN-Passwort", ttk.Entry(f, textvariable=self.v["wifi_password"], show="•")) + row(f, 3, "Land", ttk.Entry(f, textvariable=self.v["country"], width=6), "z. B. AT, DE, CH") + + f = section("3 · Zugang") + row(f, 0, "Benutzer", ttk.Entry(f, textvariable=self.v["user"]), "für SSH / Wartung") + row(f, 1, "Passwort", ttk.Entry(f, textvariable=self.v["password"], show="•")) + ttk.Checkbutton(f, text="SSH aktivieren", variable=self.v["ssh"]).grid(row=2, column=1, sticky="w", pady=3) + row(f, 3, "WebUI-PIN", ttk.Entry(f, textvariable=self.v["pin"], width=8), "4 Ziffern, später änderbar") + + f = section("4 · DSPs (optional, später in der WebUI änderbar)") + row(f, 0, "IP DSP 204", ttk.Entry(f, textvariable=self.v["dsp204"]), "z. B. 192.168.1.101") + row(f, 1, "IP DSP 408", ttk.Entry(f, textvariable=self.v["dsp408"])) + + bottom = ttk.Frame(root) + bottom.grid(sticky="ew", padx=12, pady=(8, 4)) + bottom.columnconfigure(0, weight=1) + ttk.Checkbutton(bottom, text="Nach dem Schreiben überprüfen", variable=self.v["verify"]).grid(row=0, column=0, sticky="w") + self.go = ttk.Button(bottom, text="SD-Karte schreiben", command=self.start) + self.go.grid(row=0, column=1, sticky="e") + self.bar = ttk.Progressbar(root, maximum=1000) + self.bar.grid(sticky="ew", padx=12, pady=(6, 2)) + self.status = ttk.Label(root, text="Bereit.", foreground="#333") + self.status.grid(sticky="w", padx=12, pady=(0, 8)) + + # ------------------------------------------------------------ settings + + def load_settings(self) -> dict: + try: + return json.loads(SETTINGS.read_text(encoding="utf-8")) + except (OSError, ValueError): + return {} + + def save_settings(self, cfg: dict): + try: + SETTINGS.parent.mkdir(parents=True, exist_ok=True) + SETTINGS.write_text(json.dumps({k: cfg[k] for k in REMEMBER if k in cfg}, indent=2), encoding="utf-8") + except OSError: + pass + + # ------------------------------------------------------------ disks + + def refresh_disks(self): + if self.busy: + return + self.status.config(text="Suche SD-Karten…") + threading.Thread(target=self._list_disks, daemon=True).start() + + def _list_disks(self): + try: + self.events.put(("disks", win_disk.list_disks())) + except Exception as e: # noqa: BLE001 + self.events.put(("disks_err", str(e))) + + # ------------------------------------------------------------ run + + def collect(self) -> dict: + cfg = {k: (v.get().strip() if isinstance(v, tk.StringVar) and k not in ("password", "wifi_password") else v.get()) + for k, v in self.v.items()} + cfg["hostname"] = cfg["hostname"].lower() + cfg["user"] = cfg["user"].lower() + idx = self.model_box.current() + cfg["model"], _, cfg["bits"] = pi_image.MODELS[max(0, idx)] + return cfg + + def start(self): + if self.busy: + return + cfg = self.collect() + errs = pi_image.validate(cfg) + disk = next((d for d in self.disks if win_disk.describe(d) == cfg["disk"]), None) + if not disk: + errs.insert(0, "Bitte eine SD-Karte wählen") + if errs: + messagebox.showerror(APP, "\n".join(errs)) + return + if not messagebox.askyesno(APP, f"ALLE Daten auf\n\n{win_disk.describe(disk)}\n\nwerden gelöscht. Fortfahren?", + icon="warning"): + return + self.save_settings(cfg) + self.busy = True + self.go.config(state="disabled") + threading.Thread(target=self.job, args=(cfg, disk), daemon=True).start() + + def job(self, cfg: dict, disk: dict): + ev = self.events.put + try: + ev(("status", "Lade Raspberry-Pi-OS-Liste…", None)) + img = pi_image.find_image(pi_image.fetch_os_list(), cfg["bits"]) + ev(("status", f"{img['name']} vom {img.get('release_date', '?')}", None)) + path = pi_image.download(img, CACHE, lambda d, t: ev(("progress", f"Download {d / 1e6:.0f} / {t / 1e6:.0f} MB", d, t))) + phases = {"write": "Schreibe", "verify": "Überprüfe"} + win_disk.write_image(disk["Number"], path, int(img.get("extract_size") or 0), + lambda ph, d, t: ev(("progress", f"{phases[ph]} {d / 1e9:.2f} / {t / 1e9:.2f} GB", d, t)), + verify=cfg["verify"]) + ev(("status", "Richte DSP Control ein…", None)) + boot = win_disk.mount_boot_partition(disk["Number"]) + pi_image.write_boot_files(boot, cfg, ROOT) + win_disk.eject(boot) + ev(("done", cfg)) + except Exception as e: # noqa: BLE001 - every failure is shown to the user + traceback.print_exc() + ev(("error", str(e))) + + def poll(self): + try: + while True: + kind, *a = self.events.get_nowait() + if kind == "disks": + self.disks = a[0] + names = [win_disk.describe(d) for d in self.disks] + self.disk_box.config(values=names) + if self.v["disk"].get() not in names: + self.v["disk"].set(names[0] if len(names) == 1 else "") + self.status.config(text=f"{len(names)} SD-Karte(n) gefunden." if names + else "Keine SD-Karte gefunden – einstecken und ↻ drücken.") + elif kind == "disks_err": + self.status.config(text="Fehler beim Suchen: " + a[0]) + elif kind == "status": + self.status.config(text=a[0]) + self.bar.config(mode="indeterminate") + self.bar.start(15) + elif kind == "progress": + text, done, total = a + self.bar.stop() + self.bar.config(mode="determinate", value=1000 * done / total if total else 0) + self.status.config(text=text) + elif kind in ("done", "error"): + self.busy = False + self.go.config(state="normal") + self.bar.stop() + self.bar.config(mode="determinate", value=1000 if kind == "done" else 0) + if kind == "done": + cfg = a[0] + self.status.config(text="Fertig.") + messagebox.showinfo(APP, "Fertig! Die SD-Karte kann entnommen werden.\n\n" + "Karte in den Raspberry Pi stecken, Netzwerk (LAN oder WLAN) und Strom anschließen. " + "Der erste Start dauert 2–5 Minuten.\n\n" + f"Dann im Browser öffnen: http://{cfg['hostname']}.local\n" + f"PIN: {cfg['pin']}") + else: + self.status.config(text="Fehler: " + a[0]) + messagebox.showerror(APP, a[0]) + self.refresh_disks() + except queue.Empty: + pass + self.after(100, self.poll) + + +def main(): + if sys.platform == "win32" and not win_disk.is_admin(): + if win_disk.relaunch_as_admin(): + return + messagebox.showerror(APP, "Zum Beschreiben von SD-Karten werden Administratorrechte benötigt.") + return + try: + import ctypes + ctypes.windll.shcore.SetProcessDpiAwareness(1) # sharp text on high-DPI screens + except (AttributeError, OSError): + pass + Writer().mainloop() + + +if __name__ == "__main__": + main() diff --git a/server.py b/server.py new file mode 100644 index 0000000..b474e14 --- /dev/null +++ b/server.py @@ -0,0 +1,646 @@ +"""DSP Control - web server for t.racks DSP 204 / DSP 408. + +Usage: python server.py [--host 0.0.0.0] [--port 8080] [--config config.json] +Then open http://:8080 on your phone. +""" + +import argparse +import asyncio +import base64 +import errno +import hashlib +import json +import logging +import mimetypes +import re +import secrets +import socket +import sys +import time +import uuid +from pathlib import Path +from urllib.parse import parse_qs, urlsplit + +from dsp import preset, usbhid +from dsp.device import Device + +ROOT = Path(__file__).resolve().parent +STATIC = (ROOT / "static").resolve() # resolved: in the macOS .app bundle it is a symlink +log = logging.getLogger("server") + +DEFAULT_PIN = "1234" +SESSION_TTL = 30 * 24 * 3600 # stay logged in for 30 days +MAX_SESSIONS = 50 +COOKIE = "dspsess" +CONFIG_FORMAT = "dsp-control-config" +MAX_UNDO = 20 # automatic backups kept per DSP before each import + + +def _num(v, lo: float, hi: float, default: float = 0.0) -> float: + try: + v = float(v) + except (TypeError, ValueError): + return default + return min(hi, max(lo, v)) if v == v else default + + +def local_ips() -> list[str]: + """IPv4 addresses other devices on the LAN can reach this computer at.""" + ips = [] + try: + with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: + s.connect(("192.0.2.1", 9)) # no packet is sent; just picks the outgoing interface + ips.append(s.getsockname()[0]) + except OSError: + pass + try: + for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET): + ip = info[4][0] + if ip not in ips and not ip.startswith(("127.", "169.254.")): + ips.append(ip) + except OSError: + pass + return ips + + +def clean_limiter(data: dict) -> dict: + """Validate the limiter calculator data (amplifier profiles + output assignments).""" + amps = [] + for a in (data.get("amps") or [])[:100]: + amps.append({ + "id": re.sub(r"[^\w-]", "", str(a.get("id") or uuid.uuid4().hex[:8]))[:16] or uuid.uuid4().hex[:8], + "name": str(a.get("name") or "Amplifier")[:40], + "mode": "gain" if a.get("mode") == "gain" else "sens", + "sens": _num(a.get("sens"), 0.05, 20, 1.4), + "gain": _num(a.get("gain"), 0, 60, 32), + "p8": _num(a.get("p8"), 0, 100000), "p4": _num(a.get("p4"), 0, 100000), "p2": _num(a.get("p2"), 0, 100000), + }) + ids = {a["id"] for a in amps} + assign = {} + for k, v in (data.get("assign") or {}).items(): + if re.fullmatch(r"[\w-]+:\d{1,2}", str(k)) and isinstance(v, dict) and v.get("amp") in ids: + assign[k] = {"amp": v["amp"], "ohm": _num(v.get("ohm"), 1, 32, 8), + "spk": _num(v.get("spk"), 0, 100000)} + ref = {str(k)[:32]: _num(v, -20, 30) for k, v in (data.get("ref") or {}).items()} + return {"amps": amps, "assign": assign, "ref": ref} + + +def hash_pin(pin: str, salt: str) -> str: + return hashlib.pbkdf2_hmac("sha256", pin.encode(), bytes.fromhex(salt), 100_000).hex() + + +def token_id(token: str) -> str: + """Sessions are stored hashed so config.json never contains a usable cookie.""" + return hashlib.sha256(token.encode()).hexdigest() + + +class App: + def __init__(self, config_path: Path): + self.config_path = config_path + self.devices: dict[str, Device] = {} + self.clients: set[asyncio.Queue] = set() + self.auth: dict = {} + self.sessions: dict[str, float] = {} # token hash -> expiry + self.failures: dict[str, tuple[int, float]] = {} # ip -> (failed attempts, locked until) + self.limiter: dict = clean_limiter({}) + # desktop app: its own window logs in with a one-time token, other devices need the PIN + self.app_token: str | None = None + self.app_sessions: set[str] = set() + self.remote = {"enabled": False, "port": 8080} + self.remote_server: asyncio.Server | None = None + self.remote_writers: set[asyncio.StreamWriter] = set() + self.remote_error = "" + self.locked = False # desktop app window read-only until unlocked with the PIN + self.lang = "" # UI language chosen in the desktop app ("" = not chosen yet, English) + + # ------------------------------------------------------------ config + + def load(self): + if self.config_path.exists(): + cfg = json.loads(self.config_path.read_text(encoding="utf-8")) + else: + cfg = {"devices": [ + {"id": "dsp204", "name": "DSP 204", "host": "192.168.1.101", "model": "204", "autoconnect": False}, + {"id": "dsp408", "name": "DSP 408", "host": "192.168.1.102", "model": "408", "autoconnect": False}, + ]} + now = time.time() + self.sessions = {k: v for k, v in cfg.get("sessions", {}).items() if v > now} + self.locked = bool(cfg.get("locked")) + self.lang = cfg.get("lang") if cfg.get("lang") in ("en", "de") else "" + self.apply_config(cfg) + + def apply_config(self, cfg: dict): + """Devices, PIN, limiter data and remote settings from a config dict (file or backup).""" + auth = cfg.get("auth") or {} + if re.fullmatch(r"[0-9a-f]{32}", str(auth.get("salt", ""))) and re.fullmatch(r"[0-9a-f]{64}", str(auth.get("hash", ""))): + self.auth = {"salt": auth["salt"], "hash": auth["hash"]} + elif not self.auth: # first start (a backup without PIN keeps the current one) + self.set_pin(DEFAULT_PIN, save=False) + self.limiter = clean_limiter(cfg.get("limiter") or {}) + r = cfg.get("remote") or {} + self.remote = {"enabled": bool(r.get("enabled")), "port": int(_num(r.get("port"), 1, 65535, 8080))} + for d in cfg.get("devices", [])[:20]: + if isinstance(d, dict): + self.add_device(d, save=False) + self.save() + + # ------------------------------------------------------------ backups + + def export_config(self) -> dict: + """App backup: devices, PIN (hashed), amplifiers/limiter data, remote access - no logins.""" + return {"format": CONFIG_FORMAT, "version": 1, "exported": time.strftime("%Y-%m-%dT%H:%M:%S"), + "devices": [d.config() for d in self.devices.values()], "auth": self.auth, + "limiter": self.limiter, "remote": self.remote} + + async def restore_config(self, doc: dict, session: str): + if not isinstance(doc, dict) or doc.get("format") != CONFIG_FORMAT: + raise ValueError("Not a DSP Control settings backup") + for dev in list(self.devices.values()): + await dev.stop() + del self.devices[dev.id] + self.broadcast({"type": "removed", "device": dev.id}) + old_auth = self.auth + self.apply_config(doc) + if self.auth != old_auth: # new PIN: other devices have to log in again + self.sessions = {k: v for k, v in self.sessions.items() if k == session or k in self.app_sessions} + self.save() + for dev in self.devices.values(): + self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) + self.broadcast({"type": "limiter", "data": self.limiter}) + if self.app_token: # desktop app: (re)start or stop the LAN listener as restored + await self.start_remote() + + @property + def undo_dir(self) -> Path: + return self.config_path.parent / "backups" + + def undo_files(self, dev_id: str) -> list[Path]: + return sorted(self.undo_dir.glob(f"{dev_id}-*.json"), reverse=True) + + async def import_preset(self, dev: Device, body: dict) -> dict: + if dev.status != "online" or not dev.state: + raise RuntimeError("DSP is not connected") + raw = base64.b64decode(body["raw"]) if body.get("raw") else None + state = preset.read_file(dev.model_name, dev.model, dev.state, doc=body.get("doc"), raw=raw) + # safety copy of the current state first, so the import can be undone + current = await dev.export_preset() + self.undo_dir.mkdir(exist_ok=True) + stamp = time.strftime("%Y%m%d-%H%M%S") + (self.undo_dir / f"{dev.id}-{stamp}.json").write_text(json.dumps(current), encoding="utf-8") + for old in self.undo_files(dev.id)[MAX_UNDO:]: + old.unlink(missing_ok=True) + diffs = await dev.import_preset(state) + return {"ok": not diffs, "differences": diffs[:20], "name": state.get("preset_name", "")} + + async def undo_import(self, dev: Device) -> dict: + files = self.undo_files(dev.id) + if not files: + raise RuntimeError("No backup available") + doc = json.loads(files[0].read_text(encoding="utf-8")) + state = preset.read_file(dev.model_name, dev.model, dev.state, doc=doc) + diffs = await dev.import_preset(state) + files[0].unlink() + return {"ok": not diffs, "differences": diffs[:20]} + + def save(self): + sessions = {k: v for k, v in self.sessions.items() if k not in self.app_sessions} + cfg = {"devices": [d.config() for d in self.devices.values()], "auth": self.auth, + "sessions": sessions, "limiter": self.limiter, "remote": self.remote, "locked": self.locked} + if self.lang: + cfg["lang"] = self.lang + self.config_path.write_text(json.dumps(cfg, indent=2), encoding="utf-8") + + def add_device(self, d: dict, save=True) -> Device: + dev_id = d.get("id") or uuid.uuid4().hex[:8] + usb = d.get("transport") == "usb" + dev = Device(dev_id, d.get("name") or d.get("host") or "DSP (USB)", str(d.get("host") or ""), + 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 "")) + self.devices[dev_id] = dev + if dev.autoconnect: + dev.start() + if save: + self.save() + return dev + + # ------------------------------------------------------------ auth + + def set_pin(self, pin: str, save=True): + salt = secrets.token_hex(16) + self.auth = {"salt": salt, "hash": hash_pin(pin, salt)} + if save: + self.save() + + def check_pin(self, pin: str) -> bool: + return secrets.compare_digest(hash_pin(str(pin), self.auth["salt"]), self.auth["hash"]) + + def session_of(self, headers: dict) -> str | None: + """Hashed session id of a valid login cookie, else None.""" + for part in headers.get("cookie", "").split(";"): + k, _, v = part.strip().partition("=") + if k == COOKIE and v: + tid = token_id(v) + if self.sessions.get(tid, 0) > time.time(): + return tid + return None + + def new_session(self) -> str: + token = secrets.token_urlsafe(32) + self.sessions[token_id(token)] = time.time() + SESSION_TTL + if len(self.sessions) > MAX_SESSIONS: + for k in sorted(self.sessions, key=self.sessions.get)[: len(self.sessions) - MAX_SESSIONS]: + del self.sessions[k] + self.save() + return token + + @staticmethod + def cookie(token: str, max_age: int) -> str: + return f"Set-Cookie: {COOKIE}={token}; Path=/; Max-Age={max_age}; HttpOnly; SameSite=Strict\r\n" + + async def guarded_pin(self, who: str, pin) -> tuple[int, dict]: + """Check a PIN with brute-force protection per client: 200 if right, else 401/429.""" + count, until = self.failures.get(who, (0, 0.0)) + if until > time.time(): + return 429, {"error": "locked", "retry": round(until - time.time())} + if self.check_pin(str(pin or "")): + self.failures.pop(who, None) + return 200, {"ok": True} + await asyncio.sleep(0.4) # slow down guessing + count += 1 + # 5 tries, then a 30 s lock that doubles with every further 5 failures (max 15 min) + lock = min(900, 30 * 2 ** (count // 5 - 1)) if count % 5 == 0 else 0 + self.failures[who] = (count, time.time() + lock) + return 401, {"error": "wrong pin", "retry": lock, "left": 5 - count % 5} + + async def login(self, ip: str, body: dict) -> tuple[int, dict, str]: + status, result = await self.guarded_pin(ip, body.get("pin")) + return status, result, self.cookie(self.new_session(), SESSION_TTL) if status == 200 else "" + + async def change_pin(self, session: str, body: dict) -> tuple[int, dict]: + new = str(body.get("new", "")) + # the desktop app window belongs to the owner of this computer: no current PIN needed (forgotten PIN) + if session not in self.app_sessions and not self.check_pin(str(body.get("current", ""))): + return 400, {"error": "Current PIN is wrong"} + if not re.fullmatch(r"\d{4}", new): + return 400, {"error": "The PIN must be 4 digits"} + self.set_pin(new, save=False) + # log out all other devices (the app window stays) + self.sessions = {k: v for k, v in self.sessions.items() if k == session or k in self.app_sessions} + self.save() + return 200, {"ok": True} + + # ------------------------------------------------------------ desktop app + + def app_login(self, token: str) -> str | None: + """Session cookie value for the app window, if the one-time token matches.""" + if not self.app_token or not secrets.compare_digest(token, self.app_token): + return None + cookie = secrets.token_urlsafe(32) + self.sessions[token_id(cookie)] = time.time() + SESSION_TTL + self.app_sessions.add(token_id(cookie)) + return cookie + + def set_locked(self, locked: bool): + self.locked = locked + self.save() + self.broadcast({"type": "lock", "locked": locked}) + + @staticmethod + def allowed_while_locked(method: str, path: str) -> bool: + """What the locked app window may still do: look at everything, export presets.""" + if path in ("/api/unlock", "/api/events", "/api/lang"): + return True + if method == "GET": + return path != "/api/backup" # holds the PIN hash + return method == "POST" and re.fullmatch(r"/api/devices/[\w-]+/(export|backups)", path) is not None + + def remote_info(self) -> dict: + return {**self.remote, "running": self.remote_server is not None, "error": self.remote_error, + "platform": sys.platform, + # only the main address: the others are usually virtual adapters (WSL, Hyper-V, VPN) + "urls": [f"http://{ip}:{self.remote['port']}" for ip in local_ips()[:1]]} + + async def start_remote(self): + """(Re)start the LAN listener for other devices according to self.remote.""" + self.stop_remote() + self.remote_error = "" + if not self.remote["enabled"]: + return + try: + self.remote_server = await asyncio.start_server( + lambda r, w: self.handle(r, w, remote=True), "0.0.0.0", self.remote["port"]) + log.info("Remote access on port %d", self.remote["port"]) + except OSError as e: + in_use = e.errno in (errno.EADDRINUSE, 98, 10048) or getattr(e, "winerror", None) == 10048 + self.remote_error = (f"Port {self.remote['port']} is already in use – please choose another port" if in_use + else f"Port {self.remote['port']} is not available ({e.strerror or e})") + log.warning("Remote access failed: %s", e) + + def stop_remote(self): + if self.remote_server: + self.remote_server.close() + self.remote_server = None + for w in list(self.remote_writers): # also end open connections (live event streams) + w.close() + self.remote_writers.clear() + + async def set_remote(self, body: dict) -> dict: + if "enabled" in body: + self.remote["enabled"] = bool(body["enabled"]) + if "port" in body: + self.remote["port"] = int(_num(body["port"], 1, 65535, 8080)) + self.save() + await self.start_remote() + return self.remote_info() + + async def shutdown(self): + self.stop_remote() + for d in self.devices.values(): + await d.stop() + + # ------------------------------------------------------------ events + + def broadcast(self, ev: dict): + msg = json.dumps(ev, separators=(",", ":")) + for q in list(self.clients): + if ev["type"] == "meters" and q.qsize() > 50: + continue # slow client: drop meter frames, never state changes + q.put_nowait(msg) + + # ------------------------------------------------------------ API + + async def api(self, method: str, path: str, body: dict): + if path == "/api/devices" and method == "GET": + return [d.snapshot() for d in self.devices.values()] + if path == "/api/devices" and method == "POST": + return self.add_device(body).snapshot() + if path == "/api/usb" and method == "GET": + return await asyncio.to_thread(usbhid.list_devices) + if path == "/api/limiter" and method == "GET": + return self.limiter + if path == "/api/limiter" and method == "PUT": + self.limiter = clean_limiter(body) + self.save() + self.broadcast({"type": "limiter", "data": self.limiter}) + return self.limiter + m = re.fullmatch(r"/api/devices/([\w-]+)(?:/(\w+))?(?:/(\w+))?", path) + if not m or m.group(1) not in self.devices: + raise KeyError(path) + dev = self.devices[m.group(1)] + action = "/".join(g for g in m.groups()[1:] if g) + if method == "DELETE" and not action: + await dev.stop() + del self.devices[dev.id] + self.save() + self.broadcast({"type": "removed", "device": dev.id}) + return {"ok": True} + if method == "PUT" and not action: + was_running = dev._want_connected + await dev.stop() + for k in ("name", "host", "model", "usb"): + if k in body: + setattr(dev, "model_key" if k == "model" else k, str(body[k])) + if "transport" in body: + dev.transport = "usb" if body["transport"] == "usb" else "tcp" + for k in ("port", "addr"): + if k in body: + setattr(dev, k, int(body[k])) + if "autoconnect" in body: + dev.autoconnect = bool(body["autoconnect"]) + self.save() + if was_running: + dev.start() + self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) + return dev.snapshot() + if method != "POST": + raise KeyError(path) + if action == "connect": + dev.start() + return {"ok": True} + if action == "disconnect": + await dev.stop() + return {"ok": True} + if action == "set": + dev.set_param(body["kind"], int(body["idx"]), body["param"], body["value"]) + return {"ok": True} + if action == "preset/recall": + await dev.recall_preset(int(body["index"])) + return {"ok": True} + if action == "preset/store": + await dev.store_preset(int(body["index"]), str(body["name"])) + return {"ok": True} + if action == "export": + return await dev.export_preset() + if action == "import": + return await self.import_preset(dev, body) + if action == "undo": + return await self.undo_import(dev) + if action == "backups": + return [{"file": f.name, "time": f.stat().st_mtime} for f in self.undo_files(dev.id)] + if action == "link": + kind = "in" if body.get("kind") == "in" else "out" + groups = [[int(i) for i in g] for g in body.get("groups") or [] if isinstance(g, list)] + await dev.set_links(kind, groups) + return {"ok": True} + if action == "refresh": + await dev.refresh() + return {"ok": True} + raise KeyError(path) + + # ------------------------------------------------------------ HTTP + + async def handle(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, remote=False): + if remote: + self.remote_writers.add(writer) + try: + await self._handle(reader, writer, remote) + finally: + self.remote_writers.discard(writer) + + async def _handle(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, remote: bool): + try: + head = await reader.readuntil(b"\r\n\r\n") + except (asyncio.IncompleteReadError, asyncio.LimitOverrunError, ConnectionError): + writer.close() + return + lines = head.decode("latin1").split("\r\n") + try: + method, target, _ = lines[0].split(" ", 2) + except ValueError: + writer.close() + return + headers = {k.lower(): v.strip() for k, _, v in (l.partition(":") for l in lines[1:] if l)} + url = urlsplit(target) + path = url.path + body = b"" + if int(headers.get("content-length", 0)): + body = await reader.readexactly(int(headers["content-length"])) + try: + if path == "/app-login" and not remote: + cookie = self.app_login(parse_qs(url.query).get("t", [""])[0]) + if cookie: + await self.respond(writer, 302, b"", "text/plain", + "Location: /\r\n" + self.cookie(cookie, SESSION_TTL)) + else: + await self.respond(writer, 401, b"invalid app token", "text/plain") + return + if path.startswith("/api/"): + try: + data = json.loads(body) if body else {} + except ValueError: + data = {} + session = self.session_of(headers) + if session in self.app_sessions and remote: + session = None # the window's session never counts on the LAN listener + is_app = session in self.app_sessions + if path == "/api/auth": + await self.respond_json(writer, 200, {"authenticated": bool(session), "app": is_app, + "locked": is_app and self.locked, + "lang": self.lang if is_app else ""}) + return + if path == "/api/login" and method == "POST": + ip = (writer.get_extra_info("peername") or ("?",))[0] + status, result, cookie = await self.login(ip, data) + await self.respond_json(writer, status, result, cookie) + return + if path == "/api/logout" and method == "POST": + if self.sessions.pop(session, None): + self.save() + await self.respond_json(writer, 200, {"ok": True}, self.cookie("", 0)) + return + if not session: + await self.respond_json(writer, 401, {"error": "login required"}) + return + if is_app and self.locked and not self.allowed_while_locked(method, path): + await self.respond_json(writer, 423, {"error": "Locked – unlock with the PIN to make changes"}) + return + if path == "/api/lang" and method == "PUT": + if is_app and data.get("lang") in ("en", "de"): + self.lang = data["lang"] + self.save() + await self.respond_json(writer, 200, {"lang": self.lang}) + return + if path in ("/api/lock", "/api/unlock") and method == "POST": + if not is_app: + await self.respond_json(writer, 403, {"error": "desktop app only"}) + elif path == "/api/lock": + self.set_locked(True) + await self.respond_json(writer, 200, {"locked": True}) + else: + status, result = await self.guarded_pin("app-unlock", data.get("pin")) + if status == 200: + self.set_locked(False) + # not 401: the page would take that for "logged out" + await self.respond_json(writer, 400 if status == 401 else status, result) + return + if path == "/api/pin" and method == "POST": + await self.respond_json(writer, *await self.change_pin(session, data)) + return + if path == "/api/backup": + if method == "GET": + await self.respond_json(writer, 200, self.export_config()) + elif not is_app and not self.check_pin(str(data.get("pin", ""))): + # on the LAN only with the PIN: a backup can replace it + await self.respond_json(writer, 400, {"error": "Wrong PIN"}) + else: + try: + await self.restore_config(data.get("doc"), session) + await self.respond_json(writer, 200, {"ok": True}) + except ValueError as e: + await self.respond_json(writer, 400, {"error": str(e)}) + return + if path == "/api/remote": + if not is_app: + await self.respond_json(writer, 403, {"error": "desktop app only"}) + elif method == "PUT": + await self.respond_json(writer, 200, await self.set_remote(data)) + else: + await self.respond_json(writer, 200, self.remote_info()) + return + if path == "/api/events": + await self.sse(writer) + return + if path.startswith("/api/"): + try: + result = await self.api(method, path, json.loads(body) if body else {}) + await self.respond(writer, 200, json.dumps(result).encode(), "application/json") + except KeyError as e: + await self.respond(writer, 404, json.dumps({"error": f"not found: {e}"}).encode(), + "application/json") + except Exception as e: # noqa: BLE001 - report any API error to the client + log.exception("API error") + await self.respond(writer, 400, json.dumps({"error": str(e)}).encode(), "application/json") + return + await self.static(writer, path) + except (ConnectionError, asyncio.CancelledError): + pass + finally: + try: + writer.close() + except Exception: # noqa: BLE001 + pass + + async def respond(self, writer, status: int, data: bytes, ctype: str, extra: str = ""): + reason = {200: "OK", 302: "Found", 400: "Bad Request", 401: "Unauthorized", 403: "Forbidden", + 404: "Not Found", 423: "Locked", 429: "Too Many Requests"}.get(status, "OK") + writer.write(f"HTTP/1.1 {status} {reason}\r\nContent-Type: {ctype}\r\nContent-Length: {len(data)}\r\n" + f"Cache-Control: no-cache\r\n{extra}Connection: close\r\n\r\n".encode() + data) + await writer.drain() + + async def respond_json(self, writer, status: int, obj, extra: str = ""): + await self.respond(writer, status, json.dumps(obj).encode(), "application/json", extra) + + async def static(self, writer, path: str): + rel = "index.html" if path in ("/", "") else path.lstrip("/") + f = (STATIC / rel).resolve() + if STATIC not in f.parents or not f.is_file(): + await self.respond(writer, 404, b"not found", "text/plain") + return + ctype = mimetypes.guess_type(f.name)[0] or "application/octet-stream" + if ctype.startswith("text/") or ctype.endswith("javascript"): + ctype += "; charset=utf-8" + await self.respond(writer, 200, f.read_bytes(), ctype) + + async def sse(self, writer): + writer.write(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nCache-Control: no-cache\r\n" + b"Connection: keep-alive\r\nX-Accel-Buffering: no\r\n\r\n") + q: asyncio.Queue = asyncio.Queue() + self.clients.add(q) + try: + hello = {"type": "hello", "devices": [d.snapshot() for d in self.devices.values()], "limiter": self.limiter} + writer.write(f"data: {json.dumps(hello)}\n\n".encode()) + await writer.drain() + while True: + try: + msg = await asyncio.wait_for(q.get(), timeout=15) + writer.write(f"data: {msg}\n\n".encode()) + except asyncio.TimeoutError: + writer.write(b": ping\n\n") + await writer.drain() + finally: + self.clients.discard(q) + + +async def main(): + ap = argparse.ArgumentParser(description="Web control for t.racks DSP 204/408") + ap.add_argument("--host", default="0.0.0.0") + ap.add_argument("--port", type=int, default=8080) + ap.add_argument("--config", default=str(ROOT / "config.json")) + ap.add_argument("-v", "--verbose", action="store_true") + args = ap.parse_args() + logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO, + format="%(asctime)s %(name)s %(levelname)s %(message)s") + app = App(Path(args.config)) + app.load() + server = await asyncio.start_server(app.handle, args.host, args.port) + log.info("DSP Control running on http://%s:%d", "localhost" if args.host == "0.0.0.0" else args.host, args.port) + async with server: + await server.serve_forever() + + +if __name__ == "__main__": + try: + asyncio.run(main()) + except KeyboardInterrupt: + pass diff --git a/sim.py b/sim.py new file mode 100644 index 0000000..490faed --- /dev/null +++ b/sim.py @@ -0,0 +1,108 @@ +"""Simulated t.racks DSP for testing without hardware. + +Usage: python sim.py --model 204 --port 9761 + python sim.py --model 408 --port 9762 +""" + +import argparse +import asyncio +import copy +import logging +import math +import time + +from dsp import protocol as P + +log = logging.getLogger("sim") + + +class SimDSP: + def __init__(self, model_key: str): + self.key = model_key + self.model = P.MODELS[model_key] + self.state = P.default_state(self.model) + self.presets = [copy.deepcopy(self.state) if i == 0 else None for i in range(20)] + self.presets[0]["preset_name"] = "Default" + self.pending_name = "" + + def preset_names(self) -> list[str]: + return [p["preset_name"] if p else "" for p in self.presets] + + def handle(self, cmd: int, p: bytes) -> tuple[int, bytes]: + m = self.model + if cmd == P.CMD_DEVICE_INFO: + return cmd, f"DSP{self.key} V010 SIM".encode() + if cmd == P.CMD_PRESET_COUNT: + return cmd, bytes([0, len(self.presets)]) + if cmd == P.CMD_PRESET_NAME: + return cmd, bytes([p[0]]) + self.preset_names()[p[0]].encode("latin1").ljust(14, b" ") + if cmd == P.CMD_CONFIG_REQUEST: + buf = P.build_state_buffer(m, self.state) + n = p[0] + return P.CMD_CONFIG_CHUNK, bytes([n]) + bytes(buf[n * P.CHUNK_SIZE:(n + 1) * P.CHUNK_SIZE]) + if cmd == P.CMD_METER: + t = time.monotonic() + levels = [0.0] * 12 + 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) + levels[m.meter_index("in", i)] = lv + flags = 0 + for o in range(m.n_out): + ch = self.state["outputs"][o] + src = sum(levels[m.meter_index("in", i)] for i in range(m.n_in) if ch["matrix"] >> i & 1) + lv = 0.0 if ch["mute"] else min(1.5, src * 10 ** (P.gain_to_db(ch["gain"]) / 20)) + levels[m.meter_index("out", o)] = lv + if lv > 0 and 20 * math.log10(lv) > P.threshold_to_db(ch["limit"]["threshold"]): + flags |= 1 << o + return cmd, P.encode_meters(levels, flags) + if cmd == P.CMD_PRESET_RECALL: + preset = self.presets[p[0] - 1] + if preset: + self.state = copy.deepcopy(preset) + elif cmd == P.CMD_PRESET_STORE_NAME: + self.pending_name = p.decode("latin1").strip() + elif cmd == P.CMD_PRESET_STORE: + self.state["preset_name"] = self.pending_name or f"Preset {p[0]}" + self.presets[p[0] - 1] = copy.deepcopy(self.state) + else: + P.apply_command(m, self.state, cmd, p) + return P.CMD_ACK, b"\x00" + + async def serve(self, reader, writer): + peer = writer.get_extra_info("peername") + log.info("client %s connected", peer) + parser = P.FrameParser() + try: + while data := await reader.read(4096): + for f in parser.feed(data): + if f.cmd != P.CMD_METER: + log.info("rx cmd=0x%02x payload=%s", f.cmd, f.payload.hex(" ")) + cmd, payload = self.handle(f.cmd, f.payload) + writer.write(P.build_frame(cmd, payload, addr=0, src=1)) + await writer.drain() + except ConnectionError: + pass + log.info("client %s disconnected", peer) + writer.close() + + +async def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--model", choices=list(P.MODELS), default="204") + ap.add_argument("--port", type=int, default=P.PORT) + ap.add_argument("--host", default="127.0.0.1") + args = ap.parse_args() + logging.basicConfig(level=logging.INFO, format=f"%(asctime)s sim{args.model} %(message)s") + sim = SimDSP(args.model) + server = await asyncio.start_server(sim.serve, args.host, args.port) + log.info("simulated DSP %s on %s:%d", args.model, args.host, args.port) + async with server: + await server.serve_forever() + + +if __name__ == "__main__": + try: + asyncio.run(main()) + except KeyboardInterrupt: + pass diff --git a/start.bat b/start.bat new file mode 100644 index 0000000..4bc86a1 --- /dev/null +++ b/start.bat @@ -0,0 +1,4 @@ +@echo off +cd /d "%~dp0" +python server.py %* +pause diff --git a/static/app.js b/static/app.js new file mode 100644 index 0000000..a1bdb2c --- /dev/null +++ b/static/app.js @@ -0,0 +1,1729 @@ +"use strict"; + +// ------------------------------------------------------------------ value scales (see PROTOCOL.md) + +const Q_TABLE = [0.4,0.42,0.45,0.47,0.5,0.53,0.56,0.59,0.63,0.67,0.71,0.75,0.79,0.84,0.89,0.94,1.0,1.06,1.12,1.19, + 1.26,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.1,2.2,2.4,2.5,2.7,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.2,4.5,4.8,5.0,5.3,5.7,6.0, + 6.3,6.7,7.1,7.6,8.0,8.5,9.0,9.5,10.1,10.7,11.3,12.0,12.7,13.5,14.0,15,16,17,18,19,20,21,23,24,25,27,29,30,32,34, + 36,38,40,43,45,48,51,54,57,60,64,68,72,76,81,85,91,96,102,108,114,121,128]; +const RATIOS = ["1:1.0","1:1.1","1:1.3","1:1.5","1:1.7","1:2.0","1:2.5","1:3.0","1:3.5","1:4.0","1:5.0","1:6.0", + "1:8.0","1:10","1:20","Limit"]; +const PEQ_TYPES = ["Peak","Low Shelf","High Shelf","HPF -6","HPF -12","LPF -6","LPF -12","Allpass 1","Allpass 2"]; +const PEQ_SHORT = ["PK","LS","HS","HP6","HP12","LP6","LP12","AP1","AP2"]; +const SLOPES = ["Bypass","BW -6","BL -6","BW -12","BL -12","LK -12","BW -18","BL -18","BW -24","BL -24","LK -24", + "BW -30","BL -30","BW -36","BL -36","LK -36","BW -42","BL -42","BW -48","BL -48","LK -48"]; +const GEQ_FREQS = ["20","25","31","40","50","63","80","100","125","160","200","250","315","400","500","630","800", + "1k","1.2k","1.6k","2k","2.5k","3.1k","4k","5k","6.3k","8k","10k","12k","16k","20k"]; +const IN_COLORS = ["#38bdf8", "#a78bfa", "#34d399", "#f472b6"]; + +const gainDb = r => r < 80 ? r / 2 - 60 : (r - 280) / 10; +const dbGain = db => Math.max(0, Math.min(400, db < -20 ? Math.round((db + 60) * 2) : Math.round(db * 10 + 280))); +const freqHz = r => 1000 * Math.pow(2, (r - 170) / 30); +const hzFreq = hz => Math.max(0, Math.min(300, Math.round(170 + 30 * Math.log2(Math.max(hz, 1) / 1000)))); +const eqDb = r => (r - 120) / 10; +const sign = v => (v > 0 ? "+" : "") + v.toFixed(1); +const fmtHz = hz => hz >= 1000 ? (hz / 1000).toFixed(hz >= 10000 ? 1 : 2) + " kHz" : hz.toFixed(hz < 100 ? 1 : 0) + " Hz"; +const fmtHzShort = hz => hz >= 1000 ? +(hz / 1000).toFixed(hz >= 10000 ? 0 : 1) + "k" : String(Math.round(hz)); +const nearestQ = q => Q_TABLE.reduce((best, v, i) => Math.abs(v - q) < Math.abs(Q_TABLE[best] - q) ? i : best, 0); +const num = s => parseFloat(String(s).replace(",", ".").replace(/[^0-9.+-]/g, "")); +const clamp = (v, a, b) => Math.max(a, Math.min(b, v)); + +// Parameter specs: raw range, display/parse in user units, optional 0-dB detent ("zero") +const SPEC = { + gain: { min: 0, max: 400, zero: 280, fmt: r => sign(gainDb(r)) + " dB", parse: s => dbGain(num(s)), hint: "-60 … +12 dB" }, + mix: { min: 0, max: 280, zero: 280, fmt: r => sign(gainDb(r)) + " dB", parse: s => Math.min(280, dbGain(num(s))), hint: "-60 … 0 dB" }, + delay: { min: 0, max: 65280, def: 0, fmt: r => (r / 96).toFixed(2) + " ms · " + (r / 96 * 0.343).toFixed(2) + " m", + parse: s => /m\s*$/i.test(s) && !/ms/i.test(s) ? Math.round(num(s) / 0.343 * 96) : Math.round(num(s) * 96), + hint: t("in ms, or metres with “m” (e.g. 2.5m)") }, + freq: { min: 0, max: 300, fmt: r => fmtHz(freqHz(r)), parse: s => hzFreq(/k/i.test(s) ? num(s) * 1000 : num(s)), hint: t("20 Hz … 20 kHz, e.g. 1.2k") }, + eqgain: { min: 0, max: 240, zero: 120, fmt: r => sign(eqDb(r)) + " dB", parse: s => Math.round(num(s) * 10 + 120), hint: "-12 … +12 dB" }, + q: { min: 0, max: 100, fmt: r => "Q " + Q_TABLE[r], parse: s => nearestQ(num(s)), hint: "0.4 … 128" }, + gthresh: { min: 0, max: 180, fmt: r => sign((r - 180) / 2) + " dB", parse: s => Math.round(num(s) * 2 + 180), hint: "-90 … 0 dB" }, + thresh: { min: 0, max: 220, fmt: r => sign((r - 180) / 2) + " dB", parse: s => Math.round(num(s) * 2 + 180), hint: "-90 … +20 dB" }, + attack: { min: 0, max: 998, fmt: r => (r + 1) + " ms", parse: s => Math.round(num(s)) - 1, hint: "1 … 999 ms" }, + release: { min: 9, max: 2999, fmt: r => (r + 1) + " ms", parse: s => Math.round(num(s)) - 1, hint: "10 … 3000 ms" }, + hold: { min: 9, max: 998, fmt: r => (r + 1) + " ms", parse: s => Math.round(num(s)) - 1, hint: "10 … 999 ms" }, + ratio: { min: 0, max: 15, fmt: r => RATIOS[r], parse: s => Math.max(0, RATIOS.findIndex(x => x.endsWith(s))), hint: t("e.g. 4.0") }, + knee: { min: 0, max: 12, fmt: r => r + " dB", parse: s => Math.round(num(s)), hint: "0 … 12 dB" }, +}; +const GAIN_TICKS = [[400, "+12"], [340, "+6"], [280, "0"], [220, "-6"], [160, "-12"], [80, "-20"], [40, "-40"], [0, "-60"]]; + +// ------------------------------------------------------------------ app state + +const store = { + get: k => { try { return localStorage.getItem(k); } catch { return null; } }, + set: (k, v) => { try { localStorage.setItem(k, v); } catch { /* private mode */ } }, +}; +const S = { + devices: {}, order: [], cur: store.get("dsp.cur"), + view: store.get("dsp.view") || "mixer", settings: false, + sel: { kind: "in", idx: 0 }, band: 0, busy: false, dirty: false, + routeOpen: null, es: null, linkSel: { in: [], out: [] }, + lim: { amps: [], assign: {}, ref: {} }, +}; +const $ = sel => document.querySelector(sel); +const main = $("#main"); + +function h(tag, attrs = {}, ...children) { + const el = document.createElement(tag); + for (const [k, v] of Object.entries(attrs || {})) { + if (v == null || v === false) continue; + if (k.startsWith("on")) el.addEventListener(k.slice(2), v); + else if (k === "class") el.className = v; + else if (k === "style") el.style.cssText = v; + else el.setAttribute(k, v === true ? "" : v); + } + for (const c of children.flat()) if (c != null && c !== false) el.append(c.nodeType ? c : document.createTextNode(c)); + return el; +} +const svgIcon = d => { const s = document.createElementNS("http://www.w3.org/2000/svg", "svg"); + s.setAttribute("viewBox", "0 0 24 24"); s.innerHTML = d; return s; }; +const ICON = { + prev: '', next: '', + edit: '', logout: '', + back: '', + lock: '', + unlock: '', + link: '', +}; + +function toast(msg) { + const el = $("#toast"); + el.textContent = msg; el.hidden = false; + clearTimeout(toast.timer); toast.timer = setTimeout(() => (el.hidden = true), 2500); +} +const buzz = () => { try { navigator.vibrate && navigator.vibrate(8); } catch { /* unsupported */ } }; + +async function api(method, path, body) { + const r = await fetch(path, { method, headers: { "Content-Type": "application/json" }, + body: body ? JSON.stringify(body) : undefined, credentials: "same-origin" }); + const data = await r.json().catch(() => ({})); + if (r.status === 401 && !path.startsWith("/api/login")) { showLogin(); throw new Error(t("Please log in")); } + if (!r.ok) throw new Error(trMsg(data.error || r.statusText)); + return data; +} + +const dev = () => S.devices[S.cur]; +const where = d => d.transport === "usb" ? "USB" : d.host; // connection label +const chans = (d, kind) => d.state[kind === "in" ? "inputs" : "outputs"]; +const chLabel = (kind, i) => kind === "in" ? "In " + String.fromCharCode(65 + i) : "Out " + (i + 1); +// Channel names: the DSP keeps 8 ASCII characters; on top of that a name must fit the mixer strip, +// so wide letters (W, M, @) count more. Every other place showing names is at least as wide. +const NAME_MAX = 8, NAME_PX = 76; +const UMLAUT = { ä: "ae", ö: "oe", ü: "ue", Ä: "Ae", Ö: "Oe", Ü: "Ue", ß: "ss" }; +let nameCtx; +function nameWidth(s) { + if (!nameCtx) { + nameCtx = document.createElement("canvas").getContext("2d"); + const probe = h("span", { class: "nm", style: "position:absolute;visibility:hidden" }); + const head = h("div", { class: "strip-head", style: "position:absolute;visibility:hidden" }, probe); + document.body.append(head); + const cs = getComputedStyle(probe); + nameCtx.font = `${cs.fontWeight} ${cs.fontSize} ${cs.fontFamily}`; + head.remove(); + } + return nameCtx.measureText(s).width; +} +function cleanName(s) { + s = [...s.replace(/[äöüÄÖÜß]/g, c => UMLAUT[c])].filter(c => c >= " " && c <= "~").join("").slice(0, NAME_MAX); + while (s && nameWidth(s) > NAME_PX) s = s.slice(0, -1); + return s; +} + +const chTitle = (d, kind, i) => { const n = chans(d, kind)[i].name; return n ? `${chLabel(kind, i)} · ${n}` : chLabel(kind, i); }; + +// Channel links (see protocol.py): a free channel's mask is its own bit, the first channel of a +// group holds all members' bits, the others 0. The DSP mirrors changes within a group itself. +const LINK_COLORS = ["#f59e0b", "#22d3ee", "#a3e635", "#f472b6"]; +function linkGroups(list) { + const seen = new Set(), groups = []; + list.forEach((ch, i) => { + if (seen.has(i)) return; + const mask = ch.link ?? (1 << i); + const g = list.map((_, j) => j).filter(j => (j === i || mask >> j & 1) && !seen.has(j)); + g.forEach(j => seen.add(j)); + groups.push(g); + }); + return groups; +} +const linkedGroups = (d, kind) => linkGroups(chans(d, kind)).filter(g => g.length > 1); +function linkInfo(d, kind, i) { // {group, color} if the channel is linked, else null + const gs = linkedGroups(d, kind), n = gs.findIndex(g => g.includes(i)); + return n < 0 ? null : { group: gs[n], color: LINK_COLORS[n % LINK_COLORS.length] }; +} +const linkBadge = (d, kind, i) => { + const l = linkInfo(d, kind, i); + return l ? h("span", { class: "lnk", style: `--lc:${l.color}`, title: t("Linked: ") + l.group.map(j => chLabel(kind, j)).join(" + ") }, + svgIcon(ICON.link)) : null; +}; + +function getPath(obj, path) { + return path.split(".").reduce((o, k) => o[Array.isArray(o) ? +k : k], obj); +} +function setPath(obj, path, value) { + const keys = path.split("."); + const last = keys.pop(); + const node = keys.reduce((o, k) => o[Array.isArray(o) ? +k : k], obj); + node[Array.isArray(node) ? +last : last] = value; +} + +// While the user drags something, incoming updates must not rebuild the DOM under their finger. +function beginBusy() { S.busy = true; } +function endBusy() { S.busy = false; if (S.dirty) { S.dirty = false; render(); } } + +// ------------------------------------------------------------------ dialogs (no native prompt/confirm: they are blocked in some webviews) + +function modal({ title, body, actions, onOpen }) { + return new Promise(resolve => { + const root = $("#modal"); + let done = false; + const close = v => { + if (done) return; done = true; + root.hidden = true; root.replaceChildren(); + document.removeEventListener("keydown", onKey, true); + resolve(v); + }; + const primary = actions.find(a => a.primary); + const btns = actions.map(a => h("button", { class: a.cls || (a.primary ? "on" : ""), + onclick: () => { const v = a.value ? a.value() : null; if (v !== undefined) close(v); } }, a.label)); + const onKey = e => { + if (e.key === "Escape") { e.preventDefault(); close(null); } + else if (e.key === "Enter" && primary && e.target.tagName !== "TEXTAREA") { + e.preventDefault(); btns[actions.indexOf(primary)].click(); + } + }; + document.addEventListener("keydown", onKey, true); + root.replaceChildren( + h("div", { class: "backdrop", onclick: () => close(null) }), + h("div", { class: "dialog", role: "dialog", "aria-modal": "true", "aria-label": title }, + h("h2", {}, title), body, h("div", { class: "dlg-actions" }, btns))); + root.hidden = false; + const first = root.querySelector("input, select"); + setTimeout(() => { if (first) { first.focus(); first.select && first.select(); } else if (primary) btns[actions.indexOf(primary)].focus(); onOpen && onOpen(); }, 30); + }); +} + +const askConfirm = (title, text, okLabel = "OK", danger = false) => modal({ + title, body: h("p", { class: "dlg-text" }, text), + actions: [{ label: t("Cancel") }, { label: okLabel, primary: true, cls: danger ? "danger-on" : "on", value: () => true }], +}); + +// ------------------------------------------------------------------ files (desktop app: native dialogs via pywebview) + +const today = () => new Date().toISOString().slice(0, 10); +const fileSafe = s => (s || "").replace(/[^\w\- .]+/g, "").trim().replace(/\s+/g, "_") || "preset"; + +async function saveFile(name, obj) { + const text = JSON.stringify(obj, null, 2); + const papi = window.pywebview && window.pywebview.api; + if (papi && papi.save_file) return papi.save_file(name, text); + const a = h("a", { href: URL.createObjectURL(new Blob([text], { type: "application/json" })), download: name }); + document.body.append(a); a.click(); a.remove(); + setTimeout(() => URL.revokeObjectURL(a.href), 10000); + return true; +} + +// -> { name, b64, json } (json = parsed content if the file is JSON, else null), or null if cancelled +async function openFile() { + let name, bytes; + const papi = window.pywebview && window.pywebview.api; + if (papi && papi.open_file) { + const f = await papi.open_file(); + if (!f) return null; + name = f.name; bytes = Uint8Array.from(atob(f.data), c => c.charCodeAt(0)); + } else { + const file = await new Promise(resolve => { + const inp = h("input", { type: "file", accept: ".json,.bin,application/json,application/octet-stream", hidden: true }); + inp.addEventListener("change", () => resolve(inp.files[0] || null)); + document.body.append(inp); inp.click(); setTimeout(() => inp.remove(), 60000); + }); + if (!file) return null; + if (file.size > 5e6) throw new Error(t("File is too large")); + name = file.name; bytes = new Uint8Array(await file.arrayBuffer()); + } + let json = null; + try { json = JSON.parse(new TextDecoder().decode(bytes)); } catch { /* binary */ } + let bin = ""; + bytes.forEach(b => (bin += String.fromCharCode(b))); + return { name, b64: btoa(bin), json }; +} + +function askValue(label, spec, raw) { + const input = h("input", { type: "text", value: spec.fmt(raw).replace(/^Q /, "").replace(/ ·.*$/, ""), + autocomplete: "off", spellcheck: "false", enterkeyhint: "done" }); + const quick = spec.zero != null + ? h("button", { class: "chip", onclick: () => { input.value = "0"; input.focus(); } }, "0 dB") : null; + return modal({ + title: label, + body: h("div", {}, h("div", { class: "row" }, input, quick), h("p", { class: "info" }, spec.hint || "")), + actions: [{ label: t("Cancel") }, { label: t("Apply"), primary: true, value: () => { + const s = input.value.trim(); + if (!s || isNaN(num(s))) { input.classList.add("bad"); return undefined; } + return clamp(spec.parse(s), spec.min, spec.max); + } }], + }); +} + +// ------------------------------------------------------------------ sending (throttled per parameter) + +// Controls on screen that can follow a value without re-rendering (linked channels, other devices' +// changes while a fader is held): "dev|kind|idx|param" -> [update functions]. Rebuilt on every render. +const live = new Map(); +function onLive(kind, idx, param, fn) { + const key = `${S.cur}|${kind}|${idx}|${param}`; + live.set(key, [...(live.get(key) || []), fn]); +} +const showLive = (key, v) => (live.get(key) || []).forEach(fn => fn(v)); +const LINK_OWN = ["name", "mix", "matrix", "link"]; // per channel even when linked (see protocol.py) + +const sendTimers = new Map(), sendPending = new Map(), recentlySet = new Map(); +function setParam(kind, idx, param, value) { + const d = dev(); + if (!d || !d.state) return; + setPath(chans(d, kind)[idx], param, value); + const key = `${d.id}|${kind}|${idx}|${param}`; + recentlySet.set(key, Date.now()); + // the DSP applies it to linked channels itself: move them along right away + const li = !LINK_OWN.includes(param.split(".")[0]) && linkInfo(d, kind, idx); + if (li) for (const j of li.group) if (j !== idx) { + setPath(chans(d, kind)[j], param, JSON.parse(JSON.stringify(value))); + recentlySet.set(`${d.id}|${kind}|${j}|${param}`, Date.now()); + showLive(`${d.id}|${kind}|${j}|${param}`, value); + } + const body = { kind, idx, param, value }; + const fire = b => api("POST", `/api/devices/${d.id}/set`, b).catch(e => toast(t("Error: ") + e.message)); + if (sendTimers.has(key)) { sendPending.set(key, body); return; } + fire(body); + sendTimers.set(key, setTimeout(function tick() { + if (sendPending.has(key)) { + fire(sendPending.get(key)); sendPending.delete(key); + sendTimers.set(key, setTimeout(tick, 60)); + } else sendTimers.delete(key); + }, 60)); +} + +// ------------------------------------------------------------------ controls + +// −/+ button with press-and-hold auto-repeat that speeds up the longer it is held +function stepper(dir, fn) { + const b = h("button", { class: "step", "aria-label": dir > 0 ? t("Increase") : t("Decrease"), tabindex: "-1" }, dir > 0 ? "+" : "−"); + let timer = null, n = 0; + const stop = () => { if (timer !== null) { clearTimeout(timer); timer = null; endBusy(); } }; + b.addEventListener("pointerdown", e => { + e.preventDefault(); beginBusy(); n = 0; fn(dir); + timer = setTimeout(function rep() { n++; fn(dir * (n > 30 ? 10 : n > 12 ? 3 : 1)); timer = setTimeout(rep, 70); }, 380); + }); + for (const ev of ["pointerup", "pointerleave", "pointercancel"]) b.addEventListener(ev, stop); + b.addEventListener("click", e => { if (e.detail === 0) fn(dir); }); // keyboard activation + return b; +} + +// Snap to the detent if a dragged value lands within `px` pixels of it. +function detent(v, zero, range, lengthPx, px = 10) { + if (zero == null) return v; + return Math.abs(v - zero) <= Math.max(1, range * px / Math.max(60, lengthPx)) ? zero : v; +} + +function paramSlider(label, kind, idx, path, specName, onChange) { + const spec = SPEC[specName]; + const cur = () => getPath(chans(dev(), kind)[idx], path); + const val = h("button", { class: "val", title: t("Enter value") }, spec.fmt(cur())); + const input = h("input", { type: "range", min: spec.min, max: spec.max, step: 1, value: cur(), "aria-label": label }); + const home = spec.zero ?? spec.def; + const wrap = h("div", { class: "param" + (cur() === spec.zero ? " atzero" : "") }); + let dragging = false; + const commit = v => { + v = clamp(Math.round(v), spec.min, spec.max); + input.value = v; + if (v === cur()) return; + if (v === spec.zero) buzz(); + val.textContent = spec.fmt(v); + wrap.classList.toggle("atzero", v === spec.zero); + setParam(kind, idx, path, v); + onChange && onChange(v); + }; + onLive(kind, idx, path, v => { input.value = v; val.textContent = spec.fmt(v); wrap.classList.toggle("atzero", v === spec.zero); }); + input.addEventListener("input", () => { + let v = +input.value; + if (dragging) v = detent(v, spec.zero, spec.max - spec.min, input.clientWidth - 26); + commit(v); + }); + let lastTap = 0; + input.addEventListener("pointerdown", () => { + dragging = true; beginBusy(); + const now = Date.now(); + if (home != null && now - lastTap < 320) setTimeout(() => commit(home), 0); + lastTap = now; + }); + const release = () => { if (dragging) { dragging = false; endBusy(); } }; + input.addEventListener("pointerup", release); + input.addEventListener("pointercancel", release); + input.addEventListener("blur", release); + val.addEventListener("click", async () => { + const v = await askValue(label, spec, cur()); + if (v != null) commit(v); + }); + const track = h("div", { class: "rangewrap" }, + spec.zero != null ? h("div", { class: "zmark", style: `--f:${(spec.zero - spec.min) / (spec.max - spec.min)}` }) : null, input); + wrap.append( + h("div", { class: "lbl" }, h("span", {}, label), + h("div", { class: "valbox" }, stepper(-1, d => commit(cur() + d)), val, stepper(1, d => commit(cur() + d)))), + track); + return wrap; +} + +function paramSelect(kind, idx, path, options, onChange, label) { + const ch = chans(dev(), kind)[idx]; + const sel = h("select", { "aria-label": label || path, onchange: () => { setParam(kind, idx, path, +sel.value); onChange && onChange(+sel.value); } }, + options.map((o, i) => h("option", { value: i, selected: getPath(ch, path) === i }, o))); + return sel; +} + +function toggleBtn(label, kind, idx, path, cls = "", onChange) { + const ch = chans(dev(), kind)[idx]; + const b = h("button", { class: (getPath(ch, path) ? "on " : "") + cls, "aria-pressed": String(!!getPath(ch, path)) }, label); + b.addEventListener("click", () => { + const v = !getPath(chans(dev(), kind)[idx], path); + b.classList.toggle("on", v); b.setAttribute("aria-pressed", String(v)); + setParam(kind, idx, path, v); + onChange && onChange(v); + }); + onLive(kind, idx, path, v => { b.classList.toggle("on", !!v); b.setAttribute("aria-pressed", String(!!v)); onChange && onChange(v); }); + return b; +} + +// Vertical fader: drag the cap (relative), 0-dB detent, double tap on the cap = 0 dB, wheel, keyboard. +// Touching the fader anywhere else does nothing, so a swipe there scrolls (e.g. the mixer sideways). +function fader({ min, max, value, zero, ticks, label, onInput }) { + const cap = h("div", { class: "cap" }); + const tickEls = (ticks || []).map(([v, label]) => h("div", { class: "tick" + (v === zero ? " z" : ""), style: `--f:${(v - min) / (max - min)}` }, label ? h("span", {}, label) : null)); + const el = h("div", { class: "fader", tabindex: "0", role: "slider", "aria-label": label || "Fader", + "aria-valuemin": min, "aria-valuemax": max }, h("div", { class: "track" }), tickEls, cap); + let cur = value; + const place = () => { + cap.style.setProperty("--f", (cur - min) / (max - min)); + el.setAttribute("aria-valuenow", cur); + el.classList.toggle("atzero", cur === zero); + }; + const set = (v, snap) => { + v = clamp(Math.round(v), min, max); + if (v === cur) return; + if (v === zero && snap !== false) buzz(); + cur = v; place(); onInput(v); + }; + el.setValue = v => { cur = v; place(); }; + place(); + let startY = 0, startV = 0, lastTap = 0, active = null; + el.addEventListener("pointerdown", e => { + if (active !== null || !e.target.closest(".cap")) return; + active = e.pointerId; + el.setPointerCapture(e.pointerId); + beginBusy(); + startY = e.clientY; startV = cur; + const now = Date.now(); + if (zero != null && now - lastTap < 300) { set(zero); startV = zero; } + lastTap = now; + el.classList.add("grab"); + e.preventDefault(); + }); + el.addEventListener("pointermove", e => { + if (e.pointerId !== active) return; + const H = el.clientHeight - 24; + const fine = e.shiftKey ? 0.25 : 1; + const raw = startV + (startY - e.clientY) / H * (max - min) * fine; + set(detent(raw, zero, max - min, H / fine)); + }); + const end = e => { if (e.pointerId !== active) return; active = null; el.classList.remove("grab"); endBusy(); }; + el.addEventListener("pointerup", end); + el.addEventListener("pointercancel", end); + el.addEventListener("wheel", e => { e.preventDefault(); set(cur - Math.sign(e.deltaY) * (e.shiftKey ? 1 : 4), false); }, { passive: false }); + el.addEventListener("keydown", e => { + const step = { ArrowUp: 1, ArrowRight: 1, ArrowDown: -1, ArrowLeft: -1, PageUp: 20, PageDown: -20 }[e.key]; + if (step) { e.preventDefault(); set(cur + step, false); } + else if (e.key === "Home") { e.preventDefault(); set(max, false); } + else if (e.key === "End") { e.preventDefault(); set(min, false); } + else if (e.key === "0" && zero != null) { e.preventDefault(); set(zero); } + }); + return el; +} + +// ------------------------------------------------------------------ LED meters (Pioneer-style segment bars) + +// Segment thresholds in dB (bottom to top) and their colour +const SEGS = [-48, -40, -34, -28, -24, -20, -16, -12, -9, -6, -4, -2, 0, 2, 4, 6] + .map(db => ({ db, c: db >= 4 ? "r" : db >= 0 ? "o" : "g" })); +(function meterCss() { + let css = ""; + for (let n = 1; n <= SEGS.length; n++) css += `.led[data-n="${n}"]>i:nth-child(-n+${n}),.led[data-p="${n}"]>i:nth-child(${n}){opacity:1;box-shadow:0 0 6px var(--c)}`; + document.head.append(h("style", {}, css)); +})(); + +const meterTarget = new Map(); // key -> dB from the device +const meterState = new Map(); // key -> {lvl, pk, pkT} +let meterEls = []; + +function ledMeter(devId, kind, idx, orient = "v") { + return h("div", { class: "led " + orient, "data-key": `${devId}|${kind}|${idx}`, "aria-hidden": "true" }, + SEGS.map(s => h("i", { class: s.c }))); +} +function collectMeters() { meterEls = [...document.querySelectorAll(".led[data-key]")]; limEls = [...document.querySelectorAll("[data-lim]")]; } + +// Limiter LEDs (outputs): the DSP reports "limiter active" per output with every meter reading +const limitOn = new Map(); // "dev|idx" -> time it was last reported active +let limEls = []; +const LIM_HOLD = 300; // ms an LED stays lit, so short hits are visible +const limLed = (devId, i, cls = "") => h("span", { class: "limled " + cls, "data-lim": `${devId}|${i}`, title: t("Limiter active"), "aria-hidden": "true" }, + cls ? "LIM" : null); + +function updateMeters(ev) { + for (const kind of ["in", "out"]) + (ev[kind] || []).forEach((v, i) => meterTarget.set(`${ev.device}|${kind}|${i}`, v > 0 ? 20 * Math.log10(v) : -120)); + (ev.limit || []).forEach((on, i) => { if (on) limitOn.set(`${ev.device}|${i}`, performance.now()); }); +} + +let lastFrame = performance.now(); +function meterFrame(now) { + const dt = Math.min(0.1, (now - lastFrame) / 1000); lastFrame = now; + for (const el of limEls) { + const on = now - (limitOn.get(el.dataset.lim) ?? -1e9) < LIM_HOLD; + if (el.classList.contains("on") !== on) el.classList.toggle("on", on); + } + for (const el of meterEls) { + const key = el.dataset.key; + let st = meterState.get(key); + if (!st) meterState.set(key, st = { lvl: -120, pk: 0, pkT: 0 }); + const target = meterTarget.get(key) ?? -120; + st.lvl = target > st.lvl ? target : Math.max(target, st.lvl - 26 * dt); // instant attack, ~26 dB/s fall + let n = 0; + while (n < SEGS.length && st.lvl >= SEGS[n].db) n++; + if (n >= st.pk) { st.pk = n; st.pkT = now; } + else if (now - st.pkT > 1200) { st.pk = Math.max(n, st.pk - 1); st.pkT = now - 1120; } + const ns = n ? String(n) : "", ps = st.pk ? String(st.pk) : ""; + if (el.dataset.n !== ns) el.dataset.n = ns; + if (el.dataset.p !== ps) el.dataset.p = ps; + } + requestAnimationFrame(meterFrame); +} +requestAnimationFrame(meterFrame); + +// ------------------------------------------------------------------ header / status + +function renderTabs() { + const tabs = $("#devtabs"); + tabs.replaceChildren(...S.order.map(id => { + const d = S.devices[id]; + const model = d.detected_model || (d.model !== "auto" ? d.model : ""); + return h("button", { class: "devtab" + (id === S.cur && !S.settings ? " active" : ""), title: `${d.name} · ${where(d)}`, + 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), 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)); +} + +const STATUS_TEXT = { disconnected: t("Disconnected"), connecting: t("Connecting…"), loading: t("Loading configuration…"), + online: "Online", error: t("Error") }; + +async function storePresetDialog(d) { + const slot = h("select", {}, d.presets.map((p, i) => h("option", { value: i }, `U${String(i + 1).padStart(2, "0")} ${p || t("— empty —")}`))); + const name = h("input", { type: "text", maxlength: 14, value: d.state.preset_name || "", placeholder: t("Name (max. 14 characters)") }); + const cur = d.presets.indexOf(d.state.preset_name); + if (cur >= 0) slot.value = cur; + const res = await modal({ + title: t("Store preset"), + body: h("div", { class: "form" }, h("label", {}, t("Memory slot"), slot), h("label", {}, "Name", name), + h("p", { class: "info" }, t("Overwrites the selected memory slot in the DSP."))), + actions: [{ label: t("Cancel") }, { label: t("Save"), primary: true, + value: () => ({ index: +slot.value, name: name.value.trim().slice(0, 14) || `Preset ${+slot.value + 1}` }) }], + }); + if (!res) return; + try { await api("POST", `/api/devices/${d.id}/preset/store`, res); toast(t("Stored in U{n}", { n: res.index + 1 })); } + catch (e) { toast(t("Error: ") + e.message); } +} + +async function presetFileDialog(d) { + const backups = await api("POST", `/api/devices/${d.id}/backups`).catch(() => []); + const last = backups[0] && new Date(backups[0].time * 1000).toLocaleString(LOCALE, { dateStyle: "short", timeStyle: "short" }); + const choice = await modal({ + title: t("Preset file"), + body: h("div", {}, + h("p", { class: "dlg-text" }, t("Export saves the DSP’s current state ({name}) to a file. Import loads a file into the " + + "active state – stored presets (U01 …) stay unchanged.", { name: q(d.state.preset_name || "—") })), + last ? h("p", { class: "dlg-text" }, t("A backup is made automatically before every import. Last backup: {last}.", { last })) : null), + actions: [{ label: t("Close") }, + ...(last && !S.locked ? [{ label: t("Undo import"), value: () => "undo" }] : []), + ...(S.locked ? [] : [{ label: t("Import…"), value: () => "import" }]), + { label: t("Export"), primary: true, value: () => "export" }], + }); + try { + if (choice === "export") await exportPreset(d); + else if (choice === "import") await importPreset(d); + else if (choice === "undo") { + if (!await askConfirm(t("Undo import"), t("Restore the state from {last}?", { last }), t("Restore"))) return; + toast(t("Restoring…")); + reportImport(await api("POST", `/api/devices/${d.id}/undo`), t("Previous state restored")); + } + } catch (e) { toast(t("Error: ") + e.message); } +} + +async function exportPreset(d) { + toast(t("Reading the state from the DSP…")); + const doc = await api("POST", `/api/devices/${d.id}/export`); + if (await saveFile(`${fileSafe(doc.preset_name)}_DSP${doc.model}_${today()}.json`, doc)) toast(t("Preset exported")); +} + +async function importPreset(d) { + const f = await openFile(); + if (!f) return; + const doc = f.json; + const what = doc && doc.preset_name != null + ? `${q(doc.preset_name || "—")} (DSP ${doc.model}${doc.exported ? ", " + t("exported") + " " + doc.exported.replace("T", " ").slice(0, 16) : ""})` + : q(f.name); + if (!await askConfirm(t("Import preset"), t("Load {what} into the active state? The current state is backed up automatically first and " + + "can be brought back via File → “Undo import”. Stored presets stay unchanged – to keep it, store it into a memory slot with “Save” afterwards.", + { what }), t("Import"))) return; + toast(t("Importing… (a few seconds)")); + reportImport(await api("POST", `/api/devices/${d.id}/import`, doc ? { doc } : { raw: f.b64 }), + doc && doc.preset_name ? t("Preset {name} imported", { name: q(doc.preset_name) }) : t("Preset imported")); +} + +function reportImport(res, okMsg) { + if (res.ok) return toast(okMsg); + modal({ title: t("Import incomplete"), body: h("div", {}, + h("p", { class: "dlg-text" }, t("The DSP did not take these values:")), + h("p", { class: "dlg-text" }, h("code", {}, res.differences.join(", ")))), + actions: [{ label: "OK", primary: true, value: () => true }] }); +} + +function renderStatus() { + const bar = $("#statusbar"); + const d = dev(); + if (S.settings || !d) { bar.replaceChildren(); return; } + if (d.status !== "online" || !d.state) { + bar.replaceChildren( + h("div", { class: "preset" }, h("small", {}, `${STATUS_TEXT[d.status] || d.status} · ${d.transport === "usb" ? "USB" : d.host + ":" + d.port}`), h("b", {}, d.name), + d.error ? h("div", { class: "err" }, trMsg(d.error)) : null), + d.status === "disconnected" || d.status === "error" + ? h("button", { class: "on", onclick: () => api("POST", `/api/devices/${d.id}/connect`).catch(e => toast(e.message)) }, t("Connect")) + : h("button", { onclick: () => api("POST", `/api/devices/${d.id}/disconnect`) }, t("Cancel"))); + return; + } + 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 || "—"}`))); + presetSel.addEventListener("change", async () => { + if (presetSel.value === "") return; + const i = +presetSel.value; + presetSel.value = ""; + if (!await askConfirm(t("Recall preset"), t("Recall {name} (U{n})? Unsaved changes will be lost.", { name: q(d.presets[i]), n: i + 1 }), t("Recall"))) return; + presetSel.disabled = true; + try { await api("POST", `/api/devices/${d.id}/preset/recall`, { index: i }); toast(t("Preset U{n} recalled", { n: i + 1 })); } + catch (e) { toast(t("Error: ") + e.message); } + presetSel.disabled = false; + }); + bar.replaceChildren( + h("div", { class: "preset" }, h("small", {}, `${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…")))); +} + +// ------------------------------------------------------------------ mixer + +function openChannel(kind, idx) { + S.sel = { kind, idx }; S.view = "channel"; store.set("dsp.view", "channel"); render(); window.scrollTo(0, 0); +} + +function strip(d, kind, i) { + const ch = chans(d, kind)[i]; + const db = h("button", { class: "db" + (ch.gain === 280 ? " z" : ""), title: t("Enter value") }, sign(gainDb(ch.gain))); + const showDb = v => { db.textContent = sign(gainDb(v)); db.classList.toggle("z", v === 280); }; + const el = h("div", { class: `strip ${kind}` + (ch.mute ? " muted" : ""), style: kind === "in" ? `--cc:${IN_COLORS[i]}` : "" }); + const f = fader({ min: 0, max: 400, value: ch.gain, zero: 280, ticks: GAIN_TICKS, label: `${chLabel(kind, i)} Gain`, + onInput: v => { showDb(v); setParam(kind, i, "gain", v); } }); + onLive(kind, i, "gain", v => { f.setValue(v); showDb(v); }); + db.addEventListener("click", async () => { + const v = await askValue(`${chTitle(d, kind, i)} – Gain`, SPEC.gain, chans(dev(), kind)[i].gain); + if (v != null) { f.setValue(v); showDb(v); setParam(kind, i, "gain", v); } + }); + el.append( + h("button", { class: "strip-head", onclick: () => openChannel(kind, i), title: t("Edit channel") }, + h("span", { class: "kind" }, chLabel(kind, i), linkBadge(d, kind, i)), h("span", { class: "nm" }, ch.name || " "), + kind === "out" ? limLed(d.id, i) : h("span", { class: "limled ph", "aria-hidden": "true" })), // keeps faders level with the outputs + h("div", { class: "faderbox" }, ledMeter(d.id, kind, i), f), + db, + toggleBtn("MUTE", kind, i, "mute", "mute", v => el.classList.toggle("muted", v))); + return el; +} + +function viewMixer(d) { + const group = (kind, title) => h("section", { class: "mgroup", style: `flex-grow:${chans(d, kind).length}` }, + h("h4", {}, title), h("div", { class: "strips" }, chans(d, kind).map((_, i) => strip(d, kind, i)))); + return [h("div", { class: "mixer" }, group("in", t("Inputs")), group("out", t("Outputs"))), + h("p", { class: "info hint" }, t("Drag a fader by its knob · snaps at 0 dB · double-tap the knob = 0 dB · tap the dB value to type one · tap the name = edit channel"))]; +} + +// ------------------------------------------------------------------ filter response (for the PEQ curve) + +const FS = 96000; +function biquadMag(type, f0, dbGain, q, f) { + const A = Math.pow(10, dbGain / 40), w0 = 2 * Math.PI * f0 / FS, cs = Math.cos(w0), sn = Math.sin(w0); + const alpha = sn / (2 * q); + let b0, b1, b2, a0, a1, a2; + switch (type) { + case 0: b0 = 1 + alpha * A; b1 = -2 * cs; b2 = 1 - alpha * A; a0 = 1 + alpha / A; a1 = -2 * cs; a2 = 1 - alpha / A; break; + case 1: case 2: { + const s = type === 1 ? 1 : -1, sq = 2 * Math.sqrt(A) * alpha; + b0 = A * ((A + 1) - s * (A - 1) * cs + sq); b1 = s * 2 * A * ((A - 1) - s * (A + 1) * cs); b2 = A * ((A + 1) - s * (A - 1) * cs - sq); + a0 = (A + 1) + s * (A - 1) * cs + sq; a1 = -s * 2 * ((A - 1) + s * (A + 1) * cs); a2 = (A + 1) + s * (A - 1) * cs - sq; break; + } + case 3: { const k = Math.tan(w0 / 2); b0 = 1; b1 = -1; b2 = 0; a0 = 1 + k; a1 = k - 1; a2 = 0; break; } + case 4: b0 = (1 + cs) / 2; b1 = -(1 + cs); b2 = (1 + cs) / 2; a0 = 1 + alpha; a1 = -2 * cs; a2 = 1 - alpha; break; + case 5: { const k = Math.tan(w0 / 2); b0 = k; b1 = k; b2 = 0; a0 = 1 + k; a1 = k - 1; a2 = 0; break; } + case 6: b0 = (1 - cs) / 2; b1 = 1 - cs; b2 = (1 - cs) / 2; a0 = 1 + alpha; a1 = -2 * cs; a2 = 1 - alpha; break; + default: return 0; + } + const w = 2 * Math.PI * f / FS, c1 = Math.cos(w), s1 = Math.sin(w), c2 = Math.cos(2 * w), s2 = Math.sin(2 * w); + const nr = b0 + b1 * c1 + b2 * c2, ni = -(b1 * s1 + b2 * s2), dr = a0 + a1 * c1 + a2 * c2, di = -(a1 * s1 + a2 * s2); + return 10 * Math.log10((nr * nr + ni * ni) / (dr * dr + di * di)); +} +function xoverMag(filter, f, high) { + if (!filter.slope) return 0; + const name = SLOPES[filter.slope], order = parseInt(name.split("-")[1], 10) / 6, fc = freqHz(filter.freq); + const r = high ? fc / f : f / fc; + if (name.startsWith("LK")) return -20 * Math.log10(1 + Math.pow(r, order)); + return -10 * Math.log10(1 + Math.pow(r, 2 * order)); +} +const hasGain = type => type <= 2; +const hasQ = type => [0, 4, 6, 7, 8].includes(type); + +function drawCurve(canvas, ch, selBand) { + const dpr = window.devicePixelRatio || 1, W = canvas.clientWidth, H = canvas.clientHeight; + if (!W || !H) return null; + canvas.width = W * dpr; canvas.height = H * dpr; + const g = canvas.getContext("2d"); + g.scale(dpr, dpr); + const fx = f => Math.log(f / 20) / Math.log(1000) * W; + const dy = db => H / 2 - db / 15 * (H / 2 - 10); + g.font = "10px system-ui"; g.fillStyle = "#5b6673"; g.lineWidth = 1; + for (const f of [30, 50, 100, 200, 500, 1000, 2000, 5000, 10000]) { + g.strokeStyle = [100, 1000, 10000].includes(f) ? "#252d37" : "#1a2028"; + g.beginPath(); g.moveTo(fx(f), 0); g.lineTo(fx(f), H); g.stroke(); + g.fillText(f >= 1000 ? f / 1000 + "k" : f, fx(f) + 3, H - 4); + } + for (const db of [-12, -6, 0, 6, 12]) { + g.strokeStyle = db === 0 ? "#3a4552" : "#1a2028"; + g.beginPath(); g.moveTo(0, dy(db)); g.lineTo(W, dy(db)); g.stroke(); + g.fillText((db > 0 ? "+" : "") + db, 3, dy(db) - 3); + } + const resp = f => { + let s = xoverMag(ch.hp, f, true) + xoverMag(ch.lp, f, false); + for (const b of ch.peq) if (!b.bypass) s += biquadMag(b.type, freqHz(b.freq), eqDb(b.gain), Q_TABLE[b.q], f); + return s; + }; + // selected band's own contribution, filled + const sb = ch.peq[selBand]; + if (sb && !sb.bypass) { + g.beginPath(); g.moveTo(0, dy(0)); + for (let x = 0; x <= W; x += 3) g.lineTo(x, clamp(dy(biquadMag(sb.type, freqHz(sb.freq), eqDb(sb.gain), Q_TABLE[sb.q], 20 * Math.pow(1000, x / W))), 0, H)); + g.lineTo(W, dy(0)); g.closePath(); g.fillStyle = "#f59e0b22"; g.fill(); + } + const pts = []; + for (let x = 0; x <= W; x += 2) pts.push([x, clamp(dy(resp(20 * Math.pow(1000, x / W))), 0, H)]); + g.beginPath(); g.moveTo(0, H); pts.forEach(([x, y]) => g.lineTo(x, y)); g.lineTo(W, H); g.closePath(); + const grad = g.createLinearGradient(0, 0, 0, H); grad.addColorStop(0, "#38bdf833"); grad.addColorStop(1, "#38bdf800"); + g.fillStyle = grad; g.fill(); + g.strokeStyle = "#38bdf8"; g.lineWidth = 2; g.beginPath(); + pts.forEach(([x, y], i) => i ? g.lineTo(x, y) : g.moveTo(x, y)); + g.stroke(); + ch.peq.forEach((b, i) => { + const x = fx(freqHz(b.freq)), y = dy(hasGain(b.type) ? eqDb(b.gain) : 0); + g.beginPath(); g.arc(x, y, i === selBand ? 10 : 7, 0, 2 * Math.PI); + g.fillStyle = b.bypass ? "#2a333d" : i === selBand ? "#f59e0b" : "#38bdf8cc"; g.fill(); + g.fillStyle = b.bypass ? "#6b7682" : "#0b0c0f"; g.font = "bold 10px system-ui"; g.textAlign = "center"; g.textBaseline = "middle"; + g.fillText(i + 1, x, y + 0.5); g.textAlign = "start"; g.textBaseline = "alphabetic"; + }); + return { fx, dy, W, H }; +} + +function peqCard(d, kind, idx) { + const ch = chans(d, kind)[idx]; + S.band = Math.min(S.band, ch.peq.length - 1); + const canvas = h("canvas", { class: "curve", "aria-label": t("EQ curve – drag the points") }); + const redraw = () => drawCurve(canvas, chans(dev(), kind)[idx], S.band); + const body = h("div", { class: "bandparams" }); + const bandBtns = h("div", { class: "bands", role: "tablist" }); + const renderBand = () => { + const c = chans(dev(), kind)[idx], b = c.peq[S.band], p = `peq.${S.band}`; + bandBtns.replaceChildren(...c.peq.map((bb, i) => h("button", { + class: "band" + (i === S.band ? " on" : "") + (bb.bypass ? " bypassed" : "") + (hasGain(bb.type) && bb.gain !== 120 ? " active" : ""), + role: "tab", "aria-selected": String(i === S.band), + onclick: () => { S.band = i; renderBand(); redraw(); } }, + h("b", {}, String(i + 1)), h("small", {}, fmtHzShort(freqHz(bb.freq))), + h("small", {}, hasGain(bb.type) ? sign(eqDb(bb.gain)) : PEQ_SHORT[bb.type])))); + const both = () => { renderBand(); redraw(); }; + body.replaceChildren( + h("div", { class: "row bandhead" }, + h("label", { class: "inline" }, t("Type"), paramSelect(kind, idx, p + ".type", PEQ_TYPES, both, t("Filter type"))), + toggleBtn("Bypass", kind, idx, p + ".bypass", "", both), + hasGain(b.type) ? h("button", { onclick: () => { setParam(kind, idx, p + ".gain", 120); both(); } }, "0 dB") : null), + h("div", { class: "pgrid" }, + paramSlider(t("Frequency"), kind, idx, p + ".freq", "freq", both), + hasGain(b.type) ? paramSlider("Gain", kind, idx, p + ".gain", "eqgain", both) : null, + hasQ(b.type) ? paramSlider("Q", kind, idx, p + ".q", "q", both) : null)); + }; + // drag points on the curve (gain snaps to 0 dB) + let drag = null; + canvas.addEventListener("pointerdown", e => { + const c = chans(dev(), kind)[idx], r = canvas.getBoundingClientRect(), geo = drawCurve(canvas, c, S.band); + if (!geo) return; + let best = -1, bd = 1600; + c.peq.forEach((b, i) => { + const dx = geo.fx(freqHz(b.freq)) - (e.clientX - r.left); + const dyy = geo.dy(hasGain(b.type) ? eqDb(b.gain) : 0) - (e.clientY - r.top); + if (dx * dx + dyy * dyy < bd) { bd = dx * dx + dyy * dyy; best = i; } + }); + if (best < 0) return; + e.preventDefault(); + S.band = best; beginBusy(); drag = { geo, r, id: e.pointerId }; + canvas.setPointerCapture(e.pointerId); renderBand(); redraw(); + }); + canvas.addEventListener("pointermove", e => { + if (!drag || e.pointerId !== drag.id) return; + const { geo, r } = drag, c = chans(dev(), kind)[idx], b = c.peq[S.band]; + const x = clamp(e.clientX - r.left, 0, geo.W); + const f = hzFreq(20 * Math.pow(1000, x / geo.W)); + if (f !== b.freq) setParam(kind, idx, `peq.${S.band}.freq`, f); + if (hasGain(b.type)) { + const db = (geo.H / 2 - (e.clientY - r.top)) / (geo.H / 2 - 10) * 15; + let g = clamp(Math.round(db * 10 + 120), 0, 240); + g = detent(g, 120, 300, geo.H - 20, 8); + if (g !== b.gain) { if (g === 120) buzz(); setParam(kind, idx, `peq.${S.band}.gain`, g); } + } + redraw(); + }); + const end = () => { if (drag) { drag = null; renderBand(); endBusy(); } }; + canvas.addEventListener("pointerup", end); + canvas.addEventListener("pointercancel", end); + renderBand(); + requestAnimationFrame(redraw); + new ResizeObserver(redraw).observe(canvas); + return h("div", { class: "card wide" }, + h("h3", {}, h("span", { class: "grow" }, t("Parametric EQ")), + h("button", { class: "small", onclick: async () => { + if (!await askConfirm(t("Reset EQ"), t("Set all PEQ bands of this channel to 0 dB and clear bypass?"), t("All flat"))) return; + chans(dev(), kind)[idx].peq.forEach((bb, i) => { + if (bb.gain !== 120) setParam(kind, idx, `peq.${i}.gain`, 120); + if (bb.bypass) setParam(kind, idx, `peq.${i}.bypass`, false); + }); + renderBand(); redraw(); toast(t("All bands flat")); + } }, t("All flat"))), + canvas, h("p", { class: "info" }, t("Drag the points in the curve · gain snaps at 0 dB")), bandBtns, body); +} + +function geqCard(d, idx) { + const ch = chans(d, "in")[idx]; + const faders = []; + const bands = ch.geq.map((v, b) => { + const lbl = h("span", { class: "gv" }, eqDb(v).toFixed(1)); + const f = fader({ min: 0, max: 240, value: v, zero: 120, ticks: [[240, ""], [120, ""], [0, ""]], label: `GEQ ${GEQ_FREQS[b]} Hz`, + onInput: x => { lbl.textContent = eqDb(x).toFixed(1); lbl.classList.toggle("nz", x !== 120); setParam("in", idx, `geq.${b}`, x); } }); + lbl.classList.toggle("nz", v !== 120); + faders.push([f, lbl]); + return h("div", { class: "gb" }, lbl, f, h("span", { class: "gf" }, GEQ_FREQS[b])); + }); + return h("div", { class: "card wide" }, + h("h3", {}, h("span", { class: "grow" }, t("Graphic EQ · 31 bands")), + h("button", { class: "small", onclick: async () => { + if (!await askConfirm(t("Reset GEQ"), t("Set all 31 bands to 0 dB?"), t("Reset"))) return; + chans(dev(), "in")[idx].geq.forEach((g, b) => { if (g !== 120) setParam("in", idx, `geq.${b}`, 120); }); + faders.forEach(([f, l]) => { f.setValue(120); l.textContent = "0.0"; l.classList.remove("nz"); }); + } }, t("All flat"))), + h("div", { class: "geq" }, bands), + h("p", { class: "info" }, t("Snaps at 0 dB · double-tap the knob = 0 dB"))); +} + +// ------------------------------------------------------------------ channel view + +function channelBar(d) { + const { kind, idx } = S.sel; + const all = [...chans(d, "in").map((_, i) => ["in", i]), ...chans(d, "out").map((_, i) => ["out", i])]; + const pos = all.findIndex(([k, i]) => k === kind && i === idx); + const go = p => { const [k, i] = all[(p + all.length) % all.length]; S.sel = { kind: k, idx: i }; render(); }; + const sel = h("select", { class: "chsel", "aria-label": t("Choose channel"), onchange: () => go(+sel.value) }, + h("optgroup", { label: t("Inputs") }, chans(d, "in").map((_, i) => h("option", { value: i, selected: pos === i }, chTitle(d, "in", i)))), + h("optgroup", { label: t("Outputs") }, chans(d, "out").map((_, i) => { + const p = chans(d, "in").length + i; + return h("option", { value: p, selected: pos === p }, chTitle(d, "out", i)); + }))); + return h("div", { class: "chbar" }, + h("button", { class: "icon nav", "aria-label": t("Previous channel"), onclick: () => go(pos - 1) }, svgIcon(ICON.prev)), + h("div", { class: "chselwrap", style: kind === "in" ? `--cc:${IN_COLORS[idx]}` : "" }, sel), + h("button", { class: "icon nav", "aria-label": t("Next channel"), onclick: () => go(pos + 1) }, svgIcon(ICON.next)), + ledMeter(d.id, kind, idx, "h"), + kind === "out" ? limLed(d.id, idx, "h") : null, + toggleBtn("MUTE", kind, idx, "mute", "mute")); +} + +function viewChannel(d) { + if (S.sel.idx >= chans(d, S.sel.kind).length) S.sel = { kind: "in", idx: 0 }; + const k = S.sel.kind, i = S.sel.idx, ch = chans(d, k)[i]; + const redrawPeq = () => { const c = main.querySelector("canvas.curve"); c && drawCurve(c, chans(dev(), k)[i], S.band); }; + + const li = linkInfo(d, k, i); + const basics = h("div", { class: "card" }, h("h3", {}, t("Channel")), + li ? h("p", { class: "info linknote", style: `--lc:${li.color}` }, svgIcon(ICON.link), + " " + t(k === "out" ? "Linked with {list} – changes apply to all of them (except name, routing and mix levels)." + : "Linked with {list} – changes apply to all of them (except the name).", { list: li.group.filter(j => j !== i).map(j => chLabel(k, j)).join(", ") })) : null, + h("div", { class: "row" }, + h("label", { class: "inline grow2" }, "Name", + h("input", { type: "text", maxlength: NAME_MAX, value: ch.name, placeholder: chLabel(k, i), "aria-label": t("Channel name"), + oninput: e => { // stop typing where the name would no longer fit + const c = cleanName(e.target.value); + if (c !== e.target.value) { + const pos = Math.min(e.target.selectionStart, c.length); + e.target.value = c; e.target.setSelectionRange(pos, pos); + if (Date.now() - (S.nameToast || 0) > 2000) { S.nameToast = Date.now(); toast(t("Name is full (max. 8 characters, wide letters count more)")); } + } + }, + onchange: e => { setParam(k, i, "name", cleanName(e.target.value).trim()); render(); } })), + toggleBtn("Phase Ø", k, i, "polarity")), + paramSlider("Gain", k, i, "gain", "gain"), + paramSlider("Delay", k, i, "delay", "delay")); + + const xo = (title, key) => h("div", { class: "xo" }, + h("div", { class: "row" }, h("span", { class: "sub" }, title), paramSelect(k, i, key + ".slope", SLOPES, () => { redrawPeq(); render(); }, title)), + chans(d, k)[i][key].slope ? paramSlider(t("Frequency"), k, i, key + ".freq", "freq", redrawPeq) : h("p", { class: "info off" }, t("Off (bypass)"))); + const xover = h("div", { class: "card" }, h("h3", {}, t("High- / low-pass")), + xo(t("High-pass"), "hp"), xo(t("Low-pass"), "lp")); + + const cards = [basics, xover]; + if (k === "in") { + cards.push(h("div", { class: "card" }, h("h3", {}, "Noise Gate"), + paramSlider("Threshold", k, i, "gate.threshold", "gthresh"), + paramSlider("Attack", k, i, "gate.attack", "attack"), + paramSlider("Hold", k, i, "gate.hold", "hold"), + paramSlider("Release", k, i, "gate.release", "release"))); + cards.push(peqCard(d, k, i), geqCard(d, i)); + } else { + cards.push(routingCard(d, i), peqCard(d, k, i)); + cards.push(h("div", { class: "card" }, h("h3", {}, t("Compressor")), + paramSlider("Threshold", k, i, "comp.threshold", "thresh"), + paramSlider("Ratio", k, i, "comp.ratio", "ratio"), + paramSlider("Attack", k, i, "comp.attack", "attack"), + paramSlider("Release", k, i, "comp.release", "release"), + paramSlider("Knee", k, i, "comp.knee", "knee"))); + const lc = limCalc(d.id, i, ch.limit.threshold); + cards.push(h("div", { class: "card" }, h("h3", {}, "Limiter"), + h("div", { class: "row" }, h("span", { class: "grow" }, "Threshold ", h("b", {}, SPEC.thresh.fmt(ch.limit.threshold)), + lc ? [" → ", h("b", {}, fmtW(lc.p)), ` @ ${lc.as.ohm} Ω`] : null), + h("button", { class: "small", onclick: () => { S.view = "limiter"; store.set("dsp.view", "limiter"); render(); window.scrollTo(0, 0); } }, t("Limiter tab"))))); + } + return [channelBar(d), h("div", { class: "cards" }, cards)]; +} + +// Per-output source list: on/off + level per input +function mixList(d, o) { + return chans(d, "in").map((inp, i) => { + const on = chans(d, "out")[o].matrix >> i & 1; + const btn = h("button", { class: "src" + (on ? " on" : ""), style: `--cc:${IN_COLORS[i]}`, "aria-pressed": String(!!on), + onclick: () => { + const m = chans(dev(), "out")[o].matrix ^ (1 << i); + setParam("out", o, "matrix", m); render(); + } }, h("span", { class: "sw" }), chTitle(d, "in", i)); + return h("div", { class: "mixrow" + (on ? "" : " off") }, btn, paramSlider(t("Level"), "out", o, `mix.${i}`, "mix")); + }); +} + +function routingCard(d, o) { + return h("div", { class: "card" }, h("h3", {}, t("Sources → ") + chLabel("out", o)), mixList(d, o)); +} + +// ------------------------------------------------------------------ routing view + +function viewRouting(d) { + const ins = chans(d, "in"), outs = chans(d, "out"); + const grid = h("div", { class: "xmatrix", style: `--n:${ins.length}` }); + grid.append(h("div", { class: "xcorner" }, h("span", {}, t("Input →")), h("span", {}, t("Output ↓")))); + ins.forEach((c, i) => grid.append(h("div", { class: "xin", style: `--cc:${IN_COLORS[i]}` }, + h("b", {}, chLabel("in", i)), h("small", {}, c.name || " "), ledMeter(d.id, "in", i, "h")))); + outs.forEach((oc, o) => { + const open = S.routeOpen === o; + const srcs = ins.map((_, i) => oc.matrix >> i & 1 ? chLabel("in", i).slice(3) : null).filter(Boolean); + grid.append(h("button", { class: "xout" + (open ? " open" : ""), "aria-expanded": String(open), + onclick: () => { S.routeOpen = open ? null : o; render(); } }, + h("span", { class: "xo-t" }, h("b", {}, chLabel("out", o)), h("small", {}, oc.name || " ")), + h("span", { class: "xo-s" }, srcs.length ? "← " + srcs.join("+") : "—"), + h("span", { class: "chev" }, open ? "▴" : "▾"))); + ins.forEach((_, i) => { + const on = oc.matrix >> i & 1; + grid.append(h("button", { class: "xp" + (on ? " on" : ""), style: `--cc:${IN_COLORS[i]}`, + "aria-label": `${chLabel("in", i)} → ${chLabel("out", o)}`, "aria-pressed": String(!!on), + onclick: () => { + const m = chans(dev(), "out")[o].matrix ^ (1 << i); + setParam("out", o, "matrix", m); render(); + } }, h("span", { class: "node" }), on ? h("small", {}, gainDb(oc.mix[i]) === 0 ? "0 dB" : sign(gainDb(oc.mix[i]))) : null)); + }); + if (open) grid.append(h("div", { class: "xpanel" }, h("div", { class: "xpanel-h" }, t("Level for {ch}", { ch: chTitle(d, "out", o) }), + h("button", { class: "small", onclick: () => openChannel("out", o) }, t("Open channel"))), mixList(d, o))); + }); + return h("div", { class: "card routing" }, h("h3", {}, t("Routing matrix")), grid, + h("p", { class: "info" }, t("Tap a crosspoint = connect/disconnect · tap an output = level per input"))); +} + +// ------------------------------------------------------------------ channel links + +async function saveLinks(d, kind, groups, msg) { + S.linkBusy = true; render(); + try { await api("POST", `/api/devices/${d.id}/link`, { kind, groups }); toast(msg); } + catch (e) { toast(t("Error: ") + e.message); } + S.linkBusy = false; S.linkSel[kind] = []; render(); +} + +function linkCard(d, kind) { + const list = chans(d, kind), linked = linkedGroups(d, kind); + const sel = S.linkSel[kind] = S.linkSel[kind].filter(i => i < list.length); + const btns = list.map((ch, i) => { + const l = linkInfo(d, kind, i), on = sel.includes(i); + return h("button", { class: "lkch" + (on ? " sel" : ""), style: l ? `--lc:${l.color}` : "", "aria-pressed": String(on), + disabled: S.linkBusy, onclick: () => { S.linkSel[kind] = on ? sel.filter(j => j !== i) : [...sel, i].sort((a, b) => a - b); render(); } }, + h("b", {}, chLabel(kind, i)), h("small", {}, ch.name || "\u00a0"), + h("span", { class: "lkmark" }, l ? svgIcon(ICON.link) : null)); + }); + const link = async () => { + const first = chLabel(kind, sel[0]); + const names = sel.map(i => chLabel(kind, i)).join(", "); + if (!await askConfirm(t("Link channels"), t(kind === "out" ? "Link {names}? They all take over the settings of {first} (names and routing stay)." + : "Link {names}? They all take over the settings of {first} (names stay).", { names, first }), t("Link"))) return; + const rest = linked.map(g => g.filter(i => !sel.includes(i))).filter(g => g.length > 1); + saveLinks(d, kind, [...rest, sel], t("{names} linked", { names })); + }; + const unlink = g => saveLinks(d, kind, linked.filter(x => x !== g), t("{names} unlinked", { names: g.map(i => chLabel(kind, i)).join(" + ") })); + return h("div", { class: "card" }, h("h3", {}, kind === "in" ? t("Inputs") : t("Outputs")), + h("div", { class: "lkgrid" }, btns), + h("div", { class: "row lkactions" }, + h("span", { class: "grow info" }, sel.length < 2 ? t("Tap at least two channels") : t("{n} channels selected", { n: sel.length })), + h("button", { class: "on", disabled: sel.length < 2 || S.linkBusy, onclick: link }, t("Link"))), + linked.length ? h("div", { class: "lkgroups" }, linked.map((g, n) => + h("div", { class: "row lkgroup", style: `--lc:${LINK_COLORS[n % LINK_COLORS.length]}` }, + svgIcon(ICON.link), h("span", { class: "grow" }, g.map(i => chLabel(kind, i)).join(" + ")), + h("button", { class: "small", disabled: S.linkBusy, onclick: () => unlink(g) }, t("Unlink"))))) + : h("p", { class: "info" }, t("No channels linked."))); +} + +function viewLink(d) { + return [h("div", { class: "cards" }, linkCard(d, "in"), linkCard(d, "out")), + h("p", { class: "info hint" }, t("Linked channels share all settings (gain, delay, filters, EQ, dynamics, mute) – ") + + t("a change on one channel applies to the whole group. Name, routing and mix levels stay per channel. ") + + t("The link is stored in the DSP and also applies in the Thomann editor."))]; +} + +// ------------------------------------------------------------------ limiter calculator + +// Limiter threshold -> amplifier output power. Chain: DSP output (threshold, referenced to `ref` dBu) +// × amplifier voltage gain, capped at the amplifier's clip voltage sqrt(P_rated × R). +const DBU_V = 0.7746; +const OHMS = [2, 4, 6, 8, 16]; +const limKey = (devId, o) => `${devId}:${o}`; +const limRef = devId => S.lim.ref[devId] ?? 0; +const fmtW = w => w >= 1000 ? (w / 1000).toFixed(w >= 10000 ? 1 : 2) + " kW" : Math.round(w) + " W"; + +// Rated power at any impedance from the 2/4/8 Ω datasheet values (0 = not rated that low) +function ampRated(a, ohm) { + const pts = [[2, a.p2], [4, a.p4], [8, a.p8]].filter(p => p[1] > 0); + if (!pts.length) return 0; + const hit = pts.find(p => p[0] === ohm); + if (hit) return hit[1]; + const lo = [...pts].reverse().find(p => p[0] < ohm), hi = pts.find(p => p[0] > ohm); + if (lo && hi) return lo[1] + (hi[1] - lo[1]) * (ohm - lo[0]) / (hi[0] - lo[0]); + if (lo) return lo[1] * lo[0] / ohm; // above the highest rating: same clip voltage + return 0; +} +// Linear voltage gain: from the gain in dB, or rated output voltage / input sensitivity +function ampGain(a) { + if (a.mode === "gain") return Math.pow(10, a.gain / 20); + const [r, p] = a.p8 ? [8, a.p8] : a.p4 ? [4, a.p4] : [2, a.p2]; + return p && a.sens ? Math.sqrt(p * r) / a.sens : 0; +} + +function limCalc(devId, o, thrRaw) { + const as = S.lim.assign[limKey(devId, o)]; + const amp = as && S.lim.amps.find(a => a.id === as.amp); + if (!amp) return null; + const vin = DBU_V * Math.pow(10, ((thrRaw - 180) / 2 + limRef(devId)) / 20); + const g = ampGain(amp), rated = ampRated(amp, as.ohm); + const vout = vin * g, vmax = Math.sqrt(rated * as.ohm); + const p = rated ? Math.min(vout, vmax) ** 2 / as.ohm : vout ** 2 / as.ohm; + return { amp, as, p, rated, g, over: rated ? 20 * Math.log10(vout / vmax) : 0 }; +} +// Threshold (raw) that limits to `watts` at the assigned speaker +function limThreshFor(devId, o, watts) { + const c = limCalc(devId, o, 180); + if (!c || !c.g || watts <= 0) return null; + const db = 20 * Math.log10(Math.sqrt(watts * c.as.ohm) / c.g / DBU_V) - limRef(devId); + return clamp(Math.floor(db * 2 + 1e-9) + 180, 0, 220); // round down: never above the target +} + +async function saveLim(next) { + S.lim = next; + try { S.lim = await api("PUT", "/api/limiter", next); } catch (e) { toast(t("Error: ") + e.message); } +} +const limCopy = () => JSON.parse(JSON.stringify(S.lim)); + +async function ampDialog(amp) { + const isNew = !amp; + amp = amp || { name: "", mode: "sens", sens: 1.4, gain: 32, p8: 0, p4: 0, p2: 0 }; + const numIn = (v, ph) => h("input", { type: "text", inputmode: "decimal", value: v || "", placeholder: ph, autocomplete: "off" }); + const f = { name: h("input", { type: "text", value: amp.name, placeholder: t("e.g. Crown XLS 1502"), maxlength: 40 }), + p8: numIn(amp.p8, "W"), p4: numIn(amp.p4, "W"), p2: numIn(amp.p2, "W"), + sens: numIn(amp.sens, t("e.g. 1.4")), gain: numIn(amp.gain, t("e.g. 32")) }; + let mode = amp.mode; + const modeBtns = h("div", { class: "seg" }); + const sensRow = h("label", {}, t("Input sensitivity (V RMS)"), f.sens); + const gainRow = h("label", {}, t("Gain (dB)"), f.gain); + const setMode = m => { + mode = m; + modeBtns.replaceChildren(...[["sens", t("Sensitivity")], ["gain", t("Gain")]].map(([k, label]) => + h("button", { class: k === mode ? "on" : "", onclick: () => setMode(k) }, label))); + sensRow.hidden = mode !== "sens"; gainRow.hidden = mode !== "gain"; + }; + setMode(mode); + const err = h("div", { class: "err full" }); + const v = await modal({ + title: isNew ? t("New amplifier") : t("Edit amplifier"), + body: h("div", { class: "devform ampform" }, + h("label", { class: "full" }, "Name", f.name), + h("div", { class: "full sub" }, t("Rated RMS power per channel (datasheet, empty = not specified)")), + h("label", {}, t("into 8 Ω"), f.p8), h("label", {}, t("into 4 Ω"), f.p4), h("label", {}, t("into 2 Ω"), f.p2), + h("div", { class: "full sub" }, t("Input")), h("div", { class: "full" }, modeBtns), + h("div", { class: "full" }, sensRow, gainRow), + h("p", { class: "info full" }, t("Sensitivity = input voltage for full power (e.g. 0.775 V or 1.4 V). "), + t("If the amplifier has a gain control, the value applies with it turned fully up.")), + err), + actions: [{ label: t("Cancel") }, { label: t("Save"), primary: true, value: () => { + const n = k => Math.max(0, num(f[k].value) || 0); + const r = { id: amp.id, name: f.name.value.trim() || t("Amplifier"), mode, sens: n("sens"), gain: n("gain"), + p8: n("p8"), p4: n("p4"), p2: n("p2") }; + if (!r.p8 && !r.p4 && !r.p2) { err.textContent = t("At least one power rating is missing."); return undefined; } + if (mode === "sens" && !r.sens) { err.textContent = t("Sensitivity is missing."); return undefined; } + return r; + } }], + }); + if (!v) return null; + const next = limCopy(); + if (isNew) { v.id = Math.random().toString(36).slice(2, 10); next.amps.push(v); } + else next.amps[next.amps.findIndex(a => a.id === v.id)] = v; + await saveLim(next); + render(); + return v.id; +} + +function ampCard(a) { + const used = Object.entries(S.lim.assign).filter(([, v]) => v.amp === a.id).map(([k]) => { + const [devId, o] = k.split(":"); const d = S.devices[devId]; + return (d ? d.name + " " : "") + chLabel("out", +o); + }); + const specs = [[8, a.p8], [4, a.p4], [2, a.p2]].filter(p => p[1]).map(([r, p]) => `${fmtW(p)} @ ${r} Ω`).join(" · "); + return h("div", { class: "card amp" }, + h("h3", {}, h("span", { class: "grow" }, a.name), + h("button", { class: "icon small", "aria-label": t("Edit"), title: t("Edit"), onclick: () => ampDialog(a) }, svgIcon(ICON.edit))), + h("div", { class: "ampspec" }, specs), + h("div", { class: "info" }, a.mode === "gain" ? t("Gain {v} dB", { v: a.gain }) : t("Sensitivity {v} V", { v: a.sens }), + ` (≙ ${(20 * Math.log10(ampGain(a) || 1)).toFixed(1)} dB Gain)`), + h("div", { class: "info" }, used.length ? t("Used by: ") + used.join(", ") : t("Not assigned to any output")), + h("div", { class: "actions" }, h("button", { class: "danger small", onclick: async () => { + if (!await askConfirm(t("Delete amplifier"), t("Delete {name}?", { name: q(a.name) }) + (used.length ? " " + t("Its assignments will be removed.") : ""), t("Delete"), true)) return; + const next = limCopy(); + next.amps = next.amps.filter(x => x.id !== a.id); + for (const k of Object.keys(next.assign)) if (next.assign[k].amp === a.id) delete next.assign[k]; + await saveLim(next); render(); + } }, t("Delete")))); +} + +// Live result box; returns [element, update(thrRaw)] +function limResult(d, o) { + const big = h("div", { class: "lw" }), sub = h("div", { class: "lsub" }); + const bar = h("div", { class: "lbar" }, h("i"), h("b")); + const notes = h("div", { class: "lnotes" }); + const box = h("div", { class: "lres" }, big, sub, bar, notes); + const update = raw => { + const c = limCalc(d.id, o, raw); + if (!c) { box.className = "lres none"; big.textContent = "—"; sub.textContent = t("No amplifier assigned"); notes.replaceChildren(); return; } + const spk = c.as.spk, top = Math.max(c.rated, spk, c.p) || 1; + big.replaceChildren(fmtW(c.p), h("small", {}, ` RMS @ ${c.as.ohm} Ω`)); + sub.textContent = c.rated ? t("{pct} % of {rated}", { pct: Math.round(c.p / c.rated * 100), rated: fmtW(c.rated) }) + " · " + c.amp.name : c.amp.name; + bar.style.cssText = `--p:${Math.min(1, c.p / top)};--a:${c.rated ? c.rated / top : 0};--s:${spk ? spk / top : 0}`; + bar.classList.toggle("hasspk", !!spk); + const n = []; + let lvl = "ok"; + if (!c.rated) { n.push(["bad", t("Amplifier is not rated for {ohm} Ω", { ohm: c.as.ohm })]); lvl = "bad"; } + else if (c.over > 0.05) { n.push(["bad", t("Amplifier clips – the limiter engages {db} dB too late", { db: c.over.toFixed(1) })]); lvl = "bad"; } + else n.push(["ok", t("{db} dB headroom to amplifier clipping", { db: Math.max(0, -c.over).toFixed(1) })]); + if (spk && c.p > spk * 1.01) { n.push(["warn", t("{pct} % of the speaker rating ({w} RMS)", { pct: Math.round(c.p / spk * 100), w: fmtW(spk) })]); if (lvl === "ok") lvl = "warn"; } + else if (spk) n.push(["ok", t("Speaker at {pct} % of its rating ({w} RMS)", { pct: Math.round(c.p / spk * 100), w: fmtW(spk) })]); + box.className = "lres " + lvl; + notes.replaceChildren(...n.map(([cls, text]) => h("div", { class: cls }, text))); + }; + return [box, update]; +} + +function limiterCard(d, o) { + const oc = chans(d, "out")[o], key = limKey(d.id, o); + const as = S.lim.assign[key]; + const [res, update] = limResult(d, o); + const setAssign = async patch => { + const next = limCopy(); + if (patch === null) delete next.assign[key]; + else next.assign[key] = { ohm: 8, spk: 0, ...(next.assign[key] || {}), ...patch }; + await saveLim(next); render(); + }; + const ampSel = h("select", { "aria-label": t("Amplifier"), onchange: async () => { + if (ampSel.value === "+") { const id = await ampDialog(null); if (id) setAssign({ amp: id }); else render(); } + else setAssign(ampSel.value ? { amp: ampSel.value } : null); + } }, h("option", { value: "" }, t("— no amplifier —")), + S.lim.amps.map(a => h("option", { value: a.id, selected: as && as.amp === a.id }, a.name)), + h("option", { value: "+" }, t("+ New amplifier…"))); + const ohmSel = h("select", { "aria-label": t("Impedance"), disabled: !as, onchange: () => setAssign({ ohm: +ohmSel.value }) }, + OHMS.map(r => h("option", { value: r, selected: (as ? as.ohm : 8) === r }, r + " Ω"))); + const spkIn = h("input", { type: "text", inputmode: "decimal", value: as && as.spk ? as.spk : "", placeholder: "optional", + disabled: !as, "aria-label": t("Speaker RMS"), onchange: () => setAssign({ spk: Math.max(0, num(spkIn.value) || 0) }) }); + + const target = h("input", { type: "text", inputmode: "decimal", placeholder: t("Watts"), "aria-label": t("Target power"), autocomplete: "off" }); + const apply = w => { + const raw = limThreshFor(d.id, o, w); + if (raw == null) return toast(t("Assign an amplifier first")); + setParam("out", o, "limit.threshold", raw); + target.value = ""; + target.blur(); + const hitEdge = raw === 0 || raw === 220; + toast(`Threshold ${sign((raw - 180) / 2)} dB → ${fmtW(limCalc(d.id, o, raw).p)}` + (hitEdge ? t(" (end of range reached)") : "")); + render(); + }; + const c0 = as ? limCalc(d.id, o, 180) : null; + const ampSafe = c0 && c0.rated ? c0.rated * Math.pow(10, -1 / 10) : 0; // 1 dB below amp clipping + const chips = c0 ? [ + c0.as.spk ? h("button", { class: "chip", onclick: () => apply(c0.as.spk) }, t("Speaker ") + fmtW(c0.as.spk)) : null, + ampSafe ? h("button", { class: "chip", onclick: () => apply(ampSafe) }, t("Amplifier −1 dB")) : null, + ampSafe && c0.as.spk ? h("button", { class: "chip", onclick: () => apply(Math.min(ampSafe, c0.as.spk)) }, t("Lower value")) : null, + ] : []; + + const card = h("div", { class: "card limcard" }, + h("h3", {}, h("span", { class: "grow" }, chTitle(d, "out", o)), ledMeter(d.id, "out", o, "h"), + h("button", { class: "small", onclick: () => openChannel("out", o) }, t("Channel"))), + res, + h("div", { class: "limgrid" }, + h("label", { class: "full" }, t("Amplifier"), ampSel), + h("label", {}, t("Load on channel"), ohmSel), + h("label", {}, t("Speaker RMS (W)"), spkIn)), + paramSlider("Threshold", "out", o, "limit.threshold", "thresh", update), + as ? h("div", { class: "target" }, + h("div", { class: "row" }, h("span", { class: "sub" }, t("Limit to")), target, + h("button", { class: "on", onclick: () => { const w = num(target.value); if (w > 0) apply(w); else target.focus(); } }, t("Set"))), + chips.filter(Boolean).length ? h("div", { class: "chips" }, chips) : null) : null, + timingBox(d, o)); + update(oc.limit.threshold); + return card; +} + +// Limiter timing presets per band. Rule of thumb: attack ≈ one period of the lowest frequency +// the way passes (faster distorts the waveform), release ≈ 16 × attack (slower pumps less). +// Infra/Sub/Hochton follow the MC2 Delta "auto" table and Dolby SLS LF settings (16 ms / 256 ms). +const LIM_PRESETS = [ + { id: "infra", name: "Infra", range: "< 31 Hz", a: 45, r: 720, k: 3 }, + { id: "sub", name: "Sub", range: "31–63 Hz", a: 16, r: 256, k: 2 }, + { id: "kick", name: "Kick", range: "63–250 Hz", a: 10, r: 160, k: 2 }, + { id: "mid", name: t("Mids"), range: "250 Hz–2 kHz", a: 4, r: 64, k: 1 }, + { id: "high", name: t("Highs"), range: "> 2 kHz", a: 1, r: 16, k: 0 }, + { id: "full", name: "Fullrange", range: t("no crossover"), a: 8, r: 120, k: 2 }, +]; +// Band preset picked by the channel's high-pass, i.e. its lowest frequency (20 Hz when it has none) +const AUTO_BANDS = [[31, "infra"], [63, "sub"], [250, "kick"], [2000, "mid"], [Infinity, "high"]]; +function autoPreset(ch) { + const f = ch.hp.slope ? freqHz(ch.hp.freq) : 20; + const band = AUTO_BANDS.find(([upTo]) => f < upTo)[1]; + const p = LIM_PRESETS.find(x => x.id === band); + return { ...p, id: "auto", name: "Auto", range: `${ch.hp.slope ? "HP" : t("no HP")} ${fmtHzShort(f)} → ${p.name}` }; +} + +const limOpen = new Set(); +function timingBox(d, o) { + const lim = chans(d, "out")[o].limit, key = limKey(d.id, o); + const auto = autoPreset(chans(d, "out")[o]); + const isOn = p => lim.attack === p.a - 1 && lim.release === p.r - 1 && lim.knee === p.k; + const active = [auto, ...LIM_PRESETS].find(isOn); + const set = p => { + setParam("out", o, "limit.attack", p.a - 1); + setParam("out", o, "limit.release", p.r - 1); + setParam("out", o, "limit.knee", p.k); + toast(`${p.name}: Attack ${p.a} ms · Release ${p.r} ms · Knee ${p.k} dB`); + render(); + }; + const chip = p => h("button", { class: "chip preset" + (isOn(p) ? " on" : ""), title: `${p.a} / ${p.r} ms · Knee ${p.k} dB`, onclick: () => set(p) }, + h("b", {}, p.name), h("small", {}, p.range)); + const box = h("details", { class: "more", open: limOpen.has(key), + ontoggle: () => box.open ? limOpen.add(key) : limOpen.delete(key) }, + h("summary", {}, `Attack ${lim.attack + 1} ms · Release ${lim.release + 1} ms · Knee ${lim.knee} dB`, + active ? h("span", { class: "tag" }, active.name) : null), + h("div", { class: "chips presets" }, chip(auto), LIM_PRESETS.map(chip)), + paramSlider("Attack", "out", o, "limit.attack", "attack"), + paramSlider("Release", "out", o, "limit.release", "release"), + paramSlider("Knee", "out", o, "limit.knee", "knee"), + h("p", { class: "info" }, t("Rule of thumb: attack ≈ one period of the lowest frequency (faster distorts the bass), "), + t("release ≈ 16 × attack (shorter pumps). “Auto” picks the band preset matching this channel’s high-pass."))); + return box; +} + +function refCard(d) { + const inp = h("input", { type: "text", inputmode: "decimal", value: limRef(d.id), "aria-label": t("Reference level in dBu"), class: "short", + onchange: async () => { const next = limCopy(); next.ref[d.id] = clamp(num(inp.value) || 0, -20, 30); await saveLim(next); render(); } }); + return h("div", { class: "card" }, h("h3", {}, t("Reference level · ") + d.name), + h("div", { class: "row" }, h("span", { class: "grow" }, t("Limiter 0 dB equals at the output")), inp, h("span", {}, "dBu")), + h("p", { class: "info" }, t("Thomann does not specify the reference level – 0 dBu (0.775 V) is assumed. To measure: feed a 1 kHz sine, "), + t("set the threshold to 0 dB, turn up until the limiter engages and measure the output voltage with a multimeter (AC). "), + t("dBu = 20 · log₁₀(U / 0.775 V)."))); +} + +function viewLimiter(d) { + return [ + h("div", { class: "cards" }, chans(d, "out").map((_, o) => limiterCard(d, o))), + h("p", { class: "info" }, t("Shown is the continuous sine power (RMS) once the limiter engages – music is well below that on average. "), + t("Assumes the amplifier’s gain control turned fully up (or as entered).")), + h("h2", { class: "section" }, t("Amplifiers")), + h("div", { class: "cards" }, S.lim.amps.map(ampCard), + h("button", { class: "card addcard", onclick: () => ampDialog(null) }, t("+ Add amplifier"))), + h("h2", { class: "section" }, t("Calibration")), + h("div", { class: "cards" }, refCard(d)), + ]; +} + +// ------------------------------------------------------------------ settings + +function deviceForm(d) { + const isNew = !d; + d = d || { name: "", host: "", port: 9761, model: "auto", addr: 1, autoconnect: true, transport: "tcp", usb: "" }; + const f = { + name: h("input", { type: "text", value: d.name, placeholder: t("e.g. DSP 204 stage") }), + host: h("input", { type: "text", value: d.host, placeholder: "192.168.1.101", inputmode: "decimal" }), + port: h("input", { type: "number", value: d.port }), + model: h("select", {}, [["auto", t("Automatic")], ["204", "DSP 204"], ["408", "DSP 408"]] + .map(([v, label]) => h("option", { value: v, selected: d.model === v }, label))), + autoconnect: h("input", { type: "checkbox", checked: d.autoconnect }), + usb: h("select", { "aria-label": t("USB device") }), + }; + let transport = d.transport || "tcp"; + // USB device list (both DSP models share one USB ID, so several are told apart by port/path) + const fillUsb = list => { + const opts = [["", list.length ? t("First device found") : t("No DSP found via USB")], + ...list.map((u, i) => [u.path, `${u.product || "DSP"} #${i + 1}${u.serial ? " · " + u.serial : ""}`])]; + if (d.usb && !list.some(u => u.path === d.usb)) opts.push([d.usb, t("Saved device (not plugged in)")]); + f.usb.replaceChildren(...opts.map(([v, label]) => h("option", { value: v, selected: v === (d.usb || "") }, label))); + }; + const loadUsb = () => api("GET", "/api/usb").then(fillUsb).catch(() => fillUsb([])); + fillUsb([]); + const netRows = [h("label", {}, t("IP address"), f.host), h("label", {}, "Port", f.port)]; + const usbRow = h("label", { class: "full" }, t("USB device"), + h("div", { class: "row" }, f.usb, h("button", { class: "small", type: "button", onclick: loadUsb, title: t("Search again") }, "↻"))); + const seg = h("div", { class: "seg full" }); + // existing device: the connection type and USB device are saved right away, so t("Connect") uses them + const saveConn = () => isNew || api("PUT", `/api/devices/${d.id}`, { transport, usb: f.usb.value }).catch(e => toast(e.message)); + f.usb.addEventListener("change", saveConn); + const setTransport = (mode, save) => { + transport = mode; + if (save && mode !== (d.transport || "tcp")) saveConn(); + seg.replaceChildren(...[["tcp", t("Network")], ["usb", t("USB cable")]].map(([k, label]) => + h("button", { type: "button", class: k === mode ? "on" : "", onclick: () => setTransport(k, true) }, label))); + netRows.forEach(r => (r.hidden = mode === "usb")); + usbRow.hidden = mode !== "usb"; + if (mode === "usb") loadUsb(); + }; + setTransport(transport); + const values = () => ({ name: f.name.value.trim() || (transport === "usb" ? "DSP (USB)" : f.host.value.trim()), + host: f.host.value.trim(), port: +f.port.value || 9761, model: f.model.value, autoconnect: f.autoconnect.checked, + transport, usb: f.usb.value }); + const actions = isNew + ? [h("button", { class: "on", onclick: async () => { + if (transport === "tcp" && !values().host) return toast(t("IP address missing")); + try { const nd = await api("POST", "/api/devices", values()); S.cur = nd.id; toast(t("Added")); } + catch (e) { toast(e.message); } + } }, t("Add"))] + : [ + h("button", { onclick: async () => { try { await api("PUT", `/api/devices/${d.id}`, values()); toast(t("Saved")); } catch (e) { toast(e.message); } } }, t("Save")), + d.status === "disconnected" || d.status === "error" + ? h("button", { class: "on", onclick: async () => { // connects with what the form shows, saved or not + try { await api("PUT", `/api/devices/${d.id}`, values()); await api("POST", `/api/devices/${d.id}/connect`); } + catch (e) { toast(e.message); } + } }, t("Connect")) + : h("button", { onclick: () => api("POST", `/api/devices/${d.id}/disconnect`).catch(e => toast(e.message)) }, t("Disconnect")), + h("button", { class: "danger", onclick: async () => { + if (await askConfirm(t("Remove device"), t("Remove {name} from the list?", { name: q(d.name) }), t("Remove"), true)) + await api("DELETE", `/api/devices/${d.id}`).catch(e => toast(e.message)); + } }, t("Remove")), + ]; + return h("div", { class: "card" }, + h("h3", {}, isNew ? null : h("span", { class: "dot " + d.status }), h("span", { class: "grow" }, isNew ? t("New device") : d.name), + isNew ? null : h("span", { class: "info" }, STATUS_TEXT[d.status])), + !isNew && d.info ? h("div", { class: "info" }, t("Device reports: ") + d.info) : null, + !isNew && d.error ? h("div", { class: "err" }, trMsg(d.error)) : null, + h("div", { class: "devform" }, + h("label", { class: "full" }, "Name", f.name), + h("div", { class: "full sub" }, t("Connection")), seg, + ...netRows, usbRow, + h("label", {}, t("Model"), f.model), + h("label", { class: "chk" }, f.autoconnect, t("Connect automatically")), + h("div", { class: "actions" }, actions))); +} + +// App settings backup: devices, amplifiers/limiter data, PIN, remote access (not the DSP presets) +function backupCard() { + const exportCfg = async () => { + try { if (await saveFile(`DSP-Control-${t("Settings")}_${today()}.json`, await api("GET", "/api/backup"))) toast(t("Settings backed up")); } + catch (e) { toast(t("Error: ") + e.message); } + }; + const restore = async () => { + try { + const f = await openFile(); + if (!f) return; + const doc = f.json; + if (!doc || doc.format !== "dsp-control-config") return toast(t("Not a DSP Control settings backup")); + const when = doc.exported ? doc.exported.replace("T", " ").slice(0, 16) : "?"; + const pin = h("input", { type: "password", inputmode: "numeric", maxlength: 4, autocomplete: "off", placeholder: "••••" }); + const ok = await modal({ title: t("Restore settings"), + body: h("div", { class: "form" }, + h("p", { class: "dlg-text" }, t("Devices ({n}), amplifier and limiter data, PIN and remote access will be replaced by the " + + "backup from {when}. The presets inside the DSPs stay unchanged.", { n: (doc.devices || []).length, when })), + S.isApp ? null : h("label", {}, t("Current PIN"), pin)), + actions: [{ label: t("Cancel") }, { label: t("Restore"), primary: true, value: () => true }] }); + if (!ok) return; + await api("POST", "/api/backup", { doc, pin: pin.value }); + toast(t("Settings restored")); + setTimeout(() => location.reload(), 800); + } catch (e) { toast(t("Error: ") + e.message); } + }; + return h("div", { class: "card" }, h("h3", {}, t("App settings")), + h("p", { class: "info" }, t("Saves devices, amplifiers & limiter calculator, PIN and remote access to a file. ") + + t("The settings inside the DSPs are saved per device via “File…” at the top.")), + h("div", { class: "row" }, h("button", { onclick: exportCfg }, t("Back up…")), h("button", { onclick: restore }, t("Restore…")))); +} + +// Desktop app only: let phones/tablets on the LAN use this PC as server (they need the PIN) +function remoteCard() { + const r = S.remote || { enabled: false, port: 8080, urls: [] }; + const port = h("input", { type: "number", min: 1, max: 65535, value: r.port, class: "short", "aria-label": "Port" }); + const put = async body => { + try { S.remote = await api("PUT", "/api/remote", body); } catch (e) { toast(e.message); } + render(); + }; + const sw = h("button", { class: r.enabled ? "on" : "", "aria-pressed": String(r.enabled), onclick: () => put({ enabled: !r.enabled, port: +port.value || 8080 }) }, + r.enabled ? t("On") : t("Off")); + let status; + if (r.error) status = h("div", { class: "err" }, trMsg(r.error)); + else if (r.running) status = h("div", { class: "remote-urls" }, h("div", { class: "info" }, t("Open on a phone in the same Wi-Fi:")), + r.urls.length ? r.urls.map(u => h("code", {}, u)) : h("code", {}, `http://<${t("IP of this computer")}>:${r.port}`)); + else status = h("p", { class: "info" }, t("Off – only this window has access.")); + return h("div", { class: "card" }, h("h3", {}, h("span", { class: "dot " + (r.running ? "online" : r.error ? "error" : "disconnected") }), + h("span", { class: "grow" }, t("Remote access (web server)"))), + h("div", { class: "row" }, h("span", { class: "grow" }, t("Allow phones & tablets")), sw), + h("div", { class: "row" }, h("span", { class: "grow" }, "Port"), port, + h("button", { class: "small", onclick: () => put({ port: +port.value || 8080 }) }, t("Apply"))), + status, + h("p", { class: "info" }, t("Other devices log in with the PIN (changeable below). Only runs while this app is open. "), + r.platform === "darwin" + ? t("If the macOS firewall is on, it asks the first time – choose “Allow”.") + : t("The first time, Windows Firewall asks – choose “Allow” for private networks."))); +} + +function pinCard() { + const pin = ph => h("input", { type: "password", inputmode: "numeric", pattern: "[0-9]*", maxlength: 4, autocomplete: "off", placeholder: ph }); + const cur = pin("••••"), nw = pin("••••"), rep = pin("••••"); + const err = h("div", { class: "err" }); + return h("div", { class: "card" }, h("h3", {}, S.isApp ? t("PIN for remote access") : t("Access (PIN)")), + h("div", { class: "devform" }, + S.isApp ? null : h("label", { class: "full" }, t("Current PIN"), cur), + h("label", {}, t("New PIN"), nw), h("label", {}, t("Repeat"), rep), + err, + h("div", { class: "actions" }, + h("button", { class: "on", onclick: async () => { + err.textContent = ""; + if (!/^\d{4}$/.test(nw.value)) return (err.textContent = t("The new PIN must be 4 digits.")); + if (nw.value !== rep.value) return (err.textContent = t("The new PINs do not match.")); + try { + await api("POST", "/api/pin", { current: cur.value, new: nw.value }); + cur.value = nw.value = rep.value = ""; toast(t("PIN changed – other devices were logged out")); + } catch (e) { err.textContent = e.message; } + } }, t("Change PIN")), + S.isApp ? null : h("button", { onclick: logout }, svgIcon(ICON.logout), t(" Log out")))), + h("p", { class: "info" }, S.isApp + ? t("This app needs no PIN. The default is 1234; changing it logs out all phones.") + : t("The default PIN is 1234. After changing it only this device stays logged in."))); +} + +// Language per device (stored in the browser); the desktop app also tells the server, for its own dialogs +function langCard() { + const set = async lang => { + if (lang === LANG) return; + store.set("dsp.lang", lang); + if (S.isApp) await api("PUT", "/api/lang", { lang }).catch(() => {}); + location.reload(); + }; + return h("div", { class: "card" }, h("h3", {}, "Language / Sprache"), + h("div", { class: "seg" }, Object.entries(LANGS).map(([k, label]) => + h("button", { class: k === LANG ? "on" : "", "aria-pressed": String(k === LANG), "data-view-ok": "", onclick: () => set(k) }, label)))); +} + +function viewSettings() { + return [ + h("div", { class: "cards" }, langCard()), + h("h2", { class: "section" }, t("Devices")), + h("div", { class: "cards" }, ...S.order.map(id => deviceForm(S.devices[id])), deviceForm(null)), + h("p", { class: "info" }, t("Both DSPs can be connected at the same time – switch between them at the top. "), + t("The DSPs accept only one connection: close the Thomann editor first.")), + h("h2", { class: "section" }, S.isApp ? t("Remote access") : t("Security")), + h("div", { class: "cards" }, S.isApp ? remoteCard() : null, pinCard()), + h("h2", { class: "section" }, t("Backup")), + h("div", { class: "cards" }, backupCard()), + ]; +} + +// ------------------------------------------------------------------ render + +const H_SCROLL = ".mixer, .bands, .geq, .routing"; +function render() { + if (S.busy) { S.dirty = true; return; } + if ($("#app").hidden) return; + if (!S.devices[S.cur]) S.cur = S.order[0] || null; + // keep focus on a text field (e.g. while typing a device name) – re-rendering would steal it + const ae = document.activeElement; + if (ae && main.contains(ae) && ae.matches("input[type=text], input[type=number], input[type=password]")) { S.dirty = true; return; } + renderTabs(); + renderStatus(); + const y = window.scrollY; + // keep sideways scroll positions (mixer on a phone, EQ bands …) while the view stays the same + const viewKey = `${S.cur}|${S.settings}|${S.view}|${S.sel.kind}|${S.sel.idx}`; + const xs = viewKey === render.viewKey ? [...main.querySelectorAll(H_SCROLL)].map(e => e.scrollLeft) : []; + render.viewKey = viewKey; + live.clear(); + let content; + const d = dev(); + document.body.dataset.view = S.settings || !d ? "settings" : S.view; + if (S.settings || !d) content = viewSettings(); + else if (d.status !== "online" || !d.state) + content = h("div", { class: "empty" }, h("div", { class: "spinner" + (["loading", "connecting"].includes(d.status) ? "" : " off") }), + d.status === "loading" ? t("Loading the configuration from the DSP…") + : d.status === "connecting" ? t("Connecting to {where}…", { where: where(d) }) : t("Not connected.")); + else content = ({ mixer: viewMixer, channel: viewChannel, routing: viewRouting, link: viewLink, limiter: viewLimiter }[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); + collectMeters(); +} +// flush deferred renders once a text field loses focus +main.addEventListener("focusout", () => setTimeout(() => { + if (S.dirty && !S.busy && !main.contains(document.activeElement)) { S.dirty = false; render(); } +}, 0)); + +document.querySelectorAll("#viewtabs button").forEach(b => b.addEventListener("click", () => { + S.view = b.dataset.view; S.settings = false; store.set("dsp.view", S.view); render(); window.scrollTo(0, 0); +})); +$("#btn-settings").addEventListener("click", () => { S.settings = !S.settings; render(); window.scrollTo(0, 0); }); + +// header / status bar heights -> CSS vars (sticky channel bar, fader height that fits the screen) +new ResizeObserver(() => { + document.documentElement.style.setProperty("--hdr", $("#top").offsetHeight + "px"); + document.documentElement.style.setProperty("--sb", $("#statusbar").offsetHeight + "px"); +}).observe($("#top")); +new ResizeObserver(() => document.documentElement.style.setProperty("--sb", $("#statusbar").offsetHeight + "px")).observe($("#statusbar")); + +// ------------------------------------------------------------------ lock (desktop app window: look, don't touch) + +function showLock() { + const b = $("#btn-lock"); + b.hidden = !S.isApp; + document.body.classList.toggle("locked", !!S.locked); + b.classList.toggle("on", !!S.locked); + b.title = S.locked ? t("Locked – click to unlock") : t("Lock (view only)"); + b.setAttribute("aria-label", b.title); + b.replaceChildren(...[svgIcon(S.locked ? ICON.lock : ICON.unlock), S.locked ? h("span", {}, t("Locked")) : null].filter(Boolean)); +} + +$("#btn-lock").addEventListener("click", async () => { + if (!S.locked) { + try { await api("POST", "/api/lock"); S.locked = true; showLock(); render(); toast(t("Locked – values are view-only")); } + catch (e) { toast(t("Error: ") + e.message); } + return; + } + const pin = h("input", { type: "password", inputmode: "numeric", maxlength: 4, autocomplete: "off", placeholder: "••••", "aria-label": "PIN" }); + const err = h("div", { class: "err" }); + await modal({ title: t("Unlock"), body: h("div", { class: "form" }, h("label", {}, t("PIN (same as on the phone)"), pin), err), + actions: [{ label: t("Cancel") }, { label: t("Unlock"), primary: true, value: () => { + api("POST", "/api/unlock", { pin: pin.value }).then(() => { + S.locked = false; showLock(); render(); toast(t("Unlocked")); + $("#modal .dlg-actions button").click(); // close the dialog + }).catch(e => { + err.textContent = e.message === "locked" ? t("Too many attempts – please wait a moment") : t("Wrong PIN"); + pin.value = ""; pin.focus(); + }); + return undefined; // keep the dialog open until the PIN is confirmed + } }] }); +}); + +// While locked, everything that would change a value is swallowed; navigating and looking still works. +const VIEW_OK = ".chsel, .nav, .strip-head, .xout, .band, [data-view-ok]"; +for (const type of ["pointerdown", "mousedown", "click", "dblclick", "keydown", "wheel"]) { + document.addEventListener(type, e => { + if (!S.locked || !(e.target instanceof Element)) return; + const tgt = e.target; + if (!tgt.closest("#main, #statusbar") || tgt.closest(VIEW_OK)) return; + if (type === "wheel" && !tgt.closest(".fader, input, select")) return; // page scrolling stays + if (type === "keydown" && !tgt.closest("button, input, select, textarea, .fader, [tabindex]")) return; + if (type === "pointerdown" && !tgt.closest("button, input, select, textarea, .fader, canvas, a")) return; + e.preventDefault(); e.stopPropagation(); + if (type === "click" && Date.now() - (S.lockToast || 0) > 1500) { S.lockToast = Date.now(); toast(t("Locked – unlock at the top right to make changes")); } + }, { capture: true, passive: false }); +} + +// ------------------------------------------------------------------ live events + +function setDevices(list) { + S.devices = {}; S.order = []; + for (const d of list) { S.devices[d.id] = d; S.order.push(d.id); } +} + +function connectEvents() { + if (S.es) S.es.close(); + const es = S.es = new EventSource("/api/events"); + es.onmessage = m => { + const ev = JSON.parse(m.data); + switch (ev.type) { + case "hello": + setDevices(ev.devices); + if (ev.limiter) S.lim = ev.limiter; + if (!S.order.length) S.settings = true; + render(); break; + case "device": + if (!S.devices[ev.device]) S.order.push(ev.device); + S.devices[ev.device] = ev.data; + render(); break; + case "removed": + delete S.devices[ev.device]; S.order = S.order.filter(id => id !== ev.device); + render(); break; + case "status": { + const d = S.devices[ev.device]; + if (!d) break; + Object.assign(d, { status: ev.status, error: ev.error, info: ev.info }); + if (ev.status !== "online") render(); else renderTabs(); + break; + } + case "param": { + const d = S.devices[ev.device]; + if (!d || !d.state) break; + const ch = chans(d, ev.kind)[ev.idx]; + if (Date.now() - (recentlySet.get(`${ev.device}|${ev.kind}|${ev.idx}|${ev.param}`) || 0) < 1500) break; // own echo + 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(); + break; + } + case "lock": + if (S.isApp) { S.locked = ev.locked; showLock(); render(); } + break; + case "meters": + updateMeters(ev); break; + case "limiter": + S.lim = ev.data; + if (!S.busy && (S.view === "limiter" || S.view === "channel")) render(); + break; + } + }; + es.onerror = async () => { + renderTabs(); + try { const a = await (await fetch("/api/auth")).json(); if (!a.authenticated) showLogin(); } catch { /* server down: EventSource retries */ } + }; +} + +// ------------------------------------------------------------------ login + +function showLogin() { + if (S.es) { S.es.close(); S.es = null; } + $("#app").hidden = true; + $("#modal").hidden = true; + const root = $("#login"); + if (!root.hidden) return; + let pin = "", busy = false, lockT = null; + const dots = h("div", { class: "pindots" }, [0, 1, 2, 3].map(() => h("i"))); + const msg = h("div", { class: "pinmsg" }, " "); + const paint = () => [...dots.children].forEach((d, i) => d.classList.toggle("on", i < pin.length)); + const lock = secs => { + clearInterval(lockT); busy = true; + const end = Date.now() + secs * 1000; + const tick = () => { + const left = Math.ceil((end - Date.now()) / 1000); + if (left <= 0) { clearInterval(lockT); busy = false; msg.textContent = " "; pad.classList.remove("locked"); return; } + msg.textContent = t("Too many attempts – locked for {s} s", { s: left }); + }; + pad.classList.add("locked"); tick(); lockT = setInterval(tick, 500); + }; + const submit = async () => { + busy = true; + try { + const r = await fetch("/api/login", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ pin }) }); + const data = await r.json().catch(() => ({})); + if (r.ok) { root.hidden = true; root.replaceChildren(); clearInterval(lockT); startApp(); return; } + pin = ""; paint(); + dots.classList.remove("shake"); void dots.offsetWidth; dots.classList.add("shake"); + buzz(); + busy = false; + if (data.retry) lock(data.retry); + else msg.textContent = r.status === 401 ? (data.left ? t("Wrong PIN – {n} attempts left", { n: data.left }) : t("Wrong PIN")) : t("Error: ") + trMsg(data.error || r.status); + } catch { msg.textContent = t("Server not reachable"); pin = ""; paint(); busy = false; } + }; + const press = k => { + if (busy) return; + if (k === "del") pin = pin.slice(0, -1); + else if (pin.length < 4) pin += k; + paint(); + if (pin.length === 4) submit(); + }; + const key = (k, label) => h("button", { class: "pk" + (k === "del" ? " del" : ""), "aria-label": k === "del" ? t("Delete") : k, + onpointerdown: e => { e.preventDefault(); press(k); }, onclick: e => { if (e.detail === 0) press(k); } }, label ?? k); + const pad = h("div", { class: "pinpad" }, + ["1", "2", "3", "4", "5", "6", "7", "8", "9"].map(k => key(k)), h("span"), key("0"), key("del", "⌫")); + root.replaceChildren(h("div", { class: "loginbox" }, + h("div", { class: "logo" }, $(".brand svg").cloneNode(true)), + h("h1", {}, "DSP Control"), h("p", {}, t("Enter PIN")), dots, msg, pad)); + root.hidden = false; + root.onkeydown = null; + document.onkeydown = e => { + if (root.hidden) return; + if (/^\d$/.test(e.key)) press(e.key); + else if (e.key === "Backspace") press("del"); + }; +} + +async function logout() { + await fetch("/api/logout", { method: "POST" }).catch(() => {}); + showLogin(); +} + +async function startApp() { + $("#app").hidden = false; + try { + const a = await (await fetch("/api/auth")).json(); + S.isApp = !!a.app; + // desktop app: the language chosen there is kept by the server too (survives a reset web view) + if (S.isApp && a.lang && a.lang !== LANG) { + store.set("dsp.lang", a.lang); + if (store.get("dsp.lang") === a.lang) return location.reload(); + } + S.locked = !!a.locked; + showLock(); + if (S.isApp) S.remote = await api("GET", "/api/remote"); + } catch { /* plain web UI */ } + connectEvents(); +} + +(async function init() { + try { + const a = await (await fetch("/api/auth")).json(); + if (a.authenticated) startApp(); else showLogin(); + } catch { showLogin(); } +})(); diff --git a/static/i18n.js b/static/i18n.js new file mode 100644 index 0000000..abefc7e --- /dev/null +++ b/static/i18n.js @@ -0,0 +1,323 @@ +"use strict"; +// UI language. English is the default and the language of the source; DE holds the German texts. +// t("Text with {name}", { name }) translates and fills placeholders; trMsg() does the same for +// messages coming from the server or the DSP connection (some of which contain variable parts). +// Chosen per device under ⚙ → Language (stored in the browser); the desktop app also tells the server. + +const LANGS = { en: "English", de: "Deutsch" }; +const LANG = (() => { try { return localStorage.getItem("dsp.lang") === "de" ? "de" : "en"; } catch { return "en"; } })(); +const LOCALE = LANG === "de" ? "de-AT" : "en-GB"; + +const DE = { + " (end of range reached)": " (Bereichsende erreicht)", + " Log out": " Abmelden", + "+ Add amplifier": "+ Verstärker hinzufügen", + "+ New amplifier…": "+ Neuer Verstärker…", + "20 Hz … 20 kHz, e.g. 1.2k": "20 Hz … 20 kHz, z. B. 1.2k", + "A backup is made automatically before every import. Last backup: {last}.": "Vor jedem Import wird automatisch gesichert. Letzte Sicherung: {last}.", + "a change on one channel applies to the whole group. Name, routing and mix levels stay per channel. ": "eine Änderung an einem Kanal gilt für die ganze Gruppe. Name, Routing und Mix-Pegel bleiben je Kanal. ", + "Access (PIN)": "Zugang (PIN)", + "Add": "Hinzufügen", + "Added": "Hinzugefügt", + "All bands flat": "Alle Bänder flach", + "All flat": "Alle flach", + "Allow phones & tablets": "Handy & Tablet erlauben", + "Amplifier": "Verstärker", + "Amplifier clips – the limiter engages {db} dB too late": "Verstärker clippt – Limiter greift {db} dB zu spät", + "Amplifier is not rated for {ohm} Ω": "Verstärker ist für {ohm} Ω nicht spezifiziert", + "Amplifier −1 dB": "Verstärker −1 dB", + "Amplifiers": "Verstärker", + "App settings": "App-Einstellungen", + "Apply": "Übernehmen", + "Assign an amplifier first": "Erst Verstärker zuordnen", + "Assumes the amplifier’s gain control turned fully up (or as entered).": "Voraussetzung: Gain-Regler am Verstärker auf Rechtsanschlag (bzw. so wie eingetragen).", + "At least one power rating is missing.": "Mindestens eine Leistungsangabe fehlt.", + "Automatic": "Automatisch", + "Back up…": "Sichern…", + "Backup": "Sicherung", + "Both DSPs can be connected at the same time – switch between them at the top. ": "Beide DSPs können gleichzeitig verbunden sein – oben zwischen ihnen umschalten. ", + "Calibration": "Kalibrierung", + "Cancel": "Abbrechen", + "Change PIN": "PIN ändern", + "Channel": "Kanal", + "Channel name": "Kanalname", + "Choose channel": "Kanal wählen", + "Close": "Schließen", + "Compressor": "Kompressor", + "Connect": "Verbinden", + "Connect automatically": "Automatisch verbinden", + "Connecting to {where}…": "Verbinde mit {where}…", + "Connecting…": "Verbinde…", + "Connection": "Verbindung", + "connection closed": "Verbindung beendet", + "Current PIN": "Aktuelle PIN", + "Current PIN is wrong": "Aktuelle PIN ist falsch", + "dBu = 20 · log₁₀(U / 0.775 V).": "dBu = 20 · log₁₀(U / 0,775 V).", + "Decrease": "Verringern", + "Delete": "Löschen", + "Delete amplifier": "Verstärker löschen", + "Delete {name}?": "{name} löschen?", + "desktop app only": "nur in der Desktop-App", + "device not loaded": "Gerät nicht geladen", + "Device reports: ": "Gerät meldet: ", + "Devices": "Geräte", + "Devices ({n}), amplifier and limiter data, PIN and remote access will be replaced by the backup from {when}. The presets inside the DSPs stay unchanged.": "Geräte ({n}), Verstärker- und Limiter-Daten, PIN und Fernzugriff werden durch die Sicherung vom {when} ersetzt. Die Presets in den DSPs bleiben unverändert.", + "Disconnect": "Trennen", + "Disconnected": "Getrennt", + "Drag a fader by its knob · snaps at 0 dB · double-tap the knob = 0 dB · tap the dB value to type one · tap the name = edit channel": "Fader am Knopf ziehen · rastet bei 0 dB ein · Doppeltipp auf den Knopf = 0 dB · dB-Wert antippen zum Eintippen · Name antippen = Kanal bearbeiten", + "Drag the points in the curve · gain snaps at 0 dB": "Punkte in der Kurve ziehen · Gain rastet bei 0 dB ein", + "DSP closed the connection": "DSP hat die Verbindung beendet", + "DSP is not connected": "DSP ist nicht verbunden", + "DSP not responding": "DSP antwortet nicht", + "e.g. 1.4": "z. B. 1.4", + "e.g. 32": "z. B. 32", + "e.g. 4.0": "z. B. 4.0", + "e.g. Crown XLS 1502": "z. B. Crown XLS 1502", + "e.g. DSP 204 stage": "z. B. DSP 204 Bühne", + "Edit": "Bearbeiten", + "Edit amplifier": "Verstärker bearbeiten", + "Edit channel": "Kanal bearbeiten", + "Enter PIN": "PIN eingeben", + "Enter value": "Wert eingeben", + "EQ curve – drag the points": "EQ-Kurve – Punkte ziehen", + "Error": "Fehler", + "Error: ": "Fehler: ", + "Export": "Exportieren", + "Export / import preset": "Preset exportieren / importieren", + "Export saves the DSP’s current state ({name}) to a file. Import loads a file into the active state – stored presets (U01 …) stay unchanged.": "Exportieren speichert den aktuellen Zustand des DSP ({name}) als Datei. Importieren lädt eine Datei in den aktiven Zustand – gespeicherte Presets (U01 …) bleiben unverändert.", + "exported": "exportiert", + "File is too large": "Datei ist zu groß", + "File…": "Datei…", + "Filter type": "Filtertyp", + "First device found": "Erstes gefundenes Gerät", + "Frequency": "Frequenz", + "Gain": "Verstärkung", + "Gain (dB)": "Verstärkung (dB)", + "Gain {v} dB": "Verstärkung {v} dB", + "Graphic EQ · 31 bands": "Grafischer EQ · 31 Bänder", + "High- / low-pass": "Hoch- / Tiefpass", + "High-pass": "Hochpass", + "Highs": "Hochton", + "If the amplifier has a gain control, the value applies with it turned fully up.": "Hat der Verstärker einen Gain-Regler, gilt der Wert bei Rechtsanschlag.", + "If the macOS firewall is on, it asks the first time – choose “Allow”.": "Ist die macOS-Firewall aktiv, fragt sie beim ersten Einschalten – dort „Erlauben“ wählen.", + "Impedance": "Impedanz", + "Import": "Importieren", + "Import incomplete": "Import unvollständig", + "Import preset": "Preset importieren", + "Importing… (a few seconds)": "Importiere… (einige Sekunden)", + "Import…": "Importieren…", + "in ms, or metres with “m” (e.g. 2.5m)": "in ms, oder Meter mit „m“ (z. B. 2.5m)", + "Increase": "Erhöhen", + "Input": "Eingang", + "Input sensitivity (V RMS)": "Eingangsempfindlichkeit (V RMS)", + "Input →": "Eingang →", + "Inputs": "Eingänge", + "into 2 Ω": "an 2 Ω", + "into 4 Ω": "an 4 Ω", + "into 8 Ω": "an 8 Ω", + "IP address": "IP-Adresse", + "IP address missing": "IP-Adresse fehlt", + "IP of this computer": "IP dieses PCs", + "Its assignments will be removed.": "Die Zuordnungen werden entfernt.", + "Language": "Sprache", + "Level": "Pegel", + "Level for {ch}": "Pegel für {ch}", + "Limit to": "Limiter auf", + "Limiter 0 dB equals at the output": "Limiter 0 dB entspricht am Ausgang", + "Limiter active": "Limiter aktiv", + "Limiter tab": "Limiter-Tab", + "Link": "Verknüpfen", + "Link channels": "Kanäle verknüpfen", + "Link {names}? They all take over the settings of {first} (names and routing stay).": "{names} verknüpfen? Alle übernehmen dabei die Einstellungen von {first} (Namen und Routing bleiben).", + "Link {names}? They all take over the settings of {first} (names stay).": "{names} verknüpfen? Alle übernehmen dabei die Einstellungen von {first} (Namen bleiben).", + "Linked channels share all settings (gain, delay, filters, EQ, dynamics, mute) – ": "Verknüpfte Kanäle teilen sich alle Einstellungen (Gain, Delay, Filter, EQ, Dynamik, Mute) – ", + "Linked with {list} – changes apply to all of them (except name, routing and mix levels).": "Verknüpft mit {list} – Änderungen gelten für alle (außer Name, Routing und Mix-Pegel).", + "Linked with {list} – changes apply to all of them (except the name).": "Verknüpft mit {list} – Änderungen gelten für alle (außer Name).", + "Linked: ": "Verknüpft: ", + "Load on channel": "Last am Kanal", + "Load {what} into the active state? The current state is backed up automatically first and can be brought back via File → “Undo import”. Stored presets stay unchanged – to keep it, store it into a memory slot with “Save” afterwards.": "{what} in den aktiven Zustand laden? Der aktuelle Zustand wird vorher automatisch gesichert und lässt sich über Datei → „Import rückgängig“ zurückholen. Gespeicherte Presets bleiben unverändert – zum Behalten danach mit „Speichern“ in einen Speicherplatz schreiben.", + "Loading configuration…": "Lade Konfiguration…", + "Loading the configuration from the DSP…": "Lade Konfiguration vom DSP…", + "Lock": "Sperren", + "Lock (view only)": "Sperren (nur noch ansehen)", + "Locked": "Gesperrt", + "Locked – click to unlock": "Gesperrt – zum Entsperren klicken", + "Locked – unlock at the top right to make changes": "Gesperrt – zum Ändern oben rechts entsperren", + "Locked – unlock with the PIN to make changes": "Gesperrt – zum Ändern mit der PIN entsperren", + "Locked – values are view-only": "Gesperrt – Werte nur noch ansehen", + "login required": "Anmeldung erforderlich", + "Low-pass": "Tiefpass", + "Lower value": "Kleinerer Wert", + "Memory slot": "Speicherplatz", + "Mids": "Mitten", + "Model": "Modell", + "Name (max. 14 characters)": "Name (max. 14 Zeichen)", + "Name is full (max. 8 characters, wide letters count more)": "Name ist voll (max. 8 Zeichen, breite Buchstaben zählen mehr)", + "Network": "Netzwerk", + "New amplifier": "Neuer Verstärker", + "New device": "Neues Gerät", + "New PIN": "Neue PIN", + "Next channel": "Nächster Kanal", + "No amplifier assigned": "Kein Verstärker zugeordnet", + "No backup available": "Keine Sicherung vorhanden", + "No channels linked.": "Keine Kanäle verknüpft.", + "no crossover": "ohne Weiche", + "No DSP found via USB": "Kein DSP per USB gefunden", + "No DSP found via USB – check the cable": "Kein DSP per USB gefunden – Kabel prüfen", + "no HP": "ohne HP", + "Not a DSP Control preset file": "Keine Preset-Datei von DSP Control", + "Not a DSP Control settings backup": "Keine Einstellungs-Sicherung von DSP Control", + "Not assigned to any output": "Keinem Ausgang zugeordnet", + "not connected": "nicht verbunden", + "Not connected.": "Nicht verbunden.", + "Off": "Aus", + "Off (bypass)": "Aus (Bypass)", + "Off – only this window has access.": "Aus – nur dieses Fenster hat Zugriff.", + "On": "Ein", + "Open channel": "Kanal öffnen", + "Open on a phone in the same Wi-Fi:": "Am Handy im selben WLAN öffnen:", + "Other devices log in with the PIN (changeable below). Only runs while this app is open. ": "Andere Geräte melden sich mit der PIN an (unten änderbar). Läuft nur, solange diese App offen ist. ", + "Output ↓": "Ausgang ↓", + "Outputs": "Ausgänge", + "Overwrites the selected memory slot in the DSP.": "Überschreibt den gewählten Speicherplatz im DSP.", + "Parametric EQ": "Parametrischer EQ", + "PIN (same as on the phone)": "PIN (wie am Handy)", + "PIN changed – other devices were logged out": "PIN geändert – andere Geräte wurden abgemeldet", + "PIN for remote access": "PIN für Fernzugriff", + "Please log in": "Bitte anmelden", + "Preset exported": "Preset exportiert", + "Preset file": "Preset-Datei", + "Preset imported": "Preset importiert", + "Preset U{n} recalled": "Preset U{n} geladen", + "Preset {name} imported": "Preset {name} importiert", + "Previous channel": "Vorheriger Kanal", + "Previous state restored": "Vorheriger Zustand wiederhergestellt", + "Rated RMS power per channel (datasheet, empty = not specified)": "Nennleistung RMS pro Kanal (Datenblatt, leer = nicht angegeben)", + "Reading the state from the DSP…": "Lese Zustand vom DSP…", + "Recall": "Laden", + "Recall preset": "Preset laden", + "Recall preset…": "Preset laden…", + "Recall {name} (U{n})? Unsaved changes will be lost.": "{name} (U{n}) laden? Nicht gespeicherte Änderungen gehen verloren.", + "Reference level in dBu": "Referenzpegel in dBu", + "Reference level · ": "Bezugspegel · ", + "release ≈ 16 × attack (shorter pumps). “Auto” picks the band preset matching this channel’s high-pass.": "Release ≈ 16 × Attack (zu kurz pumpt). „Auto“ wählt das Band-Preset passend zum Hochpass dieses Kanals.", + "Remote access": "Fernzugriff", + "Remote access (web server)": "Fernzugriff (Webserver)", + "Remove": "Entfernen", + "Remove device": "Gerät entfernen", + "Remove {name} from the list?": "{name} aus der Liste entfernen?", + "Repeat": "Wiederholen", + "Reset": "Zurücksetzen", + "Reset EQ": "EQ zurücksetzen", + "Reset GEQ": "GEQ zurücksetzen", + "Restore": "Wiederherstellen", + "Restore settings": "Einstellungen wiederherstellen", + "Restore the state from {last}?": "Den Zustand vom {last} wiederherstellen?", + "Restore…": "Wiederherstellen…", + "Restoring…": "Stelle wieder her…", + "Routing matrix": "Routing-Matrix", + "Rule of thumb: attack ≈ one period of the lowest frequency (faster distorts the bass), ": "Faustregel: Attack ≈ eine Schwingung der tiefsten Frequenz (zu schnell verzerrt Bässe), ", + "Save": "Speichern", + "Saved": "Gespeichert", + "Saved device (not plugged in)": "Gespeichertes Gerät (nicht angesteckt)", + "Saves devices, amplifiers & limiter calculator, PIN and remote access to a file. ": "Sichert Geräte, Verstärker & Limiter-Rechner, PIN und Fernzugriff in eine Datei. ", + "Search again": "Neu suchen", + "Security": "Sicherheit", + "Sensitivity": "Empfindlichkeit", + "Sensitivity = input voltage for full power (e.g. 0.775 V or 1.4 V). ": "Empfindlichkeit = Eingangsspannung für volle Leistung (z. B. 0.775 V oder 1.4 V). ", + "Sensitivity is missing.": "Empfindlichkeit fehlt.", + "Sensitivity {v} V": "Empfindlichkeit {v} V", + "Server not reachable": "Server nicht erreichbar", + "Set": "setzen", + "Set all 31 bands to 0 dB?": "Alle 31 Bänder auf 0 dB setzen?", + "Set all PEQ bands of this channel to 0 dB and clear bypass?": "Alle PEQ-Bänder dieses Kanals auf 0 dB setzen und Bypass aufheben?", + "set the threshold to 0 dB, turn up until the limiter engages and measure the output voltage with a multimeter (AC). ": "Threshold 0 dB, Pegel hochdrehen bis der Limiter greift und die Ausgangsspannung mit einem Multimeter (AC) messen. ", + "Settings": "Einstellungen", + "Settings backed up": "Einstellungen gesichert", + "Settings restored": "Einstellungen wiederhergestellt", + "Shown is the continuous sine power (RMS) once the limiter engages – music is well below that on average. ": "Angezeigt wird die Sinus-Dauerleistung (RMS), sobald der Limiter greift – Musik liegt im Mittel deutlich darunter. ", + "Snaps at 0 dB · double-tap the knob = 0 dB": "Rastet bei 0 dB ein · Doppeltipp = 0 dB", + "Sources → ": "Quellen → ", + "Speaker ": "Lautsprecher ", + "Speaker at {pct} % of its rating ({w} RMS)": "Lautsprecher zu {pct} % belastet ({w} RMS)", + "Speaker RMS": "Lautsprecher RMS", + "Speaker RMS (W)": "Lautsprecher RMS (W)", + "Store preset": "Preset speichern", + "Stored in U{n}": "In U{n} gespeichert", + "Tap a crosspoint = connect/disconnect · tap an output = level per input": "Kreuzungspunkt antippen = verbinden/trennen · Ausgang antippen = Pegel pro Eingang", + "Tap at least two channels": "Mindestens zwei Kanäle antippen", + "Target power": "Ziel-Leistung", + "The default PIN is 1234. After changing it only this device stays logged in.": "Standard-PIN ist 1234. Nach dem Ändern bleibt nur dieses Gerät angemeldet.", + "The DSP did not take these values:": "Diese Werte hat der DSP nicht übernommen:", + "The DSPs accept only one connection: close the Thomann editor first.": "Die DSPs erlauben nur eine Verbindung: den Thomann-Editor vorher schließen.", + "The first time, Windows Firewall asks – choose “Allow” for private networks.": "Beim ersten Einschalten fragt die Windows-Firewall – dort „Zulassen“ für private Netzwerke wählen.", + "The link is stored in the DSP and also applies in the Thomann editor.": "Die Verknüpfung wird im DSP gespeichert und gilt auch für den Thomann-Editor.", + "The new PIN must be 4 digits.": "Die neue PIN muss aus 4 Ziffern bestehen.", + "The new PINs do not match.": "Die neuen PINs stimmen nicht überein.", + "The PIN must be 4 digits": "Die PIN muss aus 4 Ziffern bestehen", + "The settings inside the DSPs are saved per device via “File…” at the top.": "Die Einstellungen in den DSPs sichert man pro Gerät oben über „Datei…“.", + "This app needs no PIN. The default is 1234; changing it logs out all phones.": "Diese App braucht keine PIN. Standard ist 1234; nach dem Ändern werden alle Handys abgemeldet.", + "Thomann does not specify the reference level – 0 dBu (0.775 V) is assumed. To measure: feed a 1 kHz sine, ": "Thomann gibt den Bezugspegel nicht an – angenommen sind 0 dBu (0,775 V). Nachmessen: Sinus 1 kHz einspeisen, ", + "TimeoutError": "Zeitüberschreitung", + "Too many attempts – locked for {s} s": "Zu viele Versuche – noch {s} s gesperrt", + "Too many attempts – please wait a moment": "Zu viele Versuche – bitte kurz warten", + "Type": "Typ", + "Undo import": "Import rückgängig", + "Unlink": "Trennen", + "Unlock": "Entsperren", + "Unlocked": "Entsperrt", + "USB cable": "USB-Kabel", + "USB connection lost": "USB-Verbindung getrennt", + "USB device": "USB-Gerät", + "USB device is in use by another program": "USB-Gerät ist von einem anderen Programm belegt", + "USB device not found – check the cable": "USB-Gerät nicht gefunden – Kabel prüfen", + "USB is not supported on this system": "USB wird auf diesem System nicht unterstützt", + "USB write error": "USB-Schreibfehler", + "Used by: ": "Belegt: ", + "View": "Ansicht", + "Watts": "Watt", + "Wrong PIN": "Falsche PIN", + "Wrong PIN – {n} attempts left": "Falsche PIN – noch {n} Versuche", + "{db} dB headroom to amplifier clipping": "{db} dB Reserve bis Verstärker-Clipping", + "{names} linked": "{names} verknüpft", + "{names} unlinked": "{names} getrennt", + "{n} channels selected": "{n} Kanäle gewählt", + "{pct} % of the speaker rating ({w} RMS)": "{pct} % der Lautsprecher-Belastbarkeit ({w} RMS)", + "{pct} % of {rated}": "{pct} % von {rated}", + "— empty —": "— leer —", + "— no amplifier —": "— kein Verstärker —", + "“{s}”": "„{s}“" +}; + +const DE_PATTERNS = [ + [/^Port (\d+) is already in use – please choose another port$/, "Port $1 ist schon belegt – bitte einen anderen Port wählen"], + [/^Port (\d+) is not available \((.*)\)$/, "Port $1 ist nicht verfügbar ($2)"], + [/^Cannot open USB device \(error (.*)\)$/, "USB-Gerät lässt sich nicht öffnen (Fehler $1)"], + [/^USB write error \((.*)\)$/, "USB-Schreibfehler ($1)"], + [/^The file is for a DSP (\w+), the connected device is a (.*)$/, "Die Datei ist für den DSP $1, verbunden ist ein $2"], + [/^Unknown file format \((\d+) bytes\) – expected a DSP Control preset file or a memory image of the (.*) \((\d+) bytes\)$/, + "Unbekanntes Dateiformat ($1 Bytes) – erwartet wird eine Preset-Datei dieser App oder ein Speicherabbild des $2 ($3 Bytes)"], + [/^unknown device '(.*)' - set the model manually$/, "Unbekanntes Gerät „$1“ – Modell bitte manuell einstellen"], + [/^config chunk (\d+) not received$/, "Konfigurations-Teil $1 nicht empfangen"], +]; + +function t(s, vars) { + const text = LANG === "de" && DE[s] != null ? DE[s] : s; + return vars ? text.replace(/\{(\w+)\}/g, (m, k) => (k in vars ? vars[k] : m)) : text; +} +function trMsg(msg) { + msg = String(msg ?? ""); + if (LANG !== "de") return msg; + if (DE[msg] != null) return DE[msg]; + for (const [re, de] of DE_PATTERNS) if (re.test(msg)) return msg.replace(re, de); + return msg; +} +const q = s => t("“{s}”", { s }); // quoted name: “x” / „x“ + +// static texts in index.html +document.documentElement.lang = LANG; +document.querySelectorAll("[data-t]").forEach(el => (el.textContent = t(el.dataset.t))); +document.querySelectorAll("[data-t-label]").forEach(el => { + el.setAttribute("aria-label", t(el.dataset.tLabel)); + if (el.title) el.title = t(el.dataset.tLabel); +}); diff --git a/static/index.html b/static/index.html new file mode 100644 index 0000000..3da3bd3 --- /dev/null +++ b/static/index.html @@ -0,0 +1,42 @@ + + + + + + + + + +DSP Control + + + + +

+ + + + + + + diff --git a/static/style.css b/static/style.css new file mode 100644 index 0000000..d97329e --- /dev/null +++ b/static/style.css @@ -0,0 +1,444 @@ +:root { + --bg: #0b0c0f; + --bg2: #101216; + --panel: #15181d; + --panel2: #1c2027; + --panel3: #232831; + --line: #2a303a; + --line2: #3a4250; + --text: #e8edf3; + --dim: #8a95a3; + --dim2: #5d6773; + --accent: #38bdf8; + --accent2: #0284c7; + --ok: #22c55e; + --warn: #f59e0b; + --bad: #ef4444; + --mute: #dc2626; + --led-g: #2bff6b; + --led-o: #ffa31a; + --led-r: #ff3030; + --radius: 12px; + --hdr: 56px; + --bnav: 0px; + --sb: 70px; + color-scheme: dark; +} +* { box-sizing: border-box; } +html, body { margin: 0; background: var(--bg); color: var(--text); } +body { + font: 15px/1.35 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; + -webkit-tap-highlight-color: transparent; + overscroll-behavior-y: contain; + min-height: 100dvh; +} +[hidden] { display: none !important; } +button, input, select { font: inherit; color: inherit; } +button { + background: var(--panel2); border: 1px solid var(--line); border-radius: 9px; + padding: 8px 12px; min-height: 40px; cursor: pointer; touch-action: manipulation; + display: inline-flex; align-items: center; justify-content: center; gap: 6px; + transition: background .12s, border-color .12s, color .12s; +} +button:hover { border-color: var(--line2); } +button:active { filter: brightness(1.25); } +button:focus-visible, select:focus-visible, input:focus-visible, .fader:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } +button.on { background: var(--accent2); border-color: var(--accent); color: #fff; } +button:disabled { opacity: .45; cursor: default; } +button.danger { color: #fca5a5; } +button.danger-on { background: #991b1b; border-color: #ef4444; color: #fff; } +button.small { min-height: 32px; padding: 4px 10px; font-size: 13px; text-transform: none; letter-spacing: 0; } +button.icon { background: none; border-color: transparent; padding: 8px; min-width: 44px; } +button.icon:hover { background: var(--panel2); } +button svg, .icon svg { width: 22px; height: 22px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; } +select, input[type=text], input[type=number], input[type=password] { + background: var(--panel2); border: 1px solid var(--line); border-radius: 9px; + padding: 8px 10px; min-height: 40px; width: 100%; min-width: 0; +} +select { cursor: pointer; } +input.bad { border-color: var(--bad); } +label.inline { display: flex; align-items: center; gap: 8px; font-size: 13px; color: var(--dim); } + +/* ------------------------------------------------------------- header */ +#top { + position: sticky; top: 0; z-index: 20; display: flex; align-items: center; gap: 8px; + padding: calc(6px + env(safe-area-inset-top)) max(8px, env(safe-area-inset-right)) 6px max(8px, env(safe-area-inset-left)); + background: rgba(11, 12, 15, .92); backdrop-filter: blur(10px); -webkit-backdrop-filter: blur(10px); + border-bottom: 1px solid var(--line); +} +.brand { display: flex; flex: none; } +#devtabs { display: flex; gap: 6px; overflow-x: auto; flex: 1; min-width: 0; scrollbar-width: none; } +#devtabs::-webkit-scrollbar { display: none; } +.devtab { white-space: nowrap; flex: none; max-width: 220px; background: var(--panel); } +.devtab .dn { overflow: hidden; text-overflow: ellipsis; } +.devtab small { font-size: 11px; color: var(--dim); background: var(--panel3); border-radius: 5px; padding: 1px 5px; } +.devtab.active { background: var(--panel3); border-color: var(--accent); } +.dot { width: 9px; height: 9px; border-radius: 50%; background: var(--dim2); flex: none; } +.dot.online { background: var(--ok); box-shadow: 0 0 6px var(--ok); } +.dot.connecting, .dot.loading { background: var(--warn); animation: blink 1s infinite; } +.dot.error { background: var(--bad); } +@keyframes blink { 50% { opacity: .3; } } + +#viewtabs { display: flex; gap: 4px; background: var(--panel); border: 1px solid var(--line); border-radius: 11px; padding: 3px; flex: none; } +#viewtabs button { border: 0; background: none; min-height: 36px; padding: 6px 14px; color: var(--dim); border-radius: 8px; } +#viewtabs button svg { width: 18px; height: 18px; } +#viewtabs button svg .f { fill: currentColor; stroke: none; } +#viewtabs button.active { background: var(--panel3); color: var(--accent); } +body[data-view=settings] #viewtabs button.active { background: none; color: var(--dim); } + +#statusbar { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; padding: 10px max(10px, env(safe-area-inset-right)) 6px max(10px, env(safe-area-inset-left)); } +#statusbar:empty { display: none; } +#statusbar .preset { flex: 1 1 180px; min-width: 0; } +#statusbar .preset b { display: block; font-size: 18px; letter-spacing: .01em; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +#statusbar .preset small { color: var(--dim); font-size: 12px; } +#statusbar .presetrow { flex: 0 1 380px; display: flex; gap: 8px; min-width: 0; } +#statusbar .presetrow select { flex: 1; min-width: 0; } +#statusbar .presetrow button { flex: none; } + +#main { padding: 4px max(10px, env(safe-area-inset-right)) calc(24px + var(--bnav)) max(10px, env(safe-area-inset-left)); max-width: 1500px; margin: 0 auto; } + +/* phones: view switcher becomes a bottom navigation bar */ +@media (max-width: 759px) { + :root { --bnav: calc(62px + env(safe-area-inset-bottom)); } + .brand { display: none; } + /* backdrop-filter would make the header the containing block of the fixed bottom bar */ + #top { backdrop-filter: none; -webkit-backdrop-filter: none; background: var(--bg); } + #viewtabs { + position: fixed; left: 0; right: 0; bottom: 0; z-index: 30; border-radius: 0; border: 0; border-top: 1px solid var(--line); + padding: 4px 6px env(safe-area-inset-bottom); background: rgba(16, 18, 22, .96); backdrop-filter: blur(10px); -webkit-backdrop-filter: blur(10px); + } + #viewtabs button { flex: 1; flex-direction: column; gap: 2px; font-size: 11px; min-height: 54px; padding: 4px; } + #viewtabs button svg { width: 22px; height: 22px; } + #toast { bottom: calc(var(--bnav) + 12px) !important; } +} + +/* ------------------------------------------------------------- generic blocks */ +.card { background: var(--panel); border: 1px solid var(--line); border-radius: var(--radius); padding: 14px; min-width: 0; } +.card h3 { margin: 0 0 12px; font-size: 12px; text-transform: uppercase; letter-spacing: .08em; color: var(--dim); + display: flex; align-items: center; gap: 8px; min-height: 22px; } +.grow { flex: 1; } +.cards { display: grid; gap: 10px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 340px), 1fr)); align-items: start; margin-bottom: 10px; } +.cards .wide { grid-column: 1 / -1; } +h2.section { font-size: 13px; text-transform: uppercase; letter-spacing: .08em; color: var(--dim); margin: 14px 2px 8px; } +.empty { color: var(--dim); text-align: center; padding: 60px 16px; display: flex; flex-direction: column; align-items: center; gap: 16px; } +.spinner { width: 28px; height: 28px; border-radius: 50%; border: 3px solid var(--line); border-top-color: var(--accent); animation: spin .9s linear infinite; } +.spinner.off { display: none; } +@keyframes spin { to { transform: rotate(360deg); } } +.row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; } +.row > * { flex: 1 1 auto; } +.row > button { flex: 0 0 auto; } +.grow2 { flex: 1 1 160px !important; } +.info { font-size: 12px; color: var(--dim); margin: 8px 2px 0; } +.info.off { margin: 4px 0 6px; } +.hint { text-align: center; } +.err { color: #fca5a5; font-size: 13px; } + +/* ------------------------------------------------------------- parameter rows */ +.param { margin: 10px 0 4px; } +.param .lbl { display: flex; justify-content: space-between; align-items: center; gap: 8px; font-size: 13px; color: var(--dim); margin-bottom: 2px; } +.valbox { display: flex; align-items: center; gap: 4px; } +.valbox .val { min-width: 104px; min-height: 32px; padding: 3px 8px; background: var(--bg2); border-color: var(--line); + font-variant-numeric: tabular-nums; font-size: 14px; color: var(--text); } +.valbox .step { width: 34px; min-width: 34px; min-height: 32px; padding: 0; font-size: 18px; line-height: 1; color: var(--dim); background: var(--panel2); } +.valbox .step:hover { color: var(--text); } +.param.atzero .val { color: var(--ok); border-color: #1f5f36; } +.rangewrap { position: relative; } +.rangewrap .zmark { position: absolute; top: 6px; bottom: 6px; width: 2px; margin-left: -1px; border-radius: 1px; background: var(--line2); + left: calc(13px + (100% - 26px) * var(--f)); pointer-events: none; } +.param.atzero .zmark { background: var(--ok); } +input[type=range] { position: relative; width: 100%; height: 36px; background: transparent; -webkit-appearance: none; appearance: none; margin: 0; cursor: pointer; touch-action: pan-y; } +input[type=range]::-webkit-slider-runnable-track { height: 6px; background: var(--line); border-radius: 3px; } +input[type=range]::-moz-range-track { height: 6px; background: var(--line); border-radius: 3px; } +input[type=range]::-webkit-slider-thumb { -webkit-appearance: none; width: 26px; height: 26px; margin-top: -10px; border-radius: 50%; + background: radial-gradient(circle at 50% 40%, #e2e8f0, #94a3b8); border: 2px solid #0b0c0f; box-shadow: 0 1px 4px #000c; } +input[type=range]::-moz-range-thumb { width: 22px; height: 22px; border-radius: 50%; background: radial-gradient(circle at 50% 40%, #e2e8f0, #94a3b8); border: 2px solid #0b0c0f; } +.param.atzero input[type=range]::-webkit-slider-thumb { box-shadow: 0 0 0 3px #22c55e55, 0 1px 4px #000c; } + +/* ------------------------------------------------------------- LED meters (segment bars) */ +.led { display: flex; gap: 2px; flex: none; } +.led > i { flex: 1; border-radius: 1.5px; background: var(--c); opacity: .13; } +.led > i.g { --c: var(--led-g); } +.led > i.o { --c: var(--led-o); } +.led > i.r { --c: var(--led-r); } +.led.v { flex-direction: column-reverse; width: 12px; height: 100%; padding: 12px 0; } +.led.h { flex-direction: row; height: 10px; width: 120px; } +.muted .led > i { filter: saturate(.25); } + +/* ------------------------------------------------------------- fader */ +/* only the cap grabs: a swipe anywhere else on the fader scrolls the page / the mixer sideways */ +.fader { --tx: 50%; position: relative; touch-action: pan-x pan-y; user-select: none; -webkit-user-select: none; border-radius: 8px; } +.fader .track { position: absolute; left: var(--tx); top: 12px; bottom: 12px; width: 6px; margin-left: -3px; background: #07080a; + border-radius: 3px; box-shadow: inset 0 0 0 1px var(--line); } +.fader .tick { position: absolute; left: calc(var(--tx) - 14px); width: 28px; height: 1px; background: var(--line2); + top: calc(12px + (100% - 24px) * (1 - var(--f))); } +.fader .tick.z { background: var(--dim); height: 2px; margin-top: -0.5px; } +.fader .tick span { position: absolute; right: calc(100% + 3px); top: -6px; font-size: 9px; line-height: 12px; color: var(--dim2); font-variant-numeric: tabular-nums; white-space: nowrap; } +.fader .tick.z span { color: var(--dim); font-weight: 600; } +.fader .cap { position: absolute; left: calc(var(--tx) - 16px); width: 32px; height: 40px; margin-top: -20px; border-radius: 5px; + top: calc(12px + (100% - 24px) * (1 - var(--f))); + background: linear-gradient(#3b4250, #262b34 45%, #1b1f26 55%, #2c323c); border: 1px solid #4a5260; + box-shadow: 0 3px 8px #000c, inset 0 1px 0 #ffffff1a; } +.fader .cap { touch-action: none; cursor: ns-resize; z-index: 1; } +.fader .cap::before { content: ""; position: absolute; inset: -10px -8px; } /* larger grip area for fingers */ +.fader .cap::after { content: ""; position: absolute; left: 3px; right: 3px; top: 50%; height: 2px; margin-top: -1px; background: #e8edf3; border-radius: 1px; } +.fader.atzero .cap::after { background: var(--ok); box-shadow: 0 0 6px var(--ok); } +.fader.grab .cap { border-color: var(--accent); } + +/* ------------------------------------------------------------- mixer */ +.mixer { display: flex; gap: 14px; overflow-x: auto; padding-bottom: 8px; scroll-snap-type: x proximity; } +.mgroup { flex: 0 0 auto; display: flex; flex-direction: column; gap: 6px; } +.mgroup h4 { margin: 0 2px; font-size: 11px; text-transform: uppercase; letter-spacing: .1em; color: var(--dim); font-weight: 600; } +.strips { display: flex; gap: 6px; } +.strip { --cc: var(--warn); flex: none; width: 92px; background: linear-gradient(var(--panel), var(--bg2)); border: 1px solid var(--line); + border-radius: var(--radius); padding: 0 6px 8px; display: flex; flex-direction: column; align-items: stretch; gap: 8px; + scroll-snap-align: start; position: relative; overflow: hidden; } +.strip::before { content: ""; height: 3px; margin: 0 -6px; background: var(--cc); opacity: .9; } +.strip-head { flex-direction: column; gap: 0; background: none; border: 0; padding: 2px 0; min-height: 38px; border-radius: 6px; } +.strip-head:hover { background: var(--panel2); } +.strip-head .kind { font-size: 11px; color: var(--dim); letter-spacing: .04em; } +.strip-head .nm { font-weight: 650; font-size: 13px; max-width: 78px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.faderbox { display: flex; justify-content: center; gap: 4px; + height: clamp(170px, calc(100dvh - var(--hdr) - var(--sb) - var(--bnav) - 196px), 560px); } +.strip .fader { --tx: 36px; width: 56px; height: 100%; } +.strip .db { min-height: 32px; padding: 2px; font-variant-numeric: tabular-nums; font-size: 13px; background: var(--bg2); } +.strip .db.z { color: var(--ok); } +.strip button.mute { min-height: 38px; font-weight: 700; font-size: 12px; letter-spacing: .06em; } +button.mute.on { background: var(--mute); border-color: #f87171; color: #fff; box-shadow: 0 0 10px #dc262655; } +.strip.muted { background: linear-gradient(#1f1517, var(--bg2)); } +@media (min-width: 1200px) { + .mgroup { flex-shrink: 1; flex-basis: 0; } + .strip { flex: 1 1 92px; max-width: 128px; } +} + +/* ------------------------------------------------------------- channel view */ +.chbar { position: sticky; top: var(--hdr); z-index: 10; display: flex; align-items: center; gap: 6px; margin: 0 -10px 10px; padding: 8px 10px; + background: rgba(11, 12, 15, .94); backdrop-filter: blur(10px); -webkit-backdrop-filter: blur(10px); border-bottom: 1px solid var(--line); } +.chbar .nav { flex: none; background: var(--panel2); border-color: var(--line); min-width: 44px; } +.chselwrap { --cc: var(--warn); flex: 1 1 auto; min-width: 0; position: relative; max-width: 420px; } +.chselwrap::before { content: ""; position: absolute; left: 0; top: 8px; bottom: 8px; width: 4px; border-radius: 2px; background: var(--cc); pointer-events: none; } +.chsel { font-weight: 650; font-size: 16px; padding-left: 14px; min-height: 44px; background: var(--panel2); } +.chbar .led.h { width: clamp(60px, 18vw, 200px); } +.chbar .mute { flex: none; min-width: 70px; font-weight: 700; font-size: 12px; letter-spacing: .06em; } +@media (max-width: 480px) { .chbar .led.h { display: none; } } + +.sub { font-size: 13px; color: var(--text); font-weight: 600; flex: 0 0 80px !important; } +.xo + .xo { margin-top: 14px; padding-top: 12px; border-top: 1px solid var(--line); } +canvas.curve { width: 100%; height: clamp(200px, 32vw, 320px); display: block; background: #08090b; border: 1px solid var(--line); border-radius: 10px; touch-action: none; cursor: crosshair; } +.bands { display: flex; gap: 6px; overflow-x: auto; padding: 10px 0 4px; scrollbar-width: thin; } +.band { flex: 1 0 58px; flex-direction: column; gap: 0; padding: 5px 4px; min-height: 52px; line-height: 1.15; } +.band b { font-size: 14px; } +.band small { font-size: 10.5px; color: var(--dim); font-variant-numeric: tabular-nums; } +.band.active:not(.on) { border-color: #3b6d8a; } +.band.on { background: #3a2a0d; border-color: var(--warn); color: #fff; } +.band.on small { color: #fcd9a0; } +.band.bypassed { opacity: .45; } +.band.bypassed b { text-decoration: line-through; } +.bandhead { margin-top: 8px; } +.bandhead label { flex: 1 1 200px; } +.pgrid { display: grid; gap: 0 18px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 260px), 1fr)); } + +.geq { display: flex; gap: 2px; overflow-x: auto; padding-bottom: 6px; } +.gb { flex: 1 0 30px; display: flex; flex-direction: column; align-items: center; gap: 4px; font-size: 10px; color: var(--dim); } +.gb .fader { width: 30px; height: 190px; } +.gb .fader .tick { left: 3px; width: 24px; } +.gb .fader .cap { left: 1px; width: 28px; height: 24px; margin-top: -12px; } +.gb .gv { font-variant-numeric: tabular-nums; } +.gb .gv.nz { color: var(--warn); } +.gb .gf { white-space: nowrap; } + +.mixrow { display: grid; grid-template-columns: minmax(110px, 0.6fr) 1fr; gap: 4px 12px; align-items: center; padding: 4px 0; } +.mixrow + .mixrow { border-top: 1px solid var(--line); } +.mixrow .param { margin: 4px 0; } +.mixrow .param .lbl > span:first-child { display: none; } +.mixrow .param .lbl { justify-content: flex-end; } +.mixrow.off .param { opacity: .45; } +.src { --cc: var(--accent); justify-content: flex-start; text-align: left; min-height: 44px; } +.src .sw { width: 30px; height: 18px; border-radius: 9px; background: var(--line); position: relative; flex: none; transition: background .15s; } +.src .sw::after { content: ""; position: absolute; left: 2px; top: 2px; width: 14px; height: 14px; border-radius: 50%; background: var(--dim); transition: transform .15s, background .15s; } +.src.on { background: var(--panel2); border-color: var(--cc); color: var(--text); } +.src.on .sw { background: var(--cc); } +.src.on .sw::after { transform: translateX(12px); background: #fff; } +@media (max-width: 420px) { .mixrow { grid-template-columns: 1fr; } } + +/* ------------------------------------------------------------- routing matrix */ +.routing { overflow-x: auto; } +.xmatrix { display: grid; grid-template-columns: minmax(104px, 1.1fr) repeat(var(--n), minmax(58px, 1fr)); gap: 0; min-width: min-content; } +.xcorner { display: flex; flex-direction: column; justify-content: flex-end; padding: 0 8px 8px 2px; font-size: 11px; color: var(--dim2); } +.xin { --cc: var(--accent); display: flex; flex-direction: column; align-items: center; gap: 2px; padding: 8px 4px 10px; border-top: 3px solid var(--cc); + background: linear-gradient(color-mix(in srgb, var(--cc) 10%, transparent), transparent); border-radius: 6px 6px 0 0; margin: 0 3px; min-width: 0; } +.xin b { font-size: 14px; } +.xin small { font-size: 11px; color: var(--dim); max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.xin .led.h { width: 80%; height: 6px; margin-top: 4px; } +.xout { display: grid; grid-template-columns: 1fr auto; grid-template-rows: auto auto; justify-items: start; align-items: center; gap: 0 6px; + text-align: left; border-radius: 9px 0 0 9px; border: 0; border-top: 1px solid var(--line); background: none; padding: 8px; min-height: 64px; } +.xout:hover { background: var(--panel2); } +.xout.open { background: var(--panel3); } +.xo-t { display: flex; flex-direction: column; min-width: 0; } +.xo-t b { font-size: 14px; } +.xo-t small { font-size: 11px; color: var(--dim); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 100%; } +.xo-s { grid-column: 1; font-size: 11px; color: var(--accent); } +.chev { grid-column: 2; grid-row: 1 / 3; color: var(--dim); font-size: 16px; } +.xp { --cc: var(--accent); position: relative; border: 0; border-top: 1px solid var(--line); border-radius: 0; min-height: 64px; padding: 0; background: + linear-gradient(var(--line), var(--line)) center / 2px 100% no-repeat, + linear-gradient(var(--line), var(--line)) center / 100% 2px no-repeat; flex-direction: column; gap: 3px; } +.xp:hover { background-color: var(--panel2); } +.xp .node { width: 24px; height: 24px; border-radius: 50%; background: var(--bg); border: 2px solid var(--line2); transition: transform .12s, background .12s; } +.xp:hover .node { border-color: var(--dim); } +.xp.on { border-color: var(--line); color: var(--text); --lc: color-mix(in srgb, var(--cc) 60%, transparent); background: + linear-gradient(var(--lc), var(--lc)) center / 2px 100% no-repeat, + linear-gradient(var(--lc), var(--lc)) center / 100% 2px no-repeat; } +.xp.on .node { background: var(--cc); border-color: #fff; box-shadow: 0 0 0 4px color-mix(in srgb, var(--cc) 30%, transparent), 0 0 14px var(--cc); transform: scale(1.08); } +.xp small { position: absolute; bottom: 3px; left: 0; right: 0; font-size: 10px; color: var(--text); background: none; font-variant-numeric: tabular-nums; } +.xpanel { grid-column: 1 / -1; background: var(--panel3); border-radius: 0 0 10px 10px; padding: 6px 12px 10px; margin-bottom: 6px; } +.xpanel-h { display: flex; align-items: center; justify-content: space-between; gap: 8px; font-size: 12px; color: var(--dim); text-transform: uppercase; letter-spacing: .06em; padding: 4px 0; } + +/* ------------------------------------------------------------- settings */ +.devform { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; } +.devform label { font-size: 12px; color: var(--dim); display: flex; flex-direction: column; gap: 4px; } +.devform label.full, .devform .err { grid-column: 1 / -1; } +.devform label.chk { flex-direction: row; align-items: center; gap: 8px; color: var(--text); font-size: 14px; } +.devform label.chk input { width: 20px; height: 20px; } +.devform .actions { grid-column: 1 / -1; display: flex; gap: 8px; flex-wrap: wrap; } +.devform .actions button { flex: 1 1 auto; } + +/* ------------------------------------------------------------- dialogs */ +#modal { position: fixed; inset: 0; z-index: 100; display: flex; align-items: center; justify-content: center; padding: 16px; } +.backdrop { position: absolute; inset: 0; background: #000a; animation: fade .15s; } +.dialog { position: relative; width: min(420px, 100%); background: var(--panel); border: 1px solid var(--line2); border-radius: 16px; + padding: 18px; box-shadow: 0 20px 60px #000c; animation: pop .15s ease-out; } +.dialog h2 { margin: 0 0 12px; font-size: 17px; } +.dlg-text { margin: 0 0 4px; color: var(--dim); } +.dlg-actions { display: flex; flex-wrap: wrap; gap: 8px; justify-content: flex-end; margin-top: 16px; } +.dlg-actions button { min-width: 110px; } +.dialog .row input { flex: 1 1 140px; font-size: 18px; font-variant-numeric: tabular-nums; } +.dialog .chip { flex: none; } +.form { display: flex; flex-direction: column; gap: 10px; } +.form label { display: flex; flex-direction: column; gap: 4px; font-size: 12px; color: var(--dim); } +@keyframes fade { from { opacity: 0; } } +@keyframes pop { from { opacity: 0; transform: scale(.96) translateY(6px); } } +@media (max-width: 520px) { + #modal { align-items: flex-end; padding: 0; } + .dialog { width: 100%; border-radius: 18px 18px 0 0; padding-bottom: calc(18px + env(safe-area-inset-bottom)); animation: slideup .18s ease-out; } + .dlg-actions button { flex: 1; } +} +@keyframes slideup { from { transform: translateY(40px); opacity: 0; } } + +#toast { position: fixed; left: 50%; bottom: calc(20px + env(safe-area-inset-bottom)); transform: translateX(-50%); + background: #1f2937; border: 1px solid var(--line2); padding: 10px 16px; border-radius: 10px; z-index: 120; max-width: 90vw; box-shadow: 0 8px 24px #000a; } + +/* ------------------------------------------------------------- login */ +#login { position: fixed; inset: 0; z-index: 200; display: flex; align-items: center; justify-content: center; overflow-y: auto; + background: radial-gradient(ellipse at 50% 0%, #13253a 0%, var(--bg) 60%); padding: 20px; } +.loginbox { display: flex; flex-direction: column; align-items: center; width: min(320px, 100%); } +.loginbox .logo svg { width: 56px; height: 56px; } +.loginbox h1 { margin: 12px 0 2px; font-size: 22px; letter-spacing: .02em; } +.loginbox p { margin: 0 0 22px; color: var(--dim); } +.pindots { display: flex; gap: 18px; margin-bottom: 10px; } +.pindots i { width: 16px; height: 16px; border-radius: 50%; border: 2px solid var(--line2); transition: background .1s, border-color .1s, transform .1s; } +.pindots i.on { background: var(--accent); border-color: var(--accent); transform: scale(1.1); box-shadow: 0 0 10px #38bdf888; } +.pindots.shake { animation: shake .4s; } +.pindots.shake i { border-color: var(--bad); } +@keyframes shake { 20%, 60% { transform: translateX(-10px); } 40%, 80% { transform: translateX(10px); } } +.pinmsg { min-height: 20px; font-size: 13px; color: #fca5a5; margin-bottom: 14px; text-align: center; } +.pinpad { display: grid; grid-template-columns: repeat(3, 1fr); gap: 14px; width: 100%; max-width: 280px; } +.pinpad.locked { opacity: .35; pointer-events: none; } +.pk { aspect-ratio: 1; border-radius: 50%; font-size: 26px; font-weight: 500; background: var(--panel); border: 1px solid var(--line); min-height: 0; } +.pk:active { background: var(--accent2); border-color: var(--accent); filter: none; } +.pk.del { font-size: 22px; background: none; border-color: transparent; color: var(--dim); } +@media (max-height: 560px) { .pk { aspect-ratio: auto; height: 52px; border-radius: 14px; } .pinpad { gap: 8px; } .loginbox p { margin-bottom: 10px; } } + +/* ------------------------------------------------------------- limiter calculator */ +.limcard h3 .led.h { width: clamp(50px, 14vw, 110px); height: 8px; } +.lres { --c: var(--ok); border: 1px solid var(--line); border-left: 4px solid var(--c); border-radius: 10px; padding: 10px 12px; margin-bottom: 12px; + background: linear-gradient(90deg, color-mix(in srgb, var(--c) 10%, transparent), transparent 70%); } +.lres.warn { --c: var(--warn); } +.lres.bad { --c: var(--bad); } +.lres.none { --c: var(--line2); background: none; } +.lw { font-size: 30px; font-weight: 700; font-variant-numeric: tabular-nums; line-height: 1.1; } +.lw small { font-size: 14px; font-weight: 500; color: var(--dim); } +.lsub { font-size: 13px; color: var(--dim); margin-top: 2px; } +.lbar { position: relative; height: 8px; border-radius: 4px; background: var(--panel3); margin: 10px 0 4px; } +.lres.none .lbar { display: none; } +.lbar i { position: absolute; inset: 0 auto 0 0; width: calc(var(--p) * 100%); border-radius: 4px; background: var(--c); transition: width .15s; } +.lbar b, .lbar::after { position: absolute; top: -4px; bottom: -4px; width: 2px; background: var(--text); left: calc(var(--a) * 100% - 1px); } +.lbar::after { content: ""; display: none; background: var(--warn); left: calc(var(--s) * 100% - 1px); } +.lbar.hasspk::after { display: block; } +.lnotes { display: grid; gap: 2px; margin-top: 6px; font-size: 12.5px; } +.lnotes .ok { color: #86efac; } .lnotes .warn { color: #fcd34d; } .lnotes .bad { color: #fca5a5; } +.lnotes div::before { content: "● "; font-size: 9px; vertical-align: 2px; } +.limgrid { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; margin-bottom: 8px; } +.limgrid label { font-size: 12px; color: var(--dim); display: flex; flex-direction: column; gap: 4px; min-width: 0; } +.limgrid label.full { grid-column: 1 / -1; } +.target { border-top: 1px solid var(--line); margin-top: 10px; padding-top: 10px; } +.target .row input { flex: 1 1 80px; min-width: 0; } +.target .sub { flex: 0 0 auto !important; } +.chips { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 8px; } +button.chip { min-height: 30px; padding: 3px 10px; font-size: 12.5px; text-transform: none; letter-spacing: 0; border-radius: 15px; } +details.more { margin-top: 8px; } +details.more summary { cursor: pointer; font-size: 13px; color: var(--dim); padding: 6px 0; user-select: none; } +.amp .ampspec { font-size: 15px; font-weight: 600; font-variant-numeric: tabular-nums; } +.amp .actions { display: flex; justify-content: flex-end; margin-top: 8px; } +.addcard { min-height: 90px; border-style: dashed; color: var(--dim); background: none; font-size: 14px; } +.addcard:hover { color: var(--accent); border-color: var(--accent); } +input.short { flex: 0 0 72px !important; width: 72px; text-align: right; } +.seg { display: flex; gap: 0; } +.seg button { flex: 1; border-radius: 0; text-transform: none; letter-spacing: 0; } +.seg button:first-child { border-radius: 8px 0 0 8px; } +.seg button:last-child { border-radius: 0 8px 8px 0; margin-left: -1px; } +.ampform { grid-template-columns: repeat(3, minmax(0, 1fr)); } +.ampform .full { grid-column: 1 / -1; } +.ampform input { min-width: 0; width: 100%; } +.ampform .sub { margin-top: 4px; } +.ampform .full > label { font-size: 12px; color: var(--dim); display: flex; flex-direction: column; gap: 4px; } +.ampform label[hidden] { display: none; } +.chips.presets { display: grid; grid-template-columns: repeat(auto-fill, minmax(104px, 1fr)); margin: 6px 0 10px; } +button.chip.preset { flex-direction: column; align-items: flex-start; gap: 0; border-radius: 9px; padding: 5px 9px; min-height: 42px; text-align: left; } +button.chip.preset b { font-size: 13px; } +button.chip.preset small { font-size: 10.5px; color: var(--dim); font-weight: 400; } +button.chip.preset.on small { color: #e0f2fe; } +details.more summary .tag { margin-left: 8px; font-size: 11px; padding: 1px 7px; border-radius: 9px; background: var(--panel3); color: var(--accent); } + +/* ------------------------------------------------------------- desktop app: remote access */ +.remote-urls { display: flex; flex-direction: column; gap: 4px; margin-top: 8px; } +.remote-urls code { font: 600 15px ui-monospace, Consolas, monospace; color: var(--accent); background: var(--panel2); + border: 1px solid var(--line); border-radius: 8px; padding: 6px 10px; user-select: all; } + +/* ------------------------------------------------------------- device form: network / USB */ +.devform .full { grid-column: 1 / -1; } +.devform [hidden] { display: none !important; } +.devform .sub { margin-top: 2px; color: var(--dim); font-weight: 500; font-size: 12px; } +.devform .row { flex-wrap: nowrap; } +.devform .row select { flex: 1 1 auto; min-width: 0; } + +/* channel links */ +.lnk { --lc: var(--warn); display: inline-flex; vertical-align: -2px; margin-left: 4px; color: var(--lc); } +.lnk svg, .linknote svg, .lkgroup svg, .lkmark svg { width: 14px; height: 14px; fill: none; stroke: currentColor; stroke-width: 2.2; stroke-linecap: round; } +.linknote { --lc: var(--warn); color: var(--lc); margin: -4px 0 10px; } +.linknote svg { vertical-align: -2px; } +.lkgrid { display: grid; grid-template-columns: repeat(auto-fill, minmax(96px, 1fr)); gap: 6px; } +.lkch { --lc: var(--line); position: relative; flex-direction: column; gap: 0; min-height: 58px; border-top: 3px solid var(--lc); } +.lkch small { color: var(--dim); max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.lkch .lkmark { position: absolute; top: 4px; right: 5px; color: var(--lc); } +.lkch.sel { background: var(--accent2); border-color: var(--accent); color: #fff; } +.lkch.sel small { color: #dbeafe; } +.lkactions { margin-top: 10px; } +.lkgroups { display: flex; flex-direction: column; gap: 6px; margin-top: 12px; } +.lkgroup { --lc: var(--warn); border-left: 3px solid var(--lc); padding: 4px 0 4px 10px; background: var(--panel2); border-radius: 6px; } +.lkgroup svg { flex: none; color: var(--lc); } + +/* lock (desktop app) */ +#btn-lock { display: inline-flex; align-items: center; gap: 6px; } +#btn-lock[hidden] { display: none; } +#btn-lock.on { background: #3a2a0d; border-color: var(--warn); color: #fcd9a0; padding: 8px 12px; } +#btn-lock span { font-size: 13px; font-weight: 600; } +body.locked #main :is(button, input, select, .fader, canvas):not(.chsel, .nav, .strip-head, .xout, .band, [data-view-ok]), +body.locked #statusbar :is(button, select):not([data-view-ok]) { cursor: not-allowed; } + +/* limiter LED (outputs): orange bar under the channel name, lit while the DSP reports the limiter active */ +.limled { flex: none; display: block; width: 34px; height: 4px; margin-top: 3px; border-radius: 1px; + background: color-mix(in srgb, var(--led-o) 16%, transparent); transition: background .08s, box-shadow .08s; } +.limled.ph { visibility: hidden; } +.limled.on { background: var(--led-o); box-shadow: 0 0 6px var(--led-o), 0 0 2px var(--led-o); } +.limled.h { width: auto; height: auto; margin: 0; padding: 2px 6px; font-size: 10px; font-weight: 700; letter-spacing: .06em; + color: color-mix(in srgb, var(--led-o) 45%, transparent); } +.limled.h.on { color: #1a1000; } diff --git a/tests/test_protocol.py b/tests/test_protocol.py new file mode 100644 index 0000000..024e2e9 --- /dev/null +++ b/tests/test_protocol.py @@ -0,0 +1,127 @@ +"""Protocol self test: python tests/test_protocol.py""" + +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +from dsp import protocol as P # noqa: E402 + + +def test_frames_match_known_captures(): + # Known-good frames as sent to the devices (they also match the DSP 408 captures published by dsp-408-ui) + assert P.build_frame(0x10) == bytes.fromhex("10 02 00 01 01 10 10 03 11") + assert P.build_frame(0x40) == bytes.fromhex("10 02 00 01 01 40 10 03 41") + assert P.build_frame(0x29, b"\x13") == bytes.fromhex("10 02 00 01 02 29 13 10 03 38") + assert P.build_frame(0x35, b"\x0b\x01") == bytes.fromhex("10 02 00 01 03 35 0b 01 10 03 3c") + + +def test_parser_handles_split_and_embedded_dle(): + payload = bytes([5]) + b"\x10\x03\x10\x02" + bytes(46) + frame = P.build_frame(P.CMD_CONFIG_CHUNK, payload, addr=0, src=1) + parser = P.FrameParser() + out = parser.feed(b"\x00garbage" + frame[:7]) + parser.feed(frame[7:] + P.build_frame(0x01, b"\x00")) + assert [f.cmd for f in out] == [P.CMD_CONFIG_CHUNK, 0x01] + assert out[0].payload == payload and out[0].checksum_ok + + +def test_layout_matches_devices(): + m204, m408 = P.MODELS["204"], P.MODELS["408"] + assert (m204.size, m204.chunks) == (724, 15) + assert (m408.size, m408.chunks) == (1448, 29) + assert m204.out_base == 0x128 and m204.globals_base == 0x2B8 + assert m408.out_base == 0x240 and m408.globals_base == 0x580 + assert m204.channel("out", 0) == 2 and m408.channel("out", 0) == 4 + + +def test_state_roundtrip(): + for m in P.MODELS.values(): + st = P.default_state(m) + st["outputs"][-1]["comp"]["threshold"] = 123 + st["inputs"][0]["geq"][30] = 7 + st["inputs"][-1]["mute"] = True + assert P.parse_state(m, bytes(P.build_state_buffer(m, st))) == st + + +def test_scales(): + assert P.gain_to_db(0) == -60 and P.gain_to_db(80) == -20 and P.gain_to_db(280) == 0 and P.gain_to_db(400) == 12 + for raw in (0, 37, 80, 150, 280, 400): + assert P.db_to_gain(P.gain_to_db(raw)) == raw + assert round(P.freq_to_hz(0), 1) == 19.7 and round(P.freq_to_hz(300)) == 20159 + assert P.hz_to_freq(1000) == 170 + assert len(P.Q_TABLE) == 101 and len(P.SLOPES) == 21 + lv = [0.5, 0.0, 1.0, 0.001] + [0.25] * 8 + dec = P.decode_meters(P.encode_meters(lv)) + assert all(abs(a - b) < 1e-3 * max(a, 1e-3) for a, b in zip(lv, dec)) + + +def test_param_commands(): + m = P.MODELS["204"] + st = P.default_state(m) + out = st["outputs"][1] + P.apply_param(out, "peq.3.gain", 150) + assert P.param_command(m, "out", 1, out, "peq.3.gain") == (0x33, bytes([3, 3, 150, 0, 125, 0, 32, 0, 0])) + P.apply_param(out, "mix.1", 200) + assert P.param_command(m, "out", 1, out, "mix.1") == (0x41, bytes([3, 1, 200, 0])) + inp = st["inputs"][1] + assert P.param_command(m, "in", 1, inp, "gate.hold") == (0x3E, bytes([1, 0, 0, 99, 0, 99, 0, 0, 0])) + + +def test_links(): + # masks as read from a real DSP 204: In A+B, Out 1+2 and Out 3+4 linked + m = P.MODELS["204"] + st = P.default_state(m) + for ch, mask in zip(st["inputs"] + st["outputs"], [3, 0, 3, 0, 12, 0]): + ch["link"] = mask + st = P.parse_state(m, bytes(P.build_state_buffer(m, st))) + assert P.link_groups(st["inputs"]) == [[0, 1]] + assert P.link_groups(st["outputs"]) == [[0, 1], [2, 3]] + assert P.link_groups(P.default_state(m)["outputs"]) == [[0], [1], [2], [3]] + assert P.link_masks(4, [[0, 1], [2, 3]]) == [3, 0, 12, 0] + assert P.link_masks(4, [[3, 1]]) == [1, 10, 4, 0] + # the DSP applies a change on any member to the whole group, but not names + P.apply_command(m, st, P.CMD_GAIN, bytes([5, 100, 0])) + P.apply_command(m, st, P.CMD_CHANNEL_NAME, bytes([4]) + b"Sub ") + assert st["outputs"][2]["gain"] == 100 and st["outputs"][3]["name"] != "Sub" + + +def test_preset_import_commands(): + from dsp import preset + m = P.MODELS["204"] + cur = P.default_state(m) + assert preset.import_commands(m, cur, cur) == [] # identical: nothing is written + tgt = P.default_state(m) + tgt["outputs"][1]["gain"] = 300 + assert preset.import_commands(m, tgt, cur) == [(0x34, bytes([3]) + (300).to_bytes(2, "little"))] + tgt["outputs"][0]["link"], tgt["outputs"][1]["link"] = 3, 0 # new link: dissolve, set, relink + cmds = preset.import_commands(m, tgt, cur) + assert cmds[0][0] == P.CMD_LINK and (P.CMD_LINK, bytes([2, 3, 0])) in cmds + # a file is read with linked channels made alike, like the DSP keeps them + doc = preset.export_doc("204", "DSP204", tgt, bytes(P.build_state_buffer(m, tgt))[: m.size]) + st = preset.read_file("204", m, cur, doc=doc) + assert st["outputs"][1]["gain"] == st["outputs"][0]["gain"] == 280 + assert st["outputs"][1]["matrix"] == tgt["outputs"][1]["matrix"] # routing stays per channel + + + +def test_limit_flags(): + # status bytes after the 12 levels, captured on a DSP 204 while forcing the limiters + assert P.decode_limit_flags(bytes(36) + bytes([0x00, 0x03]), 4) == [True, True, False, False] + assert P.decode_limit_flags(bytes(36) + bytes([0x00, 0x0C]), 4) == [False, False, True, True] + assert P.decode_limit_flags(bytes(36), 4) == [False] * 4 + assert P.decode_limit_flags(P.encode_meters([0.0] * 12, 0x05), 4) == [True, False, True, False] + + + +def test_channel_names(): + # the DSP keeps 8 ASCII characters; umlauts are spelled out, anything else is dropped + assert P.clean_name("Bühne€ Links") == "Buehne L" + m = P.MODELS["204"] + assert P.param_command(m, "in", 0, {"name": "Süd"}, "name") == (0x3D, b"\x00Sued ") + + +if __name__ == "__main__": + for name, fn in list(globals().items()): + if name.startswith("test_"): + fn() + print("ok", name) diff --git a/win_disk.py b/win_disk.py new file mode 100644 index 0000000..8f7d16a --- /dev/null +++ b/win_disk.py @@ -0,0 +1,170 @@ +"""Raw SD card writing on Windows (needs administrator rights). + +Safety: only removable USB/SD/MMC disks that are neither the boot nor the system disk are offered. +The first MiB (partition table) is written last, so Windows does not mount half-written +partitions in the middle of the job - the same trick Raspberry Pi Imager uses. +""" + +import ctypes +import hashlib +import json +import lzma +import subprocess +import sys +import time +from pathlib import Path + +CHUNK = 4 << 20 # write size (multiple of the sector size) +HEAD = 1 << 20 # held back and written last +MAX_SIZE = 512 << 30 # larger "removable" disks are most likely not an SD card +NO_WINDOW = 0x08000000 if sys.platform == "win32" else 0 + + +def is_admin() -> bool: + try: + return bool(ctypes.windll.shell32.IsUserAnAdmin()) + except (AttributeError, OSError): + return False + + +def relaunch_as_admin() -> bool: + """Restart this program elevated (UAC prompt). True if the elevated copy was started.""" + argv = sys.argv[1:] if getattr(sys, "frozen", False) else sys.argv # script: python