Files

264 lines
9.6 KiB
Python

"""Locate and read QLC+ fixture definitions (.qxf) and work out which channels
in a mode are pan / tilt / dimmer / shutter / colour.
"""
from __future__ import annotations
import os
import re
import xml.etree.ElementTree as ET
from dataclasses import dataclass, field
from functools import lru_cache
from pathlib import Path
NS = {"q": "http://www.qlcplus.org/FixtureDefinition"}
DIMMER_PRESETS = {"IntensityMasterDimmer", "IntensityDimmer"}
WHITE_PRESETS = {"IntensityWhite"}
RGB_PRESETS = ("IntensityRed", "IntensityGreen", "IntensityBlue")
@dataclass
class ChannelInfo:
index: int
name: str
preset: str | None
group: str | None
byte: int
shutter_open: int | None = None # DMX value that opens the shutter, if a shutter channel
@dataclass
class ModeInfo:
name: str
channels: list[ChannelInfo]
pan_msb: int | None = None
pan_lsb: int | None = None
tilt_msb: int | None = None
tilt_lsb: int | None = None
dimmers: list[int] = field(default_factory=list)
shutters: list[tuple[int, int]] = field(default_factory=list) # (channel, open value)
whites: list[int] = field(default_factory=list)
reds: list[int] = field(default_factory=list)
greens: list[int] = field(default_factory=list)
blues: list[int] = field(default_factory=list)
@property
def is_mover(self) -> bool:
return self.pan_msb is not None and self.tilt_msb is not None
def preview_channels(self) -> dict[int, int]:
"""Channel values that make the head visibly lit (white, open, full)."""
ch: dict[int, int] = {}
for d in self.dimmers:
ch[d] = 255
for s, v in self.shutters:
ch[s] = v
if self.whites:
for w in self.whites:
ch[w] = 255
else:
for c in self.reds + self.greens + self.blues:
ch[c] = 255
if not self.dimmers and not self.whites and not self.reds:
# Nothing we recognise as intensity — fall back to every Intensity-group channel.
for c in self.channels:
if c.group == "Intensity" or (c.preset or "").startswith("Intensity"):
ch[c.index] = 255
return ch
def to_dict(self) -> dict:
return {
"name": self.name,
"channel_count": len(self.channels),
"pan_msb": self.pan_msb,
"pan_lsb": self.pan_lsb,
"tilt_msb": self.tilt_msb,
"tilt_lsb": self.tilt_lsb,
"dimmers": self.dimmers,
"channels": [{"index": c.index, "name": c.name, "preset": c.preset, "group": c.group} for c in self.channels],
}
@dataclass
class FixtureDef:
path: Path
manufacturer: str
model: str
type: str
pan_max: int
tilt_max: int
modes: dict[str, ModeInfo]
def mode(self, name: str) -> ModeInfo | None:
if name in self.modes:
return self.modes[name]
# QLC+ sometimes stores "43 Channel" vs "43 Channel Mode" etc. — be lenient.
key = name.strip().lower()
for k, v in self.modes.items():
if k.strip().lower() == key:
return v
return None
# ----------------------------------------------------------------------------- parse
def _text(el: ET.Element | None, default: str = "") -> str:
return (el.text or default) if el is not None else default
def _parse_channel(el: ET.Element) -> ChannelInfo:
name = el.get("Name", "")
preset = el.get("Preset")
group_el = el.find("q:Group", NS)
group = _text(group_el) if group_el is not None else None
byte = int(group_el.get("Byte", "0")) if group_el is not None else 0
if preset and group is None:
# Presets imply the group; the ones we care about:
if preset.startswith("Position"):
group = "Pan" if "Pan" in preset else "Tilt"
elif preset.startswith("Intensity"):
group = "Intensity"
elif preset.startswith("Shutter") or preset.startswith("Strobe"):
group = "Shutter"
if preset.endswith("Fine"):
byte = 1
shutter_open = None
if group == "Shutter" or (preset or "").startswith("Shutter"):
caps = el.findall("q:Capability", NS)
if (preset or "").startswith("Shutter") and not caps:
shutter_open = 0 # QLC+ built-in shutter presets all start with "Open"
for cap in caps:
cp = cap.get("Preset", "")
label = (cap.text or "").strip().lower()
if cp == "ShutterOpen" or (not cp and label in ("open", "shutter open", "no function")):
shutter_open = int(cap.get("Min", "0"))
break
return ChannelInfo(index=-1, name=name, preset=preset, group=group, byte=byte, shutter_open=shutter_open)
def _resolve_mode(name: str, chans: list[ChannelInfo]) -> ModeInfo:
m = ModeInfo(name=name, channels=chans)
for c in chans:
p = c.preset or ""
if c.group == "Pan" or p in ("PositionPan", "PositionPanFine"):
if c.byte == 1 or p.endswith("Fine"):
m.pan_lsb = m.pan_lsb if m.pan_lsb is not None else c.index
else:
m.pan_msb = m.pan_msb if m.pan_msb is not None else c.index
elif c.group == "Tilt" or p in ("PositionTilt", "PositionTiltFine"):
if c.byte == 1 or p.endswith("Fine"):
m.tilt_lsb = m.tilt_lsb if m.tilt_lsb is not None else c.index
else:
m.tilt_msb = m.tilt_msb if m.tilt_msb is not None else c.index
elif p in DIMMER_PRESETS:
m.dimmers.append(c.index)
elif p in WHITE_PRESETS:
m.whites.append(c.index)
elif p == RGB_PRESETS[0]:
m.reds.append(c.index)
elif p == RGB_PRESETS[1]:
m.greens.append(c.index)
elif p == RGB_PRESETS[2]:
m.blues.append(c.index)
elif c.group == "Intensity" and not p:
lname = c.name.lower()
if "dimmer" in lname or "master" in lname or "bright" in lname:
m.dimmers.append(c.index)
if c.shutter_open is not None:
m.shutters.append((c.index, c.shutter_open))
return m
@lru_cache(maxsize=256)
def load_fixture_def(path: str) -> FixtureDef:
root = ET.parse(path).getroot()
channels: dict[str, ChannelInfo] = {}
for el in root.findall("q:Channel", NS):
ci = _parse_channel(el)
channels[ci.name] = ci
phys = root.find("q:Physical", NS)
focus = phys.find("q:Focus", NS) if phys is not None else None
pan_max = int(focus.get("PanMax", "0")) if focus is not None else 0
tilt_max = int(focus.get("TiltMax", "0")) if focus is not None else 0
modes: dict[str, ModeInfo] = {}
for mode_el in root.findall("q:Mode", NS):
name = mode_el.get("Name", "")
chans: list[ChannelInfo] = []
for ch_el in mode_el.findall("q:Channel", NS):
base = channels.get((ch_el.text or "").strip())
if base is None:
continue
ci = ChannelInfo(**{**base.__dict__, "index": int(ch_el.get("Number", len(chans)))})
chans.append(ci)
chans.sort(key=lambda c: c.index)
modes[name] = _resolve_mode(name, chans)
return FixtureDef(
path=Path(path),
manufacturer=_text(root.find("q:Manufacturer", NS)),
model=_text(root.find("q:Model", NS)),
type=_text(root.find("q:Type", NS)),
pan_max=pan_max,
tilt_max=tilt_max,
modes=modes,
)
# ----------------------------------------------------------------------------- locate
_HEAD_RE = re.compile(
rb"<Manufacturer>(.*?)</Manufacturer>.*?<Model>(.*?)</Model>", re.S
)
class FixtureLibrary:
"""Index of (manufacturer, model) → .qxf path across the usual search dirs."""
def __init__(self, project_root: Path, extra_dirs: list[Path] | None = None):
self.dirs: list[Path] = [project_root / "fixtures"]
self.dirs += extra_dirs or []
self.dirs.append(Path.home() / ".qlcplus" / "fixtures")
for d in ("/usr/share/qlcplus/fixtures", "/usr/local/share/qlcplus/fixtures"):
self.dirs.append(Path(d))
self._index: dict[tuple[str, str], Path] | None = None
def _build_index(self) -> dict[tuple[str, str], Path]:
idx: dict[tuple[str, str], Path] = {}
for d in self.dirs:
if not d.is_dir():
continue
for dirpath, _dirs, files in os.walk(d):
for fn in files:
if not fn.endswith(".qxf"):
continue
p = Path(dirpath) / fn
try:
with open(p, "rb") as fh:
head = fh.read(4096)
except OSError:
continue
m = _HEAD_RE.search(head)
if not m:
continue
key = (_unesc(m.group(1)).strip().lower(), _unesc(m.group(2)).strip().lower())
idx.setdefault(key, p) # first dir wins (project fixtures override system)
return idx
def find(self, manufacturer: str, model: str) -> FixtureDef | None:
if self._index is None:
self._index = self._build_index()
p = self._index.get((manufacturer.strip().lower(), model.strip().lower()))
if p is None:
return None
try:
return load_fixture_def(str(p))
except ET.ParseError:
return None
def _unesc(b: bytes) -> str:
s = b.decode("utf-8", "replace")
return s.replace("&amp;", "&").replace("&lt;", "<").replace("&gt;", ">").replace("&quot;", '"').replace("&apos;", "'")