Files
qlcplus/pattern_pad/engine.py
T

387 lines
13 KiB
Python

"""Corner aims, SMC-PAD input, and Art-Net output for the pattern editor."""
from __future__ import annotations
import json
import math
import re
import signal
import subprocess
import sys
import threading
import time
from dataclasses import dataclass
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SCRIPTS = ROOT / "scripts"
if str(SCRIPTS) not in sys.path:
sys.path.insert(0, str(SCRIPTS))
from cabaret_movers import ( # noqa: E402
M1_ADDR,
M2_ADDR,
ArtNetSender,
Mover,
clamp,
discover_artnet_node,
)
DEFAULT_PATH = ROOT / "shows" / "pad_pattern.json"
FOCUS_FULL = 255
# SMC-PAD preset 1. Pad 1 (bottom-left) is note 36, counting right then up.
PAD_NOTES = {
48: "front_left", # pad 13
49: "front_right", # pad 14
44: "back_left", # pad 9
45: "back_right", # pad 10
}
CC_PAN = 16 # knob 7
CC_TILT = 80 # knob 8
CC_ROTATE = 17 # knob 5
CORNERS = ("front_left", "front_right", "back_left", "back_right")
MODES = ("hold", "box", "cross", "circle", "figure8")
ROUTES = {
"box": ("front_left", "front_right", "back_right", "back_left"),
"cross": ("front_left", "back_right", "front_right", "back_left"),
"circle": ("front_left", "front_right", "back_right", "back_left"),
}
NOTE_ON_RE = re.compile(r"Note on\s+\d+,\s+note (\d+),\s+velocity (\d+)")
CC_RE = re.compile(r"Control change\s+\d+,\s+controller (\d+),\s+value (\d+)")
CLIENT_RE = re.compile(r"^client (\d+): '([^']*)'")
PORT_RE = re.compile(r"^\s+(\d+) '([^']*)'")
@dataclass
class Aim:
pan: int = 133
tilt: int = 113
rotate: int = 0
def clamped(self) -> Aim:
return Aim(clamp(self.pan), clamp(self.tilt), clamp(self.rotate))
def as_dict(self) -> dict[str, int]:
return {"pan": self.pan, "tilt": self.tilt, "rotate": self.rotate}
def encoder_delta(value: int) -> int:
"""Relative encoder step. 1..63 clockwise, 65..127 counter-clockwise."""
if value <= 0 or value == 64 or value > 127:
return 0
if value < 64:
return value
return value - 128
def lerp_aim(a: Aim, b: Aim, frac: float) -> Aim:
def mix(x: int, y: int) -> int:
return clamp(x + (y - x) * frac)
return Aim(mix(a.pan, b.pan), mix(a.tilt, b.tilt), mix(a.rotate, b.rotate))
def ease(frac: float) -> float:
return 0.5 - 0.5 * math.cos(math.pi * frac)
class Pattern:
def __init__(self, corners: dict[str, Aim]):
self.corners = corners
self.selected = "front_left"
self.mode = "hold"
self.loop_s = 6.0
self.t0 = time.monotonic()
self._lock = threading.Lock()
def select(self, name: str) -> None:
if name not in self.corners:
raise ValueError("Unknown corner")
with self._lock:
self.selected = name
self.mode = "hold"
def nudge(self, channel: str, delta: int) -> None:
if delta == 0:
return
with self._lock:
aim = self.corners[self.selected]
if channel == "pan":
aim.pan = clamp(aim.pan + delta)
elif channel == "tilt":
aim.tilt = clamp(aim.tilt + delta)
elif channel == "rotate":
aim.rotate = clamp(aim.rotate + delta)
def set_aim(self, pan: int, tilt: int, rotate: int) -> None:
with self._lock:
aim = self.corners[self.selected]
aim.pan = clamp(pan)
aim.tilt = clamp(tilt)
aim.rotate = clamp(rotate)
def play(self, mode: str) -> None:
if mode not in MODES:
raise ValueError("Unknown pattern")
with self._lock:
self.mode = mode
self.t0 = time.monotonic()
def set_loop(self, seconds: float) -> None:
with self._lock:
self.loop_s = max(0.4, float(seconds))
self.t0 = time.monotonic()
def sample(self, now: float) -> tuple[Aim, str]:
with self._lock:
if self.mode == "hold":
aim = self.corners[self.selected]
return Aim(aim.pan, aim.tilt, aim.rotate), self.selected.replace("_", " ")
if self.mode == "figure8":
return self._figure8(now), "figure of 8"
aim = self._route(now)
return aim, self._route_label
def _route(self, now: float) -> Aim:
order = ROUTES[self.mode]
u = ((now - self.t0) / self.loop_s) % 1.0
x = u * len(order)
i = int(x) % len(order)
frac = x - int(x)
if self.mode == "circle":
frac = ease(frac)
here = order[i].replace("_", " ")
nxt = order[(i + 1) % len(order)].replace("_", " ")
self._route_label = f"{here} → {nxt}"
a = self.corners[order[i]]
b = self.corners[order[(i + 1) % len(order)]]
return lerp_aim(a, b, frac)
def _figure8(self, now: float) -> Aim:
pans = [self.corners[name].pan for name in CORNERS]
tilts = [self.corners[name].tilt for name in CORNERS]
cx = (min(pans) + max(pans)) / 2.0
cy = (min(tilts) + max(tilts)) / 2.0
hw = (max(pans) - min(pans)) / 2.0
hh = (max(tilts) - min(tilts)) / 2.0
t = ((now - self.t0) / self.loop_s) % 1.0 * 2.0 * math.pi
return Aim(
clamp(cx + (-math.sin(2.0 * t)) * hw),
clamp(cy + math.cos(t) * hh),
self.corners[self.selected].rotate,
)
def snapshot(self) -> dict:
with self._lock:
return {
"corners": {name: self.corners[name].as_dict() for name in CORNERS},
"loop_s": self.loop_s,
}
def state(self, now: float) -> dict:
live, label = self.sample(now)
with self._lock:
return {
"selected": self.selected,
"mode": self.mode,
"loop_s": self.loop_s,
"label": label,
"live": live.as_dict(),
"corners": {name: self.corners[name].as_dict() for name in CORNERS},
}
def default_aim() -> Aim:
path = ROOT / "shows" / "mover_positions.json"
try:
down = json.loads(path.read_text())["positions"]["Down"]["m1"]
return Aim(int(down["pan"]), int(down["tilt"]), 0)
except (OSError, KeyError, TypeError, ValueError):
return Aim()
def load_pattern(path: Path) -> Pattern:
seed = default_aim()
corners = {name: Aim(seed.pan, seed.tilt, seed.rotate) for name in CORNERS}
loop_s = 6.0
if path.is_file():
data = json.loads(path.read_text())
loop_s = float(data.get("loop_s", loop_s))
for name in CORNERS:
raw = data.get("corners", {}).get(name, {})
corners[name] = Aim(
int(raw.get("pan", seed.pan)),
int(raw.get("tilt", seed.tilt)),
int(raw.get("rotate", 0)),
).clamped()
pattern = Pattern(corners)
pattern.loop_s = max(0.4, loop_s)
return pattern
def save_pattern(path: Path, pattern: Pattern) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(pattern.snapshot(), indent=2) + "\n")
def list_smc_ports() -> list[tuple[str, str]]:
try:
text = subprocess.check_output(["aconnect", "-l"], text=True, stderr=subprocess.DEVNULL)
except (OSError, subprocess.CalledProcessError):
return []
found: list[tuple[str, str]] = []
client_id = ""
client_name = ""
for line in text.splitlines():
client = CLIENT_RE.match(line)
if client:
client_id = client.group(1)
client_name = client.group(2)
continue
port = PORT_RE.match(line)
if not port or not client_id:
continue
label = f"{client_name} {port.group(2)}".strip()
if "smc-pad" not in label.lower() and "sinco" not in label.lower():
continue
if "private" in port.group(2).lower():
continue
found.append((f"{client_id}:{port.group(1)}", label))
return found
def parse_midi_line(line: str) -> tuple[str, int, int] | None:
note = NOTE_ON_RE.search(line)
if note and int(note.group(2)) > 0:
return ("note", int(note.group(1)), int(note.group(2)))
cc = CC_RE.search(line)
if cc:
return ("cc", int(cc.group(1)), int(cc.group(2)))
return None
class Studio:
"""Holds the pattern, sends Art-Net, and listens to the SMC-PAD."""
def __init__(self, pattern: Pattern, sender: ArtNetSender, movers: list[Mover], path: Path, midi_port: str | None, midi_label: str):
self.pattern = pattern
self.sender = sender
self.movers = movers
self.path = path
self.artnet = sender.destination()
self.midi_port = midi_port
self.midi_label = midi_label
self._running = True
self._midi: subprocess.Popen[str] | None = None
self._threads: list[threading.Thread] = []
self._seen_notes: set[int] = set()
def state(self) -> dict:
data = self.pattern.state(time.monotonic())
data["artnet"] = self.artnet
data["midi"] = self.midi_label
data["file"] = str(self.path)
return data
def apply(self, aim: Aim) -> None:
rgb = (255, 255, 255)
for mover in self.movers:
mover.apply(
pan=aim.pan,
tilt=aim.tilt,
rgb=rgb,
dimmer=255,
focus=FOCUS_FULL,
speed=0,
zoom=0,
rotate=aim.rotate,
)
def output_loop(self) -> None:
while self._running:
aim, _label = self.pattern.sample(time.monotonic())
self.apply(aim)
time.sleep(0.025)
def handle_midi(self, kind: str, number: int, value: int) -> None:
if kind == "note":
name = PAD_NOTES.get(number)
if name is None:
if number not in self._seen_notes:
self._seen_notes.add(number)
print(f"pad note {number} is not a corner", flush=True)
return
self.pattern.select(name)
return
channel = {CC_PAN: "pan", CC_TILT: "tilt", CC_ROTATE: "rotate"}.get(number)
if channel is None:
return
self.pattern.nudge(channel, encoder_delta(value))
def midi_loop(self, port: str) -> None:
self._midi = subprocess.Popen(
["aseqdump", "-p", port],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
bufsize=1,
)
assert self._midi.stdout is not None
for line in self._midi.stdout:
if not self._running:
break
parsed = parse_midi_line(line)
if parsed:
self.handle_midi(*parsed)
if self._running and self._midi.poll() not in (None, 0):
self.midi_label = "SMC-PAD disconnected"
print("MIDI input stopped. Is the SMC-PAD still connected?", flush=True)
def start(self) -> None:
out = threading.Thread(target=self.output_loop, daemon=True)
self._threads.append(out)
out.start()
if self.midi_port:
midi = threading.Thread(target=self.midi_loop, args=(self.midi_port,), daemon=True)
self._threads.append(midi)
midi.start()
def save(self) -> None:
save_pattern(self.path, self.pattern)
def close(self) -> None:
self._running = False
midi = self._midi
if midi is not None and midi.poll() is None:
midi.send_signal(signal.SIGINT)
try:
midi.wait(timeout=1.0)
except subprocess.TimeoutExpired:
midi.kill()
for thread in self._threads:
thread.join(timeout=1.0)
self.save()
self.sender.close()
def open_studio(path: Path, ip: str | None, universe: int, address: int, address2: int, midi: str | None) -> Studio:
ports = list_smc_ports()
if midi:
midi_port, midi_label = midi, midi
elif ports:
midi_port, midi_label = ports[0]
else:
midi_port, midi_label = None, "SMC-PAD not found"
pattern = load_pattern(path)
node = ip or discover_artnet_node()
sender = ArtNetSender(node, universe=universe)
movers = [Mover(sender, address, "M1"), Mover(sender, address2, "M2")]
studio = Studio(pattern, sender, movers, path, midi_port, midi_label)
print(f"Art-Net → {node} universe {universe} M1 @{address} M2 @{address2}")
print(f"MIDI {midi_label}")
print("Stop QLC+ Art-Net output first. Focus stays at 255 so rotate can spin.")
return studio