215 lines
6.6 KiB
Python
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
|