@openmixer/plugin-qualify 0.20.1 → 0.20.3

package/tools/mod-host-admit.mjs

@@ -5,10 +5,14 @@
 // socket. Prints one JSON line, {installed, steps:[{cmd, resp | died}]}, for src/host-admission.ts to classify. The host
 // is always killed at the end, so the next plugin gets a fresh one.
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { lv2ContentParams } from "../dist/lv2-loader.js";
+
 const uri = process.argv[2];
 // the host to admit under: mod-host, or omx-clap-host for plugin-hostd's LV2 adapter, which answers the same protocol
 const bin = process.argv[3] ?? "mod-host";
@@ -70,6 +74,38 @@ function outputPorts(reply) {
   return [...reply.matchAll(/ out:[^ "]*"[^"]*":([^ ]+)/g)].flatMap((m) => m[1].split(",")).map((p) => `effect_${INSTANCE}:${p}`);
 }
 
+// a sampler or a drum machine with nothing loaded is silent by design (#318): the content it declares (a patch:writable
+// parameter of range atom:Path) is given a short sample of its own before the notes, so the note test hears the plugin
+const CONTENT_RATE = 48000;
+const CONTENT_SECONDS = 0.5;
+const CONTENT_HZ = 220;
+const CONTENT_LOAD_MS = 500;
+
+// a mono 16-bit WAV of a decaying sine: the sample a content parameter is given
+function writeContentSample(dir) {
+  const frames = Math.round(CONTENT_RATE * CONTENT_SECONDS);
+  const wav = Buffer.alloc(44 + frames * 2);
+  wav.write("RIFF", 0);
+  wav.writeUInt32LE(36 + frames * 2, 4);
+  wav.write("WAVEfmt ", 8);
+  wav.writeUInt32LE(16, 16);
+  wav.writeUInt16LE(1, 20);
+  wav.writeUInt16LE(1, 22);
+  wav.writeUInt32LE(CONTENT_RATE, 24);
+  wav.writeUInt32LE(CONTENT_RATE * 2, 28);
+  wav.writeUInt16LE(2, 32);
+  wav.writeUInt16LE(16, 34);
+  wav.write("data", 36);
+  wav.writeUInt32LE(frames * 2, 40);
+  for (let i = 0; i < frames; i++) {
+    const v = Math.sin((2 * Math.PI * CONTENT_HZ * i) / CONTENT_RATE) * Math.exp((-3 * i) / frames) * 0.5;
+    wav.writeInt16LE(Math.round(v * 32767), 44 + i * 2);
+  }
+  const path = join(dir, "plugin-qualify-content.wav");
+  writeFileSync(path, wav);
+  return path;
+}
+
 const PEAK_TOOL_DIRS = [fileURLToPath(new URL("../native/build/", import.meta.url)), "/usr/libexec/plugin-qualify/", "/usr/lib/plugin-qualify/"];
 const peakTool = () => process.env.OMX_JACK_PEAK || PEAK_TOOL_DIRS.map((d) => `${d}jack_peak`).find((p) => existsSync(p));
 
@@ -132,6 +168,23 @@ async function main() {
     // an instrument the adapter took: does a held note sound? A plugin that dies on the note dies at the remove below
     if (cmd === "remove" && bin === ADAPTER && isInstrument()) {
       const ports = outputPorts((await ask(`audio_ports ${INSTANCE}`)) ?? "");
+      let content;
+      const params = lv2ContentParams(uri, process.env);
+      if (params.length > 0) {
+        const dir = mkdtempSync(join(tmpdir(), "plugin-qualify-content-"));
+        const file = writeContentSample(dir);
+        const loaded = [];
+        const refused = [];
+        for (const param of params) {
+          const reply = await ask(`patch_set ${INSTANCE} ${param} "${file}"`);
+          const resp = reply === undefined ? undefined : Number(/resp (-?\d+)/.exec(reply)?.[1]);
+          if (resp === 0) loaded.push(param);
+          else refused.push(resp === undefined ? `${param} (no answer)` : `${param} (resp ${String(resp)})`);
+        }
+        if (loaded.length > 0) await sleep(CONTENT_LOAD_MS);
+        content = { params, loaded, ...(refused.length === 0 ? {} : { refused }) };
+        cleanups.push(() => rmSync(dir, { recursive: true, force: true }));
+      }
       sound =
         ports.length === 0
           ? { problem: "no output port" }
@@ -141,6 +194,7 @@ async function main() {
               await sleep(NOTE_WINDOW_MS);
             });
       if (sound.peak !== undefined) sound.notes = NOTE_COUNT;
+      if (content !== undefined) sound.content = content;
     }
     buffer = "";
     sock.write(`${line}\0`);
@@ -164,7 +218,9 @@ async function main() {
   return { installed: true, steps, ...(sound === undefined ? {} : { sound }) };
 }
 
+const cleanups = [];
 const result = await main();
+for (const c of cleanups) c();
 try {
   process.kill(-host.pid, "SIGKILL");
 } catch {

package/tools/scan.py

@@ -30,6 +30,7 @@ import json
 import os
 import subprocess
 import sys
+from urllib.parse import unquote, urlparse
 
 import descriptors as desc
 from lv2_presets import read_presets
@@ -142,8 +143,9 @@ def bundle_path(plugin):
     if uri is None:
         return None
     p = str(uri)
-    if p.startswith("file://"):
-        p = p[len("file://"):]
+    if p.startswith("file:"):
+        # a file: URI's path is percent-decoded, as lilv and serd read it (`My%20Plugins` is `My Plugins` on the disk)
+        p = unquote(urlparse(p).path)
     return p.rstrip("/") or None
 
 
@@ -169,6 +171,8 @@ def owning_rpm(path, run=subprocess.run):
 
 
 class Scanner:
+    refusals = ()  # (uri, code, problem, args) of each plugin the last `descriptors` refused
+
     def __init__(self):
         # lilv is imported here, not at module load: the owner mapping and the pure helpers
         # (test_scan.py) run on a host without the bindings, the way benchmark.py's worker does.
@@ -338,6 +342,10 @@ class Scanner:
         # a DECLARED fact like the comment above, read off the bundle and judged against the params
         # just read. Always present on a scanned plugin — `[]` is "ships none", never "not read".
         out["presets"] = read_presets(self.w, plugin, params)
+        # a plugin the scan refuses to describe stays listed, with its code, args and sentence (plugin-qualify#27)
+        refusal = self.port_refusal(plugin)
+        if refusal is not None:
+            out["refused"] = {"code": refusal.code, "args": refusal.code_args, "text": refusal.problem}
         # Record the latency port symbol if the plugin reports one. The actual frame
         # value is filled later by the on-rig benchmark (benchmark.py); a plugin with
         # no latency port carries no `latency` key → host treats it as unknown, not 0.
@@ -418,6 +426,10 @@ class Scanner:
         if group:
             c["group"] = group
         meaning = self.designation_meaning(port)
+        # a toggle named bypass with no designation of its own is the plugin's bypass (EQ10Q's eq1qm..eq10qm): a
+        # panel leaves it to the header, which draws one bypass per panel (plugin-qualify#27)
+        if c["kind"] == "toggle" and sym.lower() == "bypass" and meaning in ("unknown", None):
+            meaning = "bypass"
         if meaning is not None:
             c["meaning"] = meaning
         if self.has(port, PP + "notOnGUI"):
@@ -427,9 +439,18 @@ class Scanner:
         c["source"] = {"from": f"{link}#{desc.link_symbol(sym)}"}
         return c
 
+    def port_refusal(self, plugin):
+        """The refusal a plugin's ports earn before any descriptor is drawn, else None: two ports with one symbol."""
+        dup = desc.duplicate_symbol(str(plugin.get_port_by_index(i).get_symbol()) for i in range(plugin.get_num_ports()))
+        return desc.refused(desc.DESCRIPTOR_CODE_DUPLICATE_SYMBOL, symbol=dup) if dup is not None else None
+
     def descriptor(self, plugin):
-        """The plugin as a scanned descriptor, and the SHA-256 of its binary: `(doc, sha256)`."""
+        """The plugin as a scanned descriptor, and the SHA-256 of its binary: `(doc, sha256)`. A plugin whose ports
+        cannot be addressed raises its refusal (`port_refusal`): it is not repaired."""
         uri = str(plugin.get_uri())
+        refusal = self.port_refusal(plugin)
+        if refusal is not None:
+            raise refusal
         bundle = bundle_path(plugin) or ""
         lib = plugin.get_library_uri()
         lib_path = lib.get_path() if lib is not None else None
@@ -524,16 +545,19 @@ class Scanner:
         return d, sha256
 
     def descriptors(self, uris=None):
-        """`(doc, sha256)` for every plugin `scan` would describe."""
+        """`(doc, sha256)` for every plugin `scan` would describe. A plugin refused here is kept in `self.refusals`,
+        `(uri, code, problem, args)`, and reported, never silently dropped (its catalog row says why, `describe`)."""
         plugins = self.w.get_all_plugins()
         chosen = [plugins.get_by_uri(self.w.new_uri(u)) for u in uris] if uris else list(plugins)
         out = []
+        self.refusals = []
         for p in chosen:
             if p is None:
                 continue
             try:
                 out.append(self.descriptor(p))
             except desc.DescriptorRefused as e:
+                self.refusals.append((str(p.get_uri()), e.code, e.problem, e.code_args))
                 sys.stderr.write(f"descriptor refused: {p.get_uri()}: {e.code}: {e.problem}\n")
             except Exception as e:  # noqa: BLE001 - one plugin's bad data never stops the scan
                 line = e.__traceback__.tb_next.tb_lineno if e.__traceback__ and e.__traceback__.tb_next else "?"
@@ -657,7 +681,7 @@ def main():
             sys.exit(f"{e.code}: {e.problem}")
         directory = desc.descriptor_dir(args.descriptor_dir, args.system)
         written, bad = desc.write_all(directory, scanner.descriptors(args.uris or None), validator)
-        refused = len(bad)
+        refused = len(bad) + len(scanner.refusals)
         sys.stderr.write(f"wrote {len(written)} descriptors -> {directory}\n")
     text = json.dumps(catalog, indent=2, ensure_ascii=False)
     if args.out: