Files
qlcplus/simulator/artnet.py
T

215 lines
6.6 KiB
Python

"""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