@livedesk/hub 0.1.4 → 0.1.6

package/src/mode4-atlas-pool.js

@@ -0,0 +1,123 @@
+import { Mode4AtlasSession } from './mode4-atlas.js';
+import { randomUUID } from 'node:crypto';
+
+export function buildMode4AtlasSessionKey(config = {}) {
+  return JSON.stringify({
+    deviceIds: Array.isArray(config.deviceIds) ? config.deviceIds : [],
+    width: Number(config.width || 1920),
+    height: Number(config.height || 1080),
+    tileWidth: Number(config.tileWidth || 320),
+    tileHeight: Number(config.tileHeight || 180),
+    fps: Number(config.fps || 20)
+  });
+}
+
+export function planMode4AtlasInputTransitions(previous = {}, next = {}) {
+  const previousIds = new Set(Array.isArray(previous.inputDeviceIds) ? previous.inputDeviceIds : []);
+  const nextIds = new Set(Array.isArray(next.inputDeviceIds) ? next.inputDeviceIds : []);
+  const previousMonitorSelections = previous.monitorSelections || {};
+  const nextMonitorSelections = next.monitorSelections || {};
+  const captureSizeChanged = previousIds.size > 0
+    && (Number(previous.tileWidth || 0) !== Number(next.tileWidth || 0)
+      || Number(previous.tileHeight || 0) !== Number(next.tileHeight || 0));
+  const captureFpsChanged = previousIds.size > 0
+    && Number(previous.inputFps || 0) !== Number(next.inputFps || 0);
+  const stop = [...previousIds].filter(deviceId => !nextIds.has(deviceId));
+  const start = [];
+  const restart = [];
+  const unchanged = [];
+
+  for (const deviceId of nextIds) {
+    if (!previousIds.has(deviceId)) {
+      start.push(deviceId);
+      continue;
+    }
+    const previousMonitorIndex = Number(previousMonitorSelections[deviceId] || 0);
+    const nextMonitorIndex = Number(nextMonitorSelections[deviceId] || 0);
+    if (captureSizeChanged || captureFpsChanged || previousMonitorIndex !== nextMonitorIndex) {
+      restart.push(deviceId);
+    } else {
+      unchanged.push(deviceId);
+    }
+  }
+
+  return { stop, start, restart, unchanged };
+}
+
+export class Mode4AtlasPool {
+  constructor(options = {}) {
+    this.createSession = typeof options.createSession === 'function'
+      ? options.createSession
+      : callbacks => new Mode4AtlasSession(callbacks);
+    this.onStatus = typeof options.onStatus === 'function' ? options.onStatus : () => {};
+    this.entries = new Map();
+  }
+
+  acquire(config, callbacks = {}) {
+    const key = buildMode4AtlasSessionKey(config);
+    let entry = this.entries.get(key);
+    if (!entry) {
+      entry = {
+        key,
+        clients: new Map(),
+        latestLayout: null,
+        session: null,
+        streamId: `mode4-atlas-shared-${randomUUID()}`
+      };
+      entry.session = this.createSession({
+        onFrame: output => {
+          for (const listener of entry.clients.values()) listener.onFrame?.(output);
+        },
+        onLayout: layout => {
+          entry.latestLayout = layout;
+          for (const listener of entry.clients.values()) listener.onLayout?.(layout);
+        },
+        onStatus: status => {
+          this.onStatus(status);
+          for (const listener of entry.clients.values()) listener.onStatus?.(status);
+        }
+      });
+      entry.session.configure(config);
+      this.entries.set(key, entry);
+    }
+
+    const clientId = Symbol(key);
+    entry.clients.set(clientId, callbacks);
+    if (entry.latestLayout) {
+      queueMicrotask(() => {
+        if (entry.clients.has(clientId)) callbacks.onLayout?.(entry.latestLayout);
+      });
+    }
+
+    let released = false;
+    return {
+      key,
+      session: entry.session,
+      streamId: entry.streamId,
+      release: () => {
+        if (released) return;
+        released = true;
+        entry.clients.delete(clientId);
+        if (entry.clients.size === 0) {
+          this.entries.delete(key);
+          entry.session.close();
+        }
+      }
+    };
+  }
+
+  ingest(frameEvent) {
+    for (const entry of this.entries.values()) {
+      entry.session.ingest(frameEvent);
+    }
+  }
+
+  get size() {
+    return this.entries.size;
+  }
+
+  close() {
+    for (const entry of this.entries.values()) entry.session.close();
+    this.entries.clear();
+  }
+}

package/src/mode4-atlas-sizing.js

@@ -0,0 +1,32 @@
+const TILE_PRESETS = Object.freeze([
+  Object.freeze({ width: 320, height: 180 }),
+  Object.freeze({ width: 480, height: 270 }),
+  Object.freeze({ width: 640, height: 360 })
+]);
+
+export function resolveMode4AtlasTileSize(options = {}) {
+  const deviceCount = Math.max(1, Math.floor(Number(options.deviceCount) || 1));
+  const atlasWidth = Math.max(640, Math.floor(Number(options.atlasWidth) || 1920));
+  const atlasHeight = Math.max(360, Math.floor(Number(options.atlasHeight) || 1080));
+  const requestedWidth = Number(options.requestedWidth) || 320;
+  const requestedHeight = Number(options.requestedHeight) || 180;
+  const columns = Math.max(1, Math.ceil(Math.sqrt(deviceCount)));
+  const rows = Math.max(1, Math.ceil(deviceCount / columns));
+  const requestedPresetIndex = requestedWidth >= 640 || requestedHeight >= 360
+    ? 2
+    : requestedWidth >= 480 || requestedHeight >= 270
+      ? 1
+      : 0;
+  const supportedCandidates = TILE_PRESETS.slice(0, requestedPresetIndex + 1).reverse();
+  const selected = supportedCandidates.find(candidate => (
+    candidate.width * columns <= atlasWidth
+    && candidate.height * rows <= atlasHeight
+  )) || TILE_PRESETS[0];
+
+  return {
+    width: selected.width,
+    height: selected.height,
+    columns,
+    rows
+  };
+}

package/src/mode4-atlas-worker.js

@@ -4,15 +4,16 @@ import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { existsSync } from 'node:fs';
 import { decodeLzo1xBlock } from './lzo1x.js';
+import { resolveMode4AtlasTileSize } from './mode4-atlas-sizing.js';
 
 const require = createRequire(import.meta.url);
 const DEFAULT_WIDTH = 1920;
 const DEFAULT_HEIGHT = 1080;
 const DEFAULT_FPS = 20;
 const MAX_DEVICES = 100;
-const FRAME_POOL_SIZE = 8;
-const MAX_TILE_WIDTH = 480;
-const MAX_TILE_HEIGHT = 270;
+const FRAME_POOL_SIZE = 3;
+const MAX_TILE_WIDTH = 640;
+const MAX_TILE_HEIGHT = 360;
 
 const rgb565Red = new Uint8Array(65_536);
 const rgb565Green = new Uint8Array(65_536);
@@ -43,7 +44,11 @@ let nextTickAt = 0;
 let closed = false;
 let lastComposeMs = 0;
 let poolStarved = 0;
+let inputRevision = 0;
+let lastEncodedInputRevision = -1;
+let lastAtlasWriteAtEpochMs = 0;
 const ENCODER_STARTUP_OUTPUT_TIMEOUT_MS = 8_000;
+const ATLAS_KEEPALIVE_MS = 1_000;
 
 function clamp(value, min, max, fallback) {
   const number = Number(value);
@@ -55,12 +60,18 @@ function normalizeConfig(value) {
     .map(item => String(item || '').trim()).filter(Boolean))].slice(0, MAX_DEVICES);
   const maxWidth = clamp(value?.width, 640, 3840, DEFAULT_WIDTH);
   const maxHeight = clamp(value?.height, 360, 2160, DEFAULT_HEIGHT);
-  const sharpTiles = Number(value?.tileWidth) >= 480 || Number(value?.tileHeight) >= 270;
-  const sourceTileWidth = sharpTiles ? 480 : 320;
-  const sourceTileHeight = sharpTiles ? 270 : 180;
   const count = Math.max(1, deviceIds.length);
-  const columns = Math.max(1, Math.ceil(Math.sqrt(count)));
-  const rows = Math.max(1, Math.ceil(count / columns));
+  const tileSize = resolveMode4AtlasTileSize({
+    requestedWidth: value?.tileWidth,
+    requestedHeight: value?.tileHeight,
+    deviceCount: count,
+    atlasWidth: maxWidth,
+    atlasHeight: maxHeight
+  });
+  const columns = tileSize.columns;
+  const rows = tileSize.rows;
+  const sourceTileWidth = tileSize.width;
+  const sourceTileHeight = tileSize.height;
   const tileWidth = Math.max(2, Math.min(sourceTileWidth, Math.floor(maxWidth / columns))) & ~1;
   const tileHeight = Math.max(2, Math.min(sourceTileHeight, Math.floor(maxHeight / rows))) & ~1;
   return {
@@ -229,6 +240,12 @@ function emitEncodedUnit(payload) {
   clearTimeout(encoderStartupTimer);
   encoderStartupTimer = null;
   frameSeq += 1;
+  const readyTiles = [...latestTiles.values()];
+  const inputTimes = readyTiles
+    .map(tile => Number(tile.hubReceivedAtEpochMs || 0))
+    .filter(value => value > 0);
+  const sourceNewestAtEpochMs = inputTimes.length > 0 ? Math.max(...inputTimes) : 0;
+  const sourceOldestAtEpochMs = inputTimes.length > 0 ? Math.min(...inputTimes) : 0;
   send({
     type: 'frame',
     payload: Buffer.from(payload),
@@ -248,7 +265,11 @@ function emitEncodedUnit(payload) {
       composeMs: lastComposeMs,
       poolStarved,
       readyTileCount: latestTiles.size,
-      tileCount: config.deviceIds.length
+      tileCount: config.deviceIds.length,
+      inputRevision,
+      sourceNewestAtEpochMs,
+      sourceOldestAtEpochMs,
+      sourceMaxAgeMs: sourceOldestAtEpochMs > 0 ? Math.max(0, Date.now() - sourceOldestAtEpochMs) : 0
     }
   });
 }
@@ -317,10 +338,28 @@ function ingestFrame(message) {
   const expectedLength = width * height * 2;
   if (!width || !height || Number(message.uncompressedByteLength) !== expectedLength) return;
   try {
+    const contentHash = String(message.contentHash || '');
+    const previous = latestTiles.get(deviceId);
+    const inputMetadata = {
+      frameSeq: Number(message.frameSeq || 0),
+      monitorIndex: Number(message.monitorIndex || 0),
+      capturedAtEpochMs: Number(message.capturedAtEpochMs || 0),
+      hubReceivedAtEpochMs: Number(message.hubReceivedAtEpochMs || 0) || Date.now(),
+      contentHash
+    };
+    if (previous
+      && contentHash
+      && previous.contentHash === contentHash
+      && previous.width === width
+      && previous.height === height) {
+      Object.assign(previous, inputMetadata);
+      return;
+    }
     const compressed = Buffer.isBuffer(message.payload) ? message.payload : Buffer.from(message.payload || []);
     const rgb565 = decodeLzo1xBlock(new Uint8Array(compressed), expectedLength);
-    const tileState = { width, height, rgb565, rendered: null, frameSeq: Number(message.frameSeq || 0) };
+    const tileState = { width, height, rgb565, rendered: null, ...inputMetadata };
     latestTiles.set(deviceId, tileState);
+    inputRevision += 1;
     if (!encoder && encoderCandidates.length > 0) startEncoder();
     if (config.deviceIds.length > 0 && config.deviceIds.every(id => latestTiles.has(id))) {
       clearTimeout(inputWaitTimer);
@@ -339,6 +378,11 @@ function writeAtlasFrame() {
     startEncoder();
     return;
   }
+  const nowEpochMs = Date.now();
+  if (inputRevision === lastEncodedInputRevision
+    && nowEpochMs - lastAtlasWriteAtEpochMs < ATLAS_KEEPALIVE_MS) {
+    return;
+  }
   const composeStartedAt = performance.now();
   const target = framePool.pop();
   const stdin = encoder?.child?.stdin;
@@ -371,6 +415,8 @@ function writeAtlasFrame() {
         send({ type: 'log', level: 'warn', message: `Mode 4 encoder write: ${error.message}` });
       }
     });
+    lastEncodedInputRevision = inputRevision;
+    lastAtlasWriteAtEpochMs = nowEpochMs;
   } catch (error) {
     framePool.push(target);
     if (!isClosedPipeError(error)) send({ type: 'log', level: 'warn', message: `Mode 4 encoder write: ${error.message}` });
@@ -396,6 +442,7 @@ function configure(value) {
   const next = normalizeConfig(value);
   const encoderChanged = next.width !== config.width || next.height !== config.height || next.fps !== config.fps;
   config = next;
+  lastEncodedInputRevision = -1;
   latestTiles = new Map([...latestTiles].filter(([deviceId]) => config.deviceIds.includes(deviceId)));
   clearTimeout(inputWaitTimer);
   inputWaitTimer = config.deviceIds.length > 0 ? setTimeout(() => {
@@ -404,7 +451,7 @@ function configure(value) {
       send({
         type: 'log',
         level: 'warn',
-        message: `Mode 4 waiting for Mode 2 input from ${missing.length}/${config.deviceIds.length} devices: ${missing.slice(0, 8).join(', ')}`
+        message: `Mode 4 waiting for internal Atlas input from ${missing.length}/${config.deviceIds.length} devices: ${missing.slice(0, 8).join(', ')}`
       });
     }
   }, 3000) : null;

package/src/mode4-atlas.js

@@ -107,7 +107,11 @@ export class Mode4AtlasSession {
     const frame = frameEvent?.frame || {};
     const deviceId = String(frameEvent?.deviceId || frame.deviceId || '').trim();
     const mode = String(frame.frameMode || frame.mode || '').toLowerCase();
-    if (!this.inputDeviceSet.has(deviceId) || mode !== 'mode2-lzo' || !Buffer.isBuffer(frameEvent?.payload)) return;
+    const streamPurpose = String(frame.streamPurpose || '').trim().toLowerCase();
+    if (!this.inputDeviceSet.has(deviceId)
+      || mode !== 'mode2-lzo'
+      || streamPurpose !== 'atlas'
+      || !Buffer.isBuffer(frameEvent?.payload)) return;
     this.pendingFrames.set(deviceId, {
       type: 'frame',
       deviceId,
@@ -115,6 +119,10 @@ export class Mode4AtlasSession {
       width: Number(frame.width || 0),
       height: Number(frame.height || 0),
       uncompressedByteLength: Number(frame.uncompressedByteLength || 0),
+      monitorIndex: Number(frame.monitorIndex || 0),
+      capturedAtEpochMs: Date.parse(frame.capturedAt || '') || 0,
+      hubReceivedAtEpochMs: Date.parse(frame.receivedAt || '') || Date.now(),
+      contentHash: String(frame.contentHash || ''),
       payload: frameEvent.payload
     });
     this.pumpDeviceFrame(deviceId);