@jamezjb/node-red-ndi-preview 0.0.0-stage → 0.1.1

package/lib/vendor/jpeg-js.LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2014, Eugene Ware
+All rights reserved.
+  
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:  
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.  
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.  
+3. Neither the name of Eugene Ware nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.  
+  
+THIS SOFTWARE IS PROVIDED BY EUGENE WARE ''AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL EUGENE WARE BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/nodes/ndi-live.html

@@ -0,0 +1,101 @@
+<script type="text/javascript">
+  RED.nodes.registerType("ndi-live", {
+    category: "network",
+    color: "#3BC3AB",
+    defaults: {
+      name: { value: "" },
+      source: { value: "" },
+      address: { value: "" },
+      fps: { value: 10, validate: RED.validators.number() },
+      width: { value: 640, validate: RED.validators.number() },
+      quality: { value: 60, validate: RED.validators.number() },
+      bandwidth: { value: "lowest" },
+      maxViewers: { value: 4, validate: RED.validators.number() },
+      timeout: { value: 5, validate: RED.validators.number() },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "font-awesome/fa-video-camera",
+    paletteLabel: "ndi live",
+    label: function () { return this.name || this.source || this.address || "ndi live"; },
+    oneditprepare: function () {
+      // NdiPreviewEditor comes from the ndi-thumbnail editor file, which Node-RED loads with this one.
+      if (window.NdiPreviewEditor) {
+        NdiPreviewEditor.runtimeBanner($("#ndi-live-runtime"));
+        NdiPreviewEditor.sourcePicker($("#ndi-live-find"), $("#ndi-live-found"), $("#node-input-source"));
+      }
+      $("#ndi-live-url").text("ndi-live/" + this.id + ".mjpg");
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="ndi-live">
+  <div class="form-row" id="ndi-live-runtime">Checking for the NDI Runtime…</div>
+  <div class="form-row"><label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name"></div>
+  <div class="form-row"><label for="node-input-source"><i class="fa fa-video-camera"></i> Source</label>
+    <input type="text" id="node-input-source" placeholder="COMPUTER (Source name)"></div>
+  <div class="form-row"><label></label>
+    <button type="button" class="red-ui-button" id="ndi-live-find">Find sources</button>
+    <select id="ndi-live-found" style="width:60%"></select></div>
+  <div class="form-row"><label for="node-input-address"><i class="fa fa-plug"></i> Address</label>
+    <input type="text" id="node-input-address" placeholder="optional ip:port, to connect without discovery"></div>
+  <div class="form-row"><label for="node-input-fps"><i class="fa fa-film"></i> Frame rate</label>
+    <input type="text" id="node-input-fps" style="width:50px"> per second <span style="opacity:.7">(1–15)</span></div>
+  <div class="form-row"><label for="node-input-width"><i class="fa fa-arrows-h"></i> Width</label>
+    <input type="text" id="node-input-width" style="width:60px"> px &nbsp; Quality
+    <input type="text" id="node-input-quality" style="width:50px"></div>
+  <div class="form-row"><label for="node-input-bandwidth"><i class="fa fa-tachometer"></i> Stream</label>
+    <select id="node-input-bandwidth">
+      <option value="lowest">Proxy (lowest bandwidth)</option>
+      <option value="highest">Full (highest bandwidth: much more network traffic)</option></select></div>
+  <div class="form-row"><label for="node-input-maxViewers"><i class="fa fa-users"></i> Viewers</label>
+    <input type="text" id="node-input-maxViewers" style="width:50px"> at most &nbsp; Timeout
+    <input type="text" id="node-input-timeout" style="width:50px"> s</div>
+  <div class="form-row"><label><i class="fa fa-link"></i> Preview at</label>
+    <code id="ndi-live-url"></code> <span style="opacity:.7">(under Node-RED's HTTP node path)</span></div>
+  <div class="form-tips">Anyone who can reach Node-RED's HTTP endpoints can watch this preview. Protect them with
+    <code>httpNodeAuth</code> if that matters.<br>
+    NDI® is a registered trademark of Vizrt NDI AB. More about NDI:
+    <a href="https://ndi.video/" target="_blank" rel="noopener">ndi.video</a>.</div>
+</script>
+
+<script type="text/html" data-help-name="ndi-live">
+  <p>A silent, low-latency live preview of one NDI® source, for checking a picture in a browser. It is a preview,
+    not a programme monitor: a few frames a second, no sound.</p>
+  <p><b>Needs the NDI Runtime on the Node-RED computer.</b> Install the NDI 6 Runtime (or NDI Tools) from
+    <a href="https://ndi.video/tools/">ndi.video</a>, then restart Node-RED. This node does not include NDI. It runs on
+    macOS and on Windows x64.</p>
+  <h3>Where to watch</h3>
+  <p>The node serves the picture on Node-RED's HTTP node server (the same place as <i>http in</i> nodes):</p>
+  <ul>
+    <li><code>ndi-live/&lt;node id&gt;.mjpg</code>: the live picture. Show it with <code>&lt;img src="…"&gt;</code>
+      in any browser or dashboard template.</li>
+    <li><code>ndi-live/&lt;node id&gt;.jpg</code>: one still of the same picture.</li>
+  </ul>
+  <p>The connection to the source opens when the first viewer starts watching and closes a few seconds after the
+    last one stops, so an unwatched preview uses no network and no processor time. Each frame is encoded once for
+    all viewers. A viewer on a slow connection skips frames instead of falling behind.</p>
+  <p>The endpoints are protected by <code>httpNodeAuth</code> if your Node-RED settings set it; without it, anyone
+    who can reach Node-RED can watch.</p>
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">any</span></dt>
+    <dd><code>"stop"</code> or <code>false</code> ends every viewer and refuses new ones; <code>"start"</code> or
+      <code>true</code> allows them again. Any message is answered with the output below.</dd>
+  </dl>
+  <h3>Outputs</h3>
+  <p>When the flow starts, whenever what the node knows about the NDI Runtime changes, and for each input:</p>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">string</span></dt><dd>the path of the live picture.</dd>
+    <dt>ndi <span class="property-type">object</span></dt>
+    <dd><code>{source, stream, still, viewers, live, paused, maxViewers, fps, width, bandwidth, runtime}</code>, and
+      <code>error</code> when the preview cannot work (no NDI Runtime, or the NDI helper has stopped).
+      <code>runtime</code> is the runtime's version, or <code>null</code> when there is none yet; <code>null</code>
+      with no <code>error</code> means it is still being checked.</dd>
+  </dl>
+  <h3>Details</h3>
+  <p><i>Proxy</i> asks the sender for its low-bandwidth stream; <i>Full</i> can put over 100 Mb/s per camera on the
+    network. The node never sets tally. Nodes that show the same source share one connection to it.</p>
+  <p>NDI® is a registered trademark of Vizrt NDI AB. <a href="https://ndi.video/">ndi.video</a></p>
+</script>

package/nodes/ndi-live.js

@@ -0,0 +1,249 @@
+"use strict";
+// ndi-live: a silent, low-latency live preview of an NDI source, served as Motion-JPEG over HTTP so a plain
+// <img src="..."> shows it in any browser. It is a preview for checking a picture, not a programme monitor.
+//
+//   GET <httpNodeRoot>/ndi-live/<node id>.mjpg   the live picture (multipart/x-mixed-replace)
+//   GET <httpNodeRoot>/ndi-live/<node id>.jpg    one still of the same picture
+//
+// The NDI receiver runs only while someone is watching: the first viewer starts it, and it stops a few seconds
+// after the last viewer leaves. Each frame is encoded once (in the NDI host process) and the same bytes go to every
+// viewer; a viewer that falls behind skips frames instead of building a queue.
+// These endpoints sit on Node-RED's normal HTTP node server, so httpNodeAuth (if set) protects them too.
+const { getClient } = require("../lib/host-client");
+const { registerAdmin, watchRuntime, statusForRuntime, CHECKING } = require("../lib/admin");
+
+const BOUNDARY = "ndipreviewframe";
+const STOP_GRACE_MS = 5000;
+const FRESH_MS = 2000;
+const STUCK_MS = 10000;          // a viewer that has not taken a frame for this long is disconnected
+const HOST_STOPPED = "the NDI helper has stopped; restart Node-RED";
+const liveNodes = new Map();
+let routed = false;
+
+function joinUrl(root, rest) {
+  const r = typeof root === "string" ? root : "/";
+  return (r.endsWith("/") ? r : r + "/") + rest;
+}
+
+module.exports = function (RED) {
+  registerAdmin(RED);
+
+  if (!routed && RED.httpNode) {
+    routed = true;
+    RED.httpNode.get("/ndi-live/:file", (req, res) => {
+      const m = /^([A-Za-z0-9_.-]{1,64})\.(mjpg|jpg)$/.exec(req.params.file || "");   // older flows have dotted ids
+      const n = m && liveNodes.get(m[1]);
+      if (!n) { res.status(404).type("text/plain").send("No NDI live preview with that id is deployed."); return; }
+      if (m[2] === "mjpg") n.serveStream(req, res); else n.serveStill(req, res);
+    });
+  }
+
+  function NdiLiveNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const client = getClient(RED);
+    const source = { name: config.source || "", address: config.address || "" };
+    const bandwidth = config.bandwidth === "highest" ? "highest" : "lowest";
+    const fps = Math.max(1, Math.min(15, Math.round(Number(config.fps) || 10)));
+    const width = Math.max(32, Math.min(1280, Number(config.width) || 640));
+    const quality = Math.max(10, Math.min(95, Number(config.quality) || 60));
+    const maxViewers = Math.max(1, Math.min(32, Math.round(Number(config.maxViewers) || 4)));
+    const timeoutMs = Math.max(1000, (Number(config.timeout) || 5) * 1000);
+    const label = "Node-RED " + (config.name || "NDI Preview") + " (live preview)";
+    const streamUrl = joinUrl(RED.settings.httpNodeRoot, `ndi-live/${node.id}.mjpg`);
+    const stillUrl = joinUrl(RED.settings.httpNodeRoot, `ndi-live/${node.id}.jpg`);
+
+    const viewers = new Set();
+    let rt = null, streaming = false, paused = false, closed = false, stopTimer = null, hostFailed = false;
+    let stillPending = null;               // one still grab at a time, shared by every .jpg request
+    let last = null;                       // { jpeg, meta, at }
+    let state = "idle", stateError = null;
+    let frameTimes = [];
+    let statusTimer = null;
+
+    function measuredFps() {
+      const now = Date.now();
+      frameTimes = frameTimes.filter((t) => now - t < 2000);
+      return Math.round(frameTimes.length / 2);
+    }
+
+    function showStatus() {
+      if (closed) return;
+      if (hostFailed) { node.status(statusForRuntime({ ok: false, host: true, failed: true })); return; }
+      if (rt && !rt.ok) { node.status(statusForRuntime(rt)); return; }
+      if (!RED.httpNode) { node.status({ fill: "red", shape: "ring", text: "HTTP endpoints are off (httpNodeRoot)" }); return; }
+      if (!source.name && !source.address) { node.status({ fill: "grey", shape: "ring", text: "no source set" }); return; }
+      if (paused) { node.status({ fill: "grey", shape: "ring", text: "paused" }); return; }
+      const v = `${viewers.size} viewer${viewers.size === 1 ? "" : "s"}`;
+      if (!streaming) { node.status({ fill: "grey", shape: "ring", text: `idle · ${v}` }); return; }
+      if (state === "novideo" || state === "error") { node.status({ fill: "red", shape: "ring", text: `${(stateError || "no video").slice(0, 40)} · ${v}` }); return; }
+      if (state === "live") { node.status({ fill: "green", shape: "dot", text: `live · ${v} · ${measuredFps()} fps` }); return; }
+      node.status({ fill: "blue", shape: "ring", text: `connecting · ${v}` });
+    }
+
+    function info() {
+      const error = hostFailed ? HOST_STOPPED : rt && !rt.ok ? rt.error : null;
+      return {
+        payload: streamUrl,
+        ndi: {
+          source: source.name || source.address, stream: streamUrl, still: stillUrl, viewers: viewers.size,
+          live: streaming, paused, maxViewers, fps, width, bandwidth, runtime: rt ? rt.version || null : null,
+          ...(error ? { error } : {}),
+        },
+      };
+    }
+
+    // The node sends info() when the flow starts, and again whenever what it says about the NDI Runtime changes
+    // (for example the helper answered late, or stopped), so a flow showing it never keeps a stale answer.
+    let announced = null;
+    function announce() {
+      if (closed) return;
+      const { runtime, error } = info().ndi;
+      const key = JSON.stringify([runtime, error || null]);
+      if (key === announced) return;
+      announced = key;
+      node.send(info());
+    }
+
+    function startStream() {
+      clearTimeout(stopTimer); stopTimer = null;
+      if (streaming || paused || closed) return;
+      streaming = true; state = "starting"; stateError = null;
+      if (!statusTimer) { statusTimer = setInterval(showStatus, 1000); statusTimer.unref?.(); }
+      showStatus();
+      client.liveStart(node.id, { source, bandwidth, fps, width, quality, label, timeoutMs }).catch((e) => {
+        if (closed) return;
+        if (e.code === "ENORUNTIME") { rt = { ok: false, error: e.message }; announce(); }
+        node.warn(`NDI live "${source.name || source.address}": ${e.message}`);
+        stopStream();
+        endViewers();
+      });
+    }
+
+    function stopStream() {
+      clearTimeout(stopTimer); stopTimer = null;
+      clearInterval(statusTimer); statusTimer = null;
+      if (streaming) { streaming = false; client.liveStop(node.id); }
+      state = "idle";
+      showStatus();
+    }
+
+    function endViewers() {
+      for (const res of viewers) { try { res.end(); } catch (e) { /* already gone */ } }
+      viewers.clear();
+      showStatus();
+    }
+
+    function writeFrame(res, jpeg) {
+      if (res.writableNeedDrain) {                        // this viewer is behind: skip, never queue
+        if (!res.stuckSince) res.stuckSince = Date.now();
+        else if (Date.now() - res.stuckSince > STUCK_MS) res.destroy();   // gone quiet: free its place
+        return;
+      }
+      res.stuckSince = 0;
+      res.write(`--${BOUNDARY}\r\nContent-Type: image/jpeg\r\nContent-Length: ${jpeg.length}\r\n\r\n`);
+      res.write(jpeg);
+      res.write("\r\n");
+    }
+
+    function onFrame(stream, jpeg, meta) {
+      if (stream !== node.id || closed) return;
+      last = { jpeg, meta, at: Date.now() };
+      frameTimes.push(last.at);
+      for (const res of viewers) writeFrame(res, jpeg);
+    }
+    function onLiveStatus(stream, s, error) {
+      if (stream !== node.id || closed) return;
+      state = s; stateError = error;
+      if (s === "novideo" || s === "error") node.warn(`NDI live "${source.name || source.address}": ${error}`);
+      showStatus();
+    }
+    function onHostState(s, why) {
+      if (closed) return;
+      if (s === "failed") { hostFailed = true; node.error(why); stopStream(); endViewers(); announce(); }
+    }
+    client.on("frame", onFrame);
+    client.on("liveStatus", onLiveStatus);
+    client.on("state", onHostState);
+
+    function refuse(res, code, text) {
+      res.status(code).set({ "Cache-Control": "no-store", "Retry-After": "5" }).type("text/plain").send(text);
+    }
+
+    node.serveStream = (req, res) => {
+      if (hostFailed) { refuse(res, 503, "The NDI helper has stopped; restart Node-RED."); return; }
+      if (paused) { refuse(res, 503, "This NDI live preview is paused."); return; }
+      if (rt && !rt.ok) { refuse(res, 503, "The NDI Runtime is not installed on the Node-RED computer (see ndi.video)."); return; }
+      if (!source.name && !source.address) { refuse(res, 503, "No NDI source is set."); return; }
+      if (viewers.size >= maxViewers) { refuse(res, 503, `This NDI live preview already has ${maxViewers} viewers.`); return; }
+      res.writeHead(200, {
+        "Content-Type": `multipart/x-mixed-replace; boundary=${BOUNDARY}`,
+        "Cache-Control": "no-store, no-cache, must-revalidate",
+        Pragma: "no-cache",
+        Connection: "close",
+        "X-Content-Type-Options": "nosniff",
+      });
+      viewers.add(res);
+      const gone = () => {
+        if (!viewers.delete(res)) return;
+        showStatus();
+        if (!viewers.size && streaming && !stopTimer) { stopTimer = setTimeout(stopStream, STOP_GRACE_MS); stopTimer.unref?.(); }
+      };
+      res.on("close", gone);
+      res.on("error", gone);
+      startStream();
+      if (last && Date.now() - last.at < FRESH_MS) writeFrame(res, last.jpeg);
+      showStatus();
+    };
+
+    node.serveStill = async (req, res) => {
+      if (hostFailed) { refuse(res, 503, "The NDI helper has stopped; restart Node-RED."); return; }
+      if (paused) { refuse(res, 503, "This NDI live preview is paused."); return; }
+      const send = (jpeg) => res.status(200).set({ "Content-Type": "image/jpeg", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" }).send(jpeg);
+      if (last && Date.now() - last.at < FRESH_MS) { send(last.jpeg); return; }
+      try {
+        // many requests at once share one grab, so a burst of stills cannot queue up work in the NDI helper
+        if (!stillPending) {
+          stillPending = client.grab({ owner: node.id + ":still", source, bandwidth, width, quality, timeoutMs, idleMs: STOP_GRACE_MS, label })
+            .finally(() => { stillPending = null; });
+        }
+        const r = await stillPending;
+        send(r.jpeg);
+      } catch (e) {
+        refuse(res, 503, `No picture: ${e.message}`);
+      }
+    };
+
+    node.on("input", (msg, send, done) => {
+      const cmd = typeof msg.payload === "string" ? msg.payload.trim().toLowerCase() : "";
+      if (cmd === "stop" || msg.payload === false) { paused = true; endViewers(); stopStream(); client.drop(node.id + ":still"); }
+      else if (cmd === "start" || msg.payload === true) { paused = false; showStatus(); }
+      send({ ...RED.util.cloneMessage(msg), ...info() });
+      done();
+    });
+
+    node.on("close", (removed, done) => {
+      closed = true;
+      liveNodes.delete(node.id);
+      client.off("frame", onFrame);
+      client.off("liveStatus", onLiveStatus);
+      client.off("state", onHostState);
+      clearTimeout(stopTimer); clearInterval(statusTimer);
+      for (const res of viewers) { try { res.end(); } catch (e) { /* already gone */ } }
+      viewers.clear();
+      const stops = [streaming ? client.liveStop(node.id) : null, client.drop(node.id + ":still")];
+      Promise.all(stops).then(() => done(), () => done());
+    });
+
+    liveNodes.set(node.id, node);
+    node.status(CHECKING);
+    watchRuntime(RED, () => closed, (r) => {
+      if (r.ok || !r.host || r.failed) rt = r;               // a host hiccup is not final: it is checked again
+      if (r.failed) hostFailed = true;
+      if (!r.ok && r.host && !r.failed) node.status(statusForRuntime(r)); else showStatus();
+      announce();                                            // tells the flow where the preview is
+    });
+  }
+
+  RED.nodes.registerType("ndi-live", NdiLiveNode);
+};

package/nodes/ndi-thumbnail.html

@@ -0,0 +1,126 @@
+<script type="text/javascript">
+  (function () {
+    // Shared by both NDI preview nodes: the runtime banner and the "Find sources" picker.
+    window.NdiPreviewEditor = window.NdiPreviewEditor || {
+      runtimeBanner: function (el) {
+        function show(rt) {
+          if (rt.ok) { el.text("NDI Runtime " + rt.version).css({ opacity: 0.7, color: "" }); return; }
+          var text = rt.unsupported ? $("<span>").text(rt.error + ".")
+            : $("<span>").append("<b>The NDI Runtime is not installed on the Node-RED computer.</b> Install the NDI 6 Runtime " +
+              '(or NDI Tools) from <a href="https://ndi.video/tools/" target="_blank" rel="noopener">ndi.video</a>, then restart ' +
+              "Node-RED. These nodes do not include NDI. ")
+              .append($('<a href="#">').text("Check again").on("click", function (e) { e.preventDefault(); load("?refresh=1"); }));
+          el.empty().append(text).css({ opacity: 1, color: "var(--red-ui-text-color-error, #c00)" });
+        }
+        function load(q) {
+          el.text("Checking for the NDI Runtime…");
+          $.getJSON("ndi-preview/runtime" + (q || "")).done(show).fail(function () { el.text("Could not check for the NDI Runtime."); });
+        }
+        load("");
+      },
+      sourcePicker: function (button, select, input) {
+        button.on("click", function () {
+          select.empty().append($("<option>").text("Searching…"));
+          $.getJSON("ndi-preview/sources").done(function (list) {
+            select.empty().append($("<option>").val("").text(list.length ? "Pick a source…" : "No NDI sources found"));
+            list.forEach(function (s) {
+              select.append($("<option>").val(s.name).text(s.name + (s.address ? "  (" + s.address + ")" : "")));
+            });
+          }).fail(function (x) {
+            var msg = (x.responseJSON && x.responseJSON.error) || "search failed";
+            select.empty().append($("<option>").val("").text("Search failed: " + msg));
+          });
+        });
+        select.on("change", function () { if (this.value) input.val(this.value); });
+      },
+    };
+  })();
+
+  RED.nodes.registerType("ndi-thumbnail", {
+    category: "network",
+    color: "#3BC3AB",
+    defaults: {
+      name: { value: "" },
+      source: { value: "" },
+      address: { value: "" },
+      interval: { value: 5, validate: RED.validators.number(true) },
+      width: { value: 320, validate: RED.validators.number() },
+      quality: { value: 70, validate: RED.validators.number() },
+      bandwidth: { value: "lowest" },
+      idle: { value: 30, validate: RED.validators.number(true) },
+      timeout: { value: 3, validate: RED.validators.number() },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "font-awesome/fa-camera",
+    paletteLabel: "ndi thumbnail",
+    label: function () { return this.name || this.source || this.address || "ndi thumbnail"; },
+    oneditprepare: function () {
+      NdiPreviewEditor.runtimeBanner($("#ndi-thumb-runtime"));
+      NdiPreviewEditor.sourcePicker($("#ndi-thumb-find"), $("#ndi-thumb-found"), $("#node-input-source"));
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="ndi-thumbnail">
+  <div class="form-row" id="ndi-thumb-runtime">Checking for the NDI Runtime…</div>
+  <div class="form-row"><label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name"></div>
+  <div class="form-row"><label for="node-input-source"><i class="fa fa-video-camera"></i> Source</label>
+    <input type="text" id="node-input-source" placeholder="COMPUTER (Source name)"></div>
+  <div class="form-row"><label></label>
+    <button type="button" class="red-ui-button" id="ndi-thumb-find">Find sources</button>
+    <select id="ndi-thumb-found" style="width:60%"></select></div>
+  <div class="form-row"><label for="node-input-address"><i class="fa fa-plug"></i> Address</label>
+    <input type="text" id="node-input-address" placeholder="optional ip:port, to connect without discovery"></div>
+  <div class="form-row"><label for="node-input-interval"><i class="fa fa-clock-o"></i> Every</label>
+    <input type="text" id="node-input-interval" style="width:60px"> s <span style="opacity:.7">(0 = only when a message arrives)</span></div>
+  <div class="form-row"><label for="node-input-width"><i class="fa fa-arrows-h"></i> Width</label>
+    <input type="text" id="node-input-width" style="width:60px"> px &nbsp; Quality
+    <input type="text" id="node-input-quality" style="width:50px"></div>
+  <div class="form-row"><label for="node-input-bandwidth"><i class="fa fa-tachometer"></i> Stream</label>
+    <select id="node-input-bandwidth">
+      <option value="lowest">Proxy (lowest bandwidth)</option>
+      <option value="highest">Full (highest bandwidth: much more network traffic)</option></select></div>
+  <div class="form-row"><label for="node-input-idle"><i class="fa fa-power-off"></i> Idle drop</label>
+    <input type="text" id="node-input-idle" style="width:60px"> s &nbsp; Timeout
+    <input type="text" id="node-input-timeout" style="width:50px"> s</div>
+  <div class="form-tips">NDI® is a registered trademark of Vizrt NDI AB. More about NDI:
+    <a href="https://ndi.video/" target="_blank" rel="noopener">ndi.video</a>.</div>
+</script>
+
+<script type="text/html" data-help-name="ndi-thumbnail">
+  <p>Receives one NDI® source and outputs a JPEG still every few seconds, or on each input.</p>
+  <p><b>Needs the NDI Runtime on the Node-RED computer.</b> Install the NDI 6 Runtime (or NDI Tools) from
+    <a href="https://ndi.video/tools/">ndi.video</a>, then restart Node-RED. This node does not include NDI; without
+    the runtime it shows "NDI Runtime not installed" and does nothing else. It runs on macOS and on Windows x64.</p>
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">any</span></dt>
+    <dd>any message grabs a still now. <code>"stop"</code> or <code>false</code> pauses the timer and disconnects;
+      <code>"start"</code> or <code>true</code> resumes.</dd>
+    <dt class="optional">source <span class="property-type">string</span></dt><dd>overrides the configured source name.</dd>
+    <dt class="optional">address <span class="property-type">string</span></dt><dd>overrides the configured ip:port.</dd>
+  </dl>
+  <h3>Outputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">Buffer | null</span></dt>
+    <dd>the JPEG, or <code>null</code> when no picture arrived.</dd>
+    <dt>statusCode, headers</dt>
+    <dd><code>200</code> and <code>content-type: image/jpeg</code> on success, like an http request node's reply,
+      so the message can feed flows built for a camera's still-image URL.</dd>
+    <dt>ndi <span class="property-type">object</span></dt>
+    <dd><code>{source, width, height, fps, fourCC, bandwidth, lastFrame, runtime, thumbWidth, thumbHeight, bytes,
+      grabMs, connections, framesTotal, framesDropped, connectedForMs}</code>, or <code>{source, error, misses}</code>
+      when no picture arrived. <code>width</code> and <code>height</code> are those of the stream received: with
+      <i>Proxy</i> that is the sender's low-bandwidth stream (often 640×360), not the camera's own format.</dd>
+  </dl>
+  <h3>Details</h3>
+  <p>The connection to the source stays open while stills are taken within <i>Idle drop</i> seconds of each other
+    (a timer faster than that keeps it open); otherwise it connects for each still, which takes about 0.1–1 s.
+    <i>Proxy</i> asks the sender for its low-bandwidth stream. The node never sets tally, so it never lights a
+    camera's on-air lamp.</p>
+  <p>All NDI work runs in a separate helper process, so a problem in the NDI Runtime cannot stop Node-RED. Nodes
+    that show the same source share one connection to it.</p>
+  <p>NDI® is a registered trademark of Vizrt NDI AB. <a href="https://ndi.video/">ndi.video</a></p>
+</script>

package/nodes/ndi-thumbnail.js

@@ -0,0 +1,97 @@
+"use strict";
+// ndi-thumbnail: an NDI source -> a JPEG still (msg.payload, a Buffer) plus frame statistics (msg.ndi).
+// The message looks like an http request node's reply (statusCode 200, content-type image/jpeg), so it can feed
+// flows that were built for a camera's still-image URL without changes.
+// All NDI work happens in the NDI host process (lib/host.js); this file only schedules grabs and sends messages.
+const { getClient } = require("../lib/host-client");
+const { registerAdmin, watchRuntime, statusForRuntime, CHECKING } = require("../lib/admin");
+
+module.exports = function (RED) {
+  registerAdmin(RED);
+
+  function NdiThumbnailNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    const client = getClient(RED);
+    const everyS = Math.max(0, Number(config.interval) || 0);           // 0 = only when a message arrives
+    const width = Math.max(32, Math.min(1920, Number(config.width) || 320));
+    const quality = Math.max(10, Math.min(95, Number(config.quality) || 70));
+    const timeoutMs = Math.max(500, (Number(config.timeout) || 3) * 1000);
+    const idleS = config.idle === "" || config.idle == null ? 30 : Math.max(0, Number(config.idle) || 0);
+    const bandwidth = config.bandwidth === "highest" ? "highest" : "lowest";
+    // A timer that fires within the idle time keeps the receiver open between grabs; a slower timer connects for
+    // each grab. On input only, the receiver stays open for the idle time after each grab.
+    const idleMs = everyS > 0 ? (everyS < idleS ? everyS * 1000 + 5000 : 0) : idleS * 1000;
+    const label = "Node-RED " + (config.name || "NDI Preview");
+
+    let rt = null, timer = null, busy = false, paused = false, misses = 0, closed = false;
+
+    async function tick(msg, send, done) {
+      send = send || node.send.bind(node);
+      const name = (msg && typeof msg.source === "string" && msg.source) || config.source || "";
+      const address = (msg && typeof msg.address === "string" && msg.address) || config.address || "";
+      if (!name && !address) { node.status({ fill: "grey", shape: "ring", text: "no source set" }); if (done) done(); return; }
+      if (busy) { if (done) done(); return; }                            // never stack grabs
+      busy = true;
+      const out = msg ? RED.util.cloneMessage(msg) : {};
+      try {
+        const r = await client.grab({ owner: node.id, source: { name, address }, bandwidth, width, quality, timeoutMs, idleMs, label });
+        if (closed) return;
+        misses = 0;
+        out.payload = r.jpeg;
+        out.statusCode = 200;
+        out.headers = { "content-type": "image/jpeg" };
+        out.ndi = { source: name || address, ...r.meta };
+        node.status({ fill: "green", shape: "dot", text: `${r.meta.width}×${r.meta.height}${r.meta.fps ? " @ " + r.meta.fps : ""} · ${new Date().toLocaleTimeString()}` });
+        send(out);
+      } catch (e) {
+        if (closed) return;
+        if (e.code === "ENORUNTIME") { stopTimer(); rt = { ok: false }; node.status(statusForRuntime({ ok: false })); return; }
+        if (e.code === "EHOSTFAILED") { stopTimer(); rt = { ok: false, host: true, failed: true }; node.status(statusForRuntime(rt)); node.error(e.message); return; }
+        misses++;
+        out.payload = null;
+        out.ndi = { source: name || address, error: e.message, misses };
+        node.status({ fill: "red", shape: "ring", text: e.message.slice(0, 48) });
+        if (misses === 1) node.warn(`NDI "${name || address}": ${e.message}`);   // once per outage, not every tick
+        send(out);
+      } finally {
+        busy = false;
+        if (done) done();
+      }
+    }
+
+    function startTimer() {
+      stopTimer();
+      if (everyS > 0 && !paused && rt && rt.ok) timer = setInterval(() => tick(null), everyS * 1000);
+    }
+    function stopTimer() { clearInterval(timer); timer = null; }
+
+    node.on("input", (msg, send, done) => {
+      const cmd = typeof msg.payload === "string" ? msg.payload.trim().toLowerCase() : "";
+      if (cmd === "stop" || msg.payload === false) {                     // e.g. the page showing it was hidden
+        paused = true; stopTimer(); client.drop(node.id);
+        node.status({ fill: "grey", shape: "ring", text: "paused" }); done(); return;
+      }
+      if (rt && !rt.ok) { node.status(statusForRuntime(rt)); done(); return; }   // nothing can run without NDI
+      if (cmd === "start" || msg.payload === true) { paused = false; startTimer(); }
+      tick(msg, send, done);
+    });
+
+    node.on("close", (done) => {
+      closed = true;
+      stopTimer();
+      client.drop(node.id).then(() => done(), () => done());
+    });
+
+    node.status(CHECKING);
+    watchRuntime(RED, () => closed, (r) => {
+      if (!r.ok) { node.status(statusForRuntime(r)); if (!r.host || r.failed) rt = r; return; }   // a host hiccup is retried
+      rt = r;
+      node.status({ fill: "grey", shape: "ring", text: config.source || config.address || "no source set" });
+      startTimer();
+      if (everyS > 0) setTimeout(() => { if (!paused && !closed) tick(null); }, 500);
+    });
+  }
+
+  RED.nodes.registerType("ndi-thumbnail", NdiThumbnailNode);
+};