"""Art-Net receiver. Speaks ArtDMX and answers ArtPoll.""" from __future__ import annotations import socket import threading import time from collections import deque ARTNET_PORT = 6454 HEADER = b"Art-Net\x00" OP_POLL = 0x2000 OP_POLL_REPLY = 0x2100 OP_DMX = 0x5000 def build_artdmx(channels: bytes, universe: int = 0, sequence: int = 1) -> bytes: """ArtDMX packet. `channels` is the 0-based DMX frame (up to 512).""" data = bytearray(channels) n = len(data) if n < 2: data.extend(b"\x00" * (2 - n)) n = 2 if n & 1: data.append(0) n += 1 if n > 512: data = data[:512] n = 512 pkt = bytearray(18 + n) pkt[0:8] = HEADER pkt[8] = OP_DMX & 0xFF pkt[9] = (OP_DMX >> 8) & 0xFF pkt[11] = 14 pkt[12] = sequence & 0xFF pkt[14] = universe & 0xFF pkt[15] = (universe >> 8) & 0x7F pkt[16] = (n >> 8) & 0xFF pkt[17] = n & 0xFF pkt[18 : 18 + n] = data return bytes(pkt) def parse_artdmx(packet: bytes) -> tuple[int, bytes] | None: """Return (port-address, dmx) for an ArtDMX packet, else None.""" if len(packet) < 18 or not packet.startswith(HEADER): return None opcode = packet[8] | (packet[9] << 8) if opcode != OP_DMX: return None universe = packet[14] | ((packet[15] & 0x7F) << 8) length = (packet[16] << 8) | packet[17] if length < 2 or 18 + length > len(packet): return None return universe, packet[18 : 18 + length] def parse_opcode(packet: bytes) -> int | None: if len(packet) < 10 or not packet.startswith(HEADER): return None return packet[8] | (packet[9] << 8) def poll_reply(ip: str) -> bytes: """Short ArtPollReply so QLC+ can list this node.""" pkt = bytearray(239) pkt[0:8] = HEADER pkt[8] = OP_POLL_REPLY & 0xFF pkt[9] = (OP_POLL_REPLY >> 8) & 0xFF pkt[11] = 14 parts = [int(part) for part in ip.split(".")] if len(parts) != 4: parts = [127, 0, 0, 1] pkt[12:16] = bytes(parts) pkt[16] = ARTNET_PORT & 0xFF pkt[17] = (ARTNET_PORT >> 8) & 0xFF pkt[19] = 1 pkt[25] = 0xD0 short = b"Stage sim" pkt[28 : 28 + len(short)] = short long = b"QLC+ stage Art-Net simulator" pkt[46 : 46 + len(long)] = long pkt[175] = 1 pkt[176] = 0x80 pkt[184] = 0x80 return bytes(pkt) def local_ip_toward(peer: str) -> str: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: sock.connect((peer, ARTNET_PORT)) return sock.getsockname()[0] except OSError: return "127.0.0.1" finally: sock.close() class ArtNetNode: """Holds the latest DMX frame per Art-Net universe.""" def __init__(self, host: str = "0.0.0.0", port: int = ARTNET_PORT): self.host = host self.port = port self._lock = threading.Lock() self._universes: dict[int, bytearray] = {} self.packets = 0 self._times: deque[float] = deque() self.last_rx = 0.0 self.last_universe: int | None = None self._sock: socket.socket | None = None self._running = False self._thread: threading.Thread | None = None self._announced = False def start(self) -> None: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) if hasattr(socket, "SO_REUSEPORT"): sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) try: sock.bind((self.host, self.port)) except OSError as exc: sock.close() raise OSError( f"Cannot listen for Art-Net on {self.host}:{self.port} ({exc}). " "Close the other program using that port, or pass --artnet-port." ) from exc sock.settimeout(0.5) self._sock = sock self._running = True self._thread = threading.Thread(target=self._loop, name="artnet", daemon=True) self._thread.start() def close(self) -> None: self._running = False sock = self._sock if sock is not None: try: sock.close() except OSError: pass if self._thread is not None: self._thread.join(timeout=1.5) def write(self, universe: int, data: bytes) -> None: with self._lock: buf = self._universes.get(universe) if buf is None: buf = bytearray(512) self._universes[universe] = buf n = min(512, len(data)) buf[:n] = data[:n] if n < 512: buf[n:] = b"\x00" * (512 - n) now = time.monotonic() self.packets += 1 self.last_rx = now self.last_universe = universe self._times.append(now) def snapshot(self) -> dict[int, bytes]: with self._lock: return {universe: bytes(buf) for universe, buf in self._universes.items()} def stats(self) -> dict: now = time.monotonic() with self._lock: while self._times and now - self._times[0] > 1.0: self._times.popleft() age = None if self.last_rx == 0 else now - self.last_rx return { "packets": self.packets, "rate": len(self._times), "age": None if age is None else round(age, 3), "universe": self.last_universe, "listen": f"{self.host}:{self.port}", } def _loop(self) -> None: sock = self._sock assert sock is not None while self._running: try: packet, addr = sock.recvfrom(2048) except TimeoutError: continue except OSError: break self._handle(packet, addr) def _handle(self, packet: bytes, addr: tuple) -> None: opcode = parse_opcode(packet) if opcode == OP_DMX: parsed = parse_artdmx(packet) if parsed is None: return universe, data = parsed self.write(universe, data) if not self._announced: self._announced = True print( f"Art-Net DMX from {addr[0]}:{addr[1]} " f"universe {universe} ({len(data)} channels)", flush=True, ) return if opcode == OP_POLL and self._sock is not None: ip = local_ip_toward(addr[0]) try: self._sock.sendto(poll_reply(ip), (addr[0], ARTNET_PORT)) except OSError: pass