livedesk 0.1.151 → 0.1.153

package/README.md

@@ -29,7 +29,7 @@ automatically after reboot.
 - Mode 2: independent 320x180 RGB565+LZO tiles for large, stable walls.
 - Mode 3: direct hardware H.264 for focused remote control up to 4K.
 - Mode 4: client Mode 2 inputs composited by an isolated Hub worker into one
-  1920x1080 H.264 Atlas stream for the browser wall.
+  bounded H.264 Atlas stream, then split by UV into the normal browser slots.
 
 ## Plans
 

package/hub/src/mode4-atlas-worker.js

@@ -9,7 +9,18 @@ const DEFAULT_WIDTH = 1920;
 const DEFAULT_HEIGHT = 1080;
 const DEFAULT_FPS = 20;
 const MAX_DEVICES = 100;
-const FRAME_POOL_SIZE = 3;
+const FRAME_POOL_SIZE = 8;
+const MAX_TILE_WIDTH = 320;
+const MAX_TILE_HEIGHT = 180;
+
+const rgb565Red = new Uint8Array(65_536);
+const rgb565Green = new Uint8Array(65_536);
+const rgb565Blue = new Uint8Array(65_536);
+for (let pixel = 0; pixel < 65_536; pixel += 1) {
+  rgb565Red[pixel] = (((pixel >> 11) & 0x1f) * 255 / 31) | 0;
+  rgb565Green[pixel] = (((pixel >> 5) & 0x3f) * 255 / 63) | 0;
+  rgb565Blue[pixel] = ((pixel & 0x1f) * 255 / 31) | 0;
+}
 
 let config = normalizeConfig({});
 let layoutVersion = 0;
@@ -22,10 +33,14 @@ let encoderCandidates = [];
 let encoderOutputSeen = false;
 let encoderRestartTimer = null;
 let encoderStartupTimer = null;
+let inputWaitTimer = null;
 let outputBuffer = Buffer.alloc(0);
 let frameSeq = 0;
 let tickTimer = null;
+let nextTickAt = 0;
 let closed = false;
+let lastComposeMs = 0;
+let poolStarved = 0;
 
 function clamp(value, min, max, fallback) {
   const number = Number(value);
@@ -35,10 +50,23 @@ function clamp(value, min, max, fallback) {
 function normalizeConfig(value) {
   const deviceIds = [...new Set((Array.isArray(value?.deviceIds) ? value.deviceIds : [])
     .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 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 tileWidth = Math.max(2, Math.min(MAX_TILE_WIDTH, Math.floor(maxWidth / columns))) & ~1;
+  const tileHeight = Math.max(2, Math.min(MAX_TILE_HEIGHT, Math.floor(maxHeight / rows))) & ~1;
   return {
     deviceIds,
-    width: clamp(value?.width, 640, 3840, DEFAULT_WIDTH),
-    height: clamp(value?.height, 360, 2160, DEFAULT_HEIGHT),
+    maxWidth,
+    maxHeight,
+    width: tileWidth * columns,
+    height: tileHeight * rows,
+    columns,
+    rows,
+    tileWidth,
+    tileHeight,
     fps: clamp(value?.fps, 1, 30, DEFAULT_FPS)
   };
 }
@@ -193,27 +221,27 @@ function emitEncodedUnit(payload) {
       isKeyFrame,
       chunkType: isKeyFrame ? 'key' : 'delta',
       hardwareEncoder: encoder?.candidate?.name || '',
-      layoutVersion
+      layoutVersion,
+      composeMs: lastComposeMs,
+      poolStarved,
+      readyTileCount: latestTiles.size,
+      tileCount: config.deviceIds.length
     }
   });
 }
 
 function rebuildLayout() {
-  const count = Math.max(1, config.deviceIds.length);
-  const columns = Math.max(1, Math.ceil(Math.sqrt(count)));
-  const rows = Math.max(1, Math.ceil(count / columns));
-  const cellWidth = Math.floor(config.width / columns);
-  const cellHeight = Math.floor(config.height / rows);
+  const { columns, rows, tileWidth, tileHeight } = config;
   layoutVersion += 1;
   layout = config.deviceIds.map((deviceId, index) => ({
     deviceId,
     index,
     column: index % columns,
     row: Math.floor(index / columns),
-    x: (index % columns) * cellWidth,
-    y: Math.floor(index / columns) * cellHeight,
-    width: index % columns === columns - 1 ? config.width - (index % columns) * cellWidth : cellWidth,
-    height: Math.floor(index / columns) === rows - 1 ? config.height - Math.floor(index / columns) * cellHeight : cellHeight
+    x: (index % columns) * tileWidth,
+    y: Math.floor(index / columns) * tileHeight,
+    width: tileWidth,
+    height: tileHeight
   }));
   for (const tile of latestTiles.values()) tile.rendered = null;
   framePool = Array.from({ length: FRAME_POOL_SIZE }, () => Buffer.alloc(config.width * config.height * 3));
@@ -228,17 +256,26 @@ function renderTile(tileState, tileLayout) {
   const height = Math.max(1, Math.floor(sourceHeight * scale));
   const pixels = Buffer.allocUnsafe(width * height * 3);
   let target = 0;
+  if (width === sourceWidth && height === sourceHeight) {
+    for (let source = 0; source < tileState.rgb565.length; source += 2) {
+      const pixel = tileState.rgb565[source] | (tileState.rgb565[source + 1] << 8);
+      pixels[target++] = rgb565Red[pixel];
+      pixels[target++] = rgb565Green[pixel];
+      pixels[target++] = rgb565Blue[pixel];
+    }
+  } else {
   for (let y = 0; y < height; y += 1) {
     const sourceY = Math.min(sourceHeight - 1, Math.floor((y + 0.5) * sourceHeight / height));
     for (let x = 0; x < width; x += 1) {
       const sourceX = Math.min(sourceWidth - 1, Math.floor((x + 0.5) * sourceWidth / width));
       const source = (sourceY * sourceWidth + sourceX) * 2;
       const pixel = tileState.rgb565[source] | (tileState.rgb565[source + 1] << 8);
-      pixels[target++] = ((pixel >> 11) & 0x1f) * 255 / 31;
-      pixels[target++] = ((pixel >> 5) & 0x3f) * 255 / 63;
-      pixels[target++] = (pixel & 0x1f) * 255 / 31;
+      pixels[target++] = rgb565Red[pixel];
+      pixels[target++] = rgb565Green[pixel];
+      pixels[target++] = rgb565Blue[pixel];
     }
   }
+  }
   tileState.rendered = {
     pixels,
     width,
@@ -261,6 +298,10 @@ function ingestFrame(message) {
     const rgb565 = decodeLzo1xBlock(new Uint8Array(compressed), expectedLength);
     const tileState = { width, height, rgb565, rendered: null, frameSeq: Number(message.frameSeq || 0) };
     latestTiles.set(deviceId, tileState);
+    if (config.deviceIds.length > 0 && config.deviceIds.every(id => latestTiles.has(id))) {
+      clearTimeout(inputWaitTimer);
+      inputWaitTimer = null;
+    }
     const tileLayout = layout.find(item => item.deviceId === deviceId);
     if (tileLayout) renderTile(tileState, tileLayout);
   } catch (error) {
@@ -269,9 +310,14 @@ function ingestFrame(message) {
 }
 
 function writeAtlasFrame() {
+  if (latestTiles.size === 0) return;
+  const composeStartedAt = performance.now();
   const target = framePool.pop();
   const stdin = encoder?.child?.stdin;
-  if (!target || !stdin || stdin.destroyed || !stdin.writable) return;
+  if (!target || !stdin || stdin.destroyed || !stdin.writable) {
+    if (!target) poolStarved += 1;
+    return;
+  }
   target.fill(0);
   for (const tileLayout of layout) {
     const tileState = latestTiles.get(tileLayout.deviceId);
@@ -284,6 +330,7 @@ function writeAtlasFrame() {
       rendered.pixels.copy(target, targetStart, sourceStart, sourceStart + rendered.width * 3);
     }
   }
+  lastComposeMs = Math.max(0, performance.now() - composeStartedAt);
   try {
     stdin.write(target, error => {
       framePool.push(target);
@@ -295,11 +342,37 @@ function writeAtlasFrame() {
   }
 }
 
+function startComposeClock() {
+  clearTimeout(tickTimer);
+  const intervalMs = 1000 / config.fps;
+  nextTickAt = performance.now() + intervalMs;
+  const tick = () => {
+    if (closed) return;
+    writeAtlasFrame();
+    const now = performance.now();
+    nextTickAt += intervalMs;
+    if (nextTickAt < now - intervalMs) nextTickAt = now + intervalMs;
+    tickTimer = setTimeout(tick, Math.max(0, nextTickAt - performance.now()));
+  };
+  tickTimer = setTimeout(tick, intervalMs);
+}
+
 function configure(value) {
   const next = normalizeConfig(value);
   const encoderChanged = next.width !== config.width || next.height !== config.height || next.fps !== config.fps;
   config = next;
   latestTiles = new Map([...latestTiles].filter(([deviceId]) => config.deviceIds.includes(deviceId)));
+  clearTimeout(inputWaitTimer);
+  inputWaitTimer = config.deviceIds.length > 0 ? setTimeout(() => {
+    const missing = config.deviceIds.filter(deviceId => !latestTiles.has(deviceId));
+    if (missing.length > 0) {
+      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(', ')}`
+      });
+    }
+  }, 3000) : null;
   rebuildLayout();
   if (encoderChanged || !encoder) {
     stopEncoder();
@@ -307,8 +380,7 @@ function configure(value) {
     encoderCandidateIndex = 0;
     startEncoder();
   }
-  clearInterval(tickTimer);
-  tickTimer = setInterval(writeAtlasFrame, Math.max(1, Math.round(1000 / config.fps)));
+  startComposeClock();
 }
 
 process.on('message', message => {
@@ -320,7 +392,8 @@ process.on('message', message => {
 function shutdown() {
   if (closed) return;
   closed = true;
-  clearInterval(tickTimer);
+  clearTimeout(tickTimer);
+  clearTimeout(inputWaitTimer);
   stopEncoder();
   setTimeout(() => process.exit(0), 50).unref?.();
 }

package/hub/src/mode4-atlas.js

@@ -14,6 +14,8 @@ export class Mode4AtlasSession {
     this.closed = false;
     this.worker = null;
     this.restartTimer = null;
+    this.pendingFrames = new Map();
+    this.frameSendsInFlight = new Set();
     this.startWorker();
   }
 
@@ -37,6 +39,7 @@ export class Mode4AtlasSession {
     });
     worker.on('exit', code => {
       if (this.worker === worker) this.worker = null;
+      this.frameSendsInFlight.clear();
       if (this.closed) return;
       this.onStatus({ type: 'status', state: 'worker-restart', code });
       clearTimeout(this.restartTimer);
@@ -46,13 +49,18 @@ export class Mode4AtlasSession {
       }, 750);
     });
     worker.on('error', error => this.onStatus({ type: 'status', state: 'worker-error', error: error.message }));
-    if (this.config) worker.send({ type: 'configure', ...this.config });
+    if (this.config) {
+      worker.send({ type: 'configure', ...this.config }, () => {
+        for (const deviceId of this.pendingFrames.keys()) this.pumpDeviceFrame(deviceId);
+      });
+    }
   }
 
   configure(options = {}) {
     this.deviceIds = [...new Set((Array.isArray(options.deviceIds) ? options.deviceIds : [])
       .map(value => String(value || '').trim()).filter(Boolean))].slice(0, 100);
     this.deviceSet = new Set(this.deviceIds);
+    this.pendingFrames = new Map([...this.pendingFrames].filter(([deviceId]) => this.deviceSet.has(deviceId)));
     this.config = {
       deviceIds: this.deviceIds,
       width: Number(options.width || 1920),
@@ -62,13 +70,33 @@ export class Mode4AtlasSession {
     this.worker?.send({ type: 'configure', ...this.config });
   }
 
+  pumpDeviceFrame(deviceId) {
+    if (this.closed || !this.worker || this.frameSendsInFlight.has(deviceId)) return;
+    const message = this.pendingFrames.get(deviceId);
+    if (!message) return;
+    this.pendingFrames.delete(deviceId);
+    this.frameSendsInFlight.add(deviceId);
+    try {
+      this.worker.send(message, error => {
+        this.frameSendsInFlight.delete(deviceId);
+        if (error && !this.closed) {
+          this.onStatus({ type: 'log', level: 'warn', message: `Mode 4 input ${deviceId}: ${error.message}` });
+        }
+        this.pumpDeviceFrame(deviceId);
+      });
+    } catch (error) {
+      this.frameSendsInFlight.delete(deviceId);
+      this.onStatus({ type: 'log', level: 'warn', message: `Mode 4 input ${deviceId}: ${error.message}` });
+    }
+  }
+
   ingest(frameEvent) {
     if (this.closed || !this.worker) return;
     const frame = frameEvent?.frame || {};
     const deviceId = String(frameEvent?.deviceId || frame.deviceId || '').trim();
     const mode = String(frame.frameMode || frame.mode || '').toLowerCase();
     if (!this.deviceSet.has(deviceId) || mode !== 'mode2-lzo' || !Buffer.isBuffer(frameEvent?.payload)) return;
-    this.worker.send({
+    this.pendingFrames.set(deviceId, {
       type: 'frame',
       deviceId,
       frameSeq: Number(frame.frameSeq || 0),
@@ -77,12 +105,15 @@ export class Mode4AtlasSession {
       uncompressedByteLength: Number(frame.uncompressedByteLength || 0),
       payload: frameEvent.payload
     });
+    this.pumpDeviceFrame(deviceId);
   }
 
   close() {
     if (this.closed) return;
     this.closed = true;
     clearTimeout(this.restartTimer);
+    this.pendingFrames.clear();
+    this.frameSendsInFlight.clear();
     const worker = this.worker;
     this.worker = null;
     try { worker?.send({ type: 'close' }); } catch {}

package/hub/src/remote-hub.js

@@ -4588,6 +4588,7 @@ export function createRemoteHub(options = {}) {
         if (device.activeLiveStream?.streamId === streamId
             && options.forceRestart !== true
             && options.reuseExisting === true
+            && liveStreamMatchesOptions(device.activeLiveStream, normalized)
             && liveStreamIsReusable(device.activeLiveStream)) {
             return {
                 ok: true,

package/hub/src/server.js

@@ -773,7 +773,11 @@ function buildRemoteFrameBinaryPacket(frameEvent, diagnostics = {}) {
     convertMs: Number(frame.convertMs || 0) || 0,
     compressMs: Number(frame.compressMs || 0) || 0,
     sameContentStreak: Number(frame.sameContentStreak || 0) || 0,
-    layoutVersion: Number(frame.layoutVersion || 0) || 0
+    layoutVersion: Number(frame.layoutVersion || 0) || 0,
+    atlasComposeMs: Number(frame.atlasComposeMs || 0) || 0,
+    atlasPoolStarved: Number(frame.atlasPoolStarved || 0) || 0,
+    atlasReadyTiles: Number(frame.atlasReadyTiles || 0) || 0,
+    atlasTileCount: Number(frame.atlasTileCount || 0) || 0
   };
   const metaBuffer = Buffer.from(JSON.stringify(metadata), 'utf8');
   const header = Buffer.allocUnsafe(4);
@@ -913,7 +917,11 @@ function sendMode4AtlasFrame(ws, output) {
       receivedAt: new Date().toISOString(),
       hardwareEncoder: String(metadata.hardwareEncoder || ''),
       platformProfile: 'mode4-hub-atlas-worker',
-      layoutVersion: Number(metadata.layoutVersion || 0)
+      layoutVersion: Number(metadata.layoutVersion || 0),
+      atlasComposeMs: Number(metadata.composeMs || 0),
+      atlasPoolStarved: Number(metadata.poolStarved || 0),
+      atlasReadyTiles: Number(metadata.readyTileCount || 0),
+      atlasTileCount: Number(metadata.tileCount || 0)
     }
   };
   const lane = ensureFrameClientSendLane(ws);
@@ -952,7 +960,7 @@ function configureMode4Atlas(ws, payload = {}) {
       mode: 'mode2-lzo',
       frameMode: 'mode2-lzo',
       monitorIndex: Number(monitorSelections[deviceId] || 0),
-      reuseExisting: true,
+      reuseExisting: false,
       silentReuse: true
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.151",
+  "version": "0.1.153",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "bin": {