@livedesk/hub 0.1.41 → 0.1.42

package/src/lzo1x.js

@@ -1,109 +1,109 @@
-function requireInput(input, index, length) {
-  if (length < 0 || index < 0 || index + length > input.length) {
-    throw new Error('Invalid LZO1X block: input overrun.');
-  }
-}
-
-function readExtendedLength(input, state, basis) {
-  let zeroBytes = 0;
-  while (true) {
-    requireInput(input, state.inputIndex, 1);
-    if (input[state.inputIndex] !== 0) break;
-    zeroBytes += 1;
-    state.inputIndex += 1;
-  }
-  const length = zeroBytes * 255 + basis + input[state.inputIndex];
-  state.inputIndex += 1;
-  return length;
-}
-
-function copyLiteral(input, state, output, length) {
-  requireInput(input, state.inputIndex, length);
-  if (state.outputIndex + length > output.length) {
-    throw new Error('Invalid LZO1X block: output overrun.');
-  }
-  output.set(input.subarray(state.inputIndex, state.inputIndex + length), state.outputIndex);
-  state.inputIndex += length;
-  state.outputIndex += length;
-}
-
-export function decodeLzo1xBlock(input, outputLength) {
-  if (!(input instanceof Uint8Array) || input.length < 3 || outputLength < 0) {
-    throw new Error('Invalid LZO1X block.');
-  }
-  const output = new Uint8Array(outputLength);
-  const cursor = { inputIndex: 0, outputIndex: 0 };
-  let state = 0;
-  let matchLength = 0;
-  if (input[cursor.inputIndex] >= 22) {
-    const length = input[cursor.inputIndex] - 17;
-    cursor.inputIndex += 1;
-    copyLiteral(input, cursor, output, length);
-    state = 4;
-  } else if (input[cursor.inputIndex] >= 18) {
-    state = input[cursor.inputIndex] - 17;
-    cursor.inputIndex += 1;
-    copyLiteral(input, cursor, output, state);
-  }
-  while (true) {
-    requireInput(input, cursor.inputIndex, 1);
-    const instruction = input[cursor.inputIndex++];
-    let nextState;
-    let matchIndex;
-    if ((instruction & 0xc0) !== 0) {
-      requireInput(input, cursor.inputIndex, 1);
-      matchIndex = cursor.outputIndex - ((input[cursor.inputIndex] << 3) + ((instruction >> 2) & 7) + 1);
-      cursor.inputIndex += 1;
-      matchLength = (instruction >> 5) + 1;
-      nextState = instruction & 3;
-    } else if ((instruction & 0x20) !== 0) {
-      matchLength = (instruction & 0x1f) + 2;
-      if (matchLength === 2) matchLength += readExtendedLength(input, cursor, 31);
-      requireInput(input, cursor.inputIndex, 2);
-      const encoded = input[cursor.inputIndex] | (input[cursor.inputIndex + 1] << 8);
-      cursor.inputIndex += 2;
-      matchIndex = cursor.outputIndex - ((encoded >> 2) + 1);
-      nextState = encoded & 3;
-    } else if ((instruction & 0x10) !== 0) {
-      matchLength = (instruction & 7) + 2;
-      if (matchLength === 2) matchLength += readExtendedLength(input, cursor, 7);
-      requireInput(input, cursor.inputIndex, 2);
-      const encoded = input[cursor.inputIndex] | (input[cursor.inputIndex + 1] << 8);
-      cursor.inputIndex += 2;
-      matchIndex = cursor.outputIndex - (((instruction & 8) << 11) + (encoded >> 2));
-      nextState = encoded & 3;
-      if (matchIndex === cursor.outputIndex) break;
-      matchIndex -= 0x4000;
-    } else if (state === 0) {
-      let length = instruction + 3;
-      if (length === 3) length += readExtendedLength(input, cursor, 15);
-      copyLiteral(input, cursor, output, length);
-      state = 4;
-      continue;
-    } else if (state !== 4) {
-      requireInput(input, cursor.inputIndex, 1);
-      nextState = instruction & 3;
-      matchIndex = cursor.outputIndex - ((instruction >> 2) + (input[cursor.inputIndex] << 2) + 1);
-      cursor.inputIndex += 1;
-      matchLength = 2;
-    } else {
-      requireInput(input, cursor.inputIndex, 1);
-      nextState = instruction & 3;
-      matchIndex = cursor.outputIndex - ((instruction >> 2) + (input[cursor.inputIndex] << 2) + 2049);
-      cursor.inputIndex += 1;
-      matchLength = 3;
-    }
-    if (matchIndex < 0 || cursor.outputIndex + matchLength + nextState > output.length) {
-      throw new Error('Invalid LZO1X block: lookbehind overrun.');
-    }
-    for (let index = 0; index < matchLength; index += 1) {
-      output[cursor.outputIndex++] = output[matchIndex++];
-    }
-    state = nextState;
-    copyLiteral(input, cursor, output, nextState);
-  }
-  if (matchLength !== 3 || cursor.inputIndex !== input.length || cursor.outputIndex !== output.length) {
-    throw new Error('Invalid LZO1X block: incomplete output.');
-  }
-  return output;
-}
+function requireInput(input, index, length) {
+  if (length < 0 || index < 0 || index + length > input.length) {
+    throw new Error('Invalid LZO1X block: input overrun.');
+  }
+}
+
+function readExtendedLength(input, state, basis) {
+  let zeroBytes = 0;
+  while (true) {
+    requireInput(input, state.inputIndex, 1);
+    if (input[state.inputIndex] !== 0) break;
+    zeroBytes += 1;
+    state.inputIndex += 1;
+  }
+  const length = zeroBytes * 255 + basis + input[state.inputIndex];
+  state.inputIndex += 1;
+  return length;
+}
+
+function copyLiteral(input, state, output, length) {
+  requireInput(input, state.inputIndex, length);
+  if (state.outputIndex + length > output.length) {
+    throw new Error('Invalid LZO1X block: output overrun.');
+  }
+  output.set(input.subarray(state.inputIndex, state.inputIndex + length), state.outputIndex);
+  state.inputIndex += length;
+  state.outputIndex += length;
+}
+
+export function decodeLzo1xBlock(input, outputLength) {
+  if (!(input instanceof Uint8Array) || input.length < 3 || outputLength < 0) {
+    throw new Error('Invalid LZO1X block.');
+  }
+  const output = new Uint8Array(outputLength);
+  const cursor = { inputIndex: 0, outputIndex: 0 };
+  let state = 0;
+  let matchLength = 0;
+  if (input[cursor.inputIndex] >= 22) {
+    const length = input[cursor.inputIndex] - 17;
+    cursor.inputIndex += 1;
+    copyLiteral(input, cursor, output, length);
+    state = 4;
+  } else if (input[cursor.inputIndex] >= 18) {
+    state = input[cursor.inputIndex] - 17;
+    cursor.inputIndex += 1;
+    copyLiteral(input, cursor, output, state);
+  }
+  while (true) {
+    requireInput(input, cursor.inputIndex, 1);
+    const instruction = input[cursor.inputIndex++];
+    let nextState;
+    let matchIndex;
+    if ((instruction & 0xc0) !== 0) {
+      requireInput(input, cursor.inputIndex, 1);
+      matchIndex = cursor.outputIndex - ((input[cursor.inputIndex] << 3) + ((instruction >> 2) & 7) + 1);
+      cursor.inputIndex += 1;
+      matchLength = (instruction >> 5) + 1;
+      nextState = instruction & 3;
+    } else if ((instruction & 0x20) !== 0) {
+      matchLength = (instruction & 0x1f) + 2;
+      if (matchLength === 2) matchLength += readExtendedLength(input, cursor, 31);
+      requireInput(input, cursor.inputIndex, 2);
+      const encoded = input[cursor.inputIndex] | (input[cursor.inputIndex + 1] << 8);
+      cursor.inputIndex += 2;
+      matchIndex = cursor.outputIndex - ((encoded >> 2) + 1);
+      nextState = encoded & 3;
+    } else if ((instruction & 0x10) !== 0) {
+      matchLength = (instruction & 7) + 2;
+      if (matchLength === 2) matchLength += readExtendedLength(input, cursor, 7);
+      requireInput(input, cursor.inputIndex, 2);
+      const encoded = input[cursor.inputIndex] | (input[cursor.inputIndex + 1] << 8);
+      cursor.inputIndex += 2;
+      matchIndex = cursor.outputIndex - (((instruction & 8) << 11) + (encoded >> 2));
+      nextState = encoded & 3;
+      if (matchIndex === cursor.outputIndex) break;
+      matchIndex -= 0x4000;
+    } else if (state === 0) {
+      let length = instruction + 3;
+      if (length === 3) length += readExtendedLength(input, cursor, 15);
+      copyLiteral(input, cursor, output, length);
+      state = 4;
+      continue;
+    } else if (state !== 4) {
+      requireInput(input, cursor.inputIndex, 1);
+      nextState = instruction & 3;
+      matchIndex = cursor.outputIndex - ((instruction >> 2) + (input[cursor.inputIndex] << 2) + 1);
+      cursor.inputIndex += 1;
+      matchLength = 2;
+    } else {
+      requireInput(input, cursor.inputIndex, 1);
+      nextState = instruction & 3;
+      matchIndex = cursor.outputIndex - ((instruction >> 2) + (input[cursor.inputIndex] << 2) + 2049);
+      cursor.inputIndex += 1;
+      matchLength = 3;
+    }
+    if (matchIndex < 0 || cursor.outputIndex + matchLength + nextState > output.length) {
+      throw new Error('Invalid LZO1X block: lookbehind overrun.');
+    }
+    for (let index = 0; index < matchLength; index += 1) {
+      output[cursor.outputIndex++] = output[matchIndex++];
+    }
+    state = nextState;
+    copyLiteral(input, cursor, output, nextState);
+  }
+  if (matchLength !== 3 || cursor.inputIndex !== input.length || cursor.outputIndex !== output.length) {
+    throw new Error('Invalid LZO1X block: incomplete output.');
+  }
+  return output;
+}

package/src/mode4-atlas-pool.js

@@ -1,137 +1,137 @@
-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();
-    this.closingByKey = 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({
-        startAfter: this.closingByKey.get(key) || null,
-        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);
-          const closePromise = Promise.resolve(entry.session.close());
-          this.closingByKey.set(key, closePromise);
-          const retireCloseOwner = () => {
-            if (this.closingByKey.get(key) === closePromise) {
-              this.closingByKey.delete(key);
-            }
-          };
-          void closePromise.then(retireCloseOwner, retireCloseOwner);
-        }
-      }
-    };
-  }
-
-  ingest(frameEvent) {
-    for (const entry of this.entries.values()) {
-      entry.session.ingest(frameEvent);
-    }
-  }
-
-  get size() {
-    return this.entries.size;
-  }
-
-  async close() {
-    const closePromises = [...this.closingByKey.values()];
-    for (const entry of this.entries.values()) {
-      closePromises.push(Promise.resolve(entry.session.close()));
-    }
-    this.entries.clear();
-    this.closingByKey.clear();
-    await Promise.allSettled(closePromises);
-  }
-}
+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();
+    this.closingByKey = 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({
+        startAfter: this.closingByKey.get(key) || null,
+        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);
+          const closePromise = Promise.resolve(entry.session.close());
+          this.closingByKey.set(key, closePromise);
+          const retireCloseOwner = () => {
+            if (this.closingByKey.get(key) === closePromise) {
+              this.closingByKey.delete(key);
+            }
+          };
+          void closePromise.then(retireCloseOwner, retireCloseOwner);
+        }
+      }
+    };
+  }
+
+  ingest(frameEvent) {
+    for (const entry of this.entries.values()) {
+      entry.session.ingest(frameEvent);
+    }
+  }
+
+  get size() {
+    return this.entries.size;
+  }
+
+  async close() {
+    const closePromises = [...this.closingByKey.values()];
+    for (const entry of this.entries.values()) {
+      closePromises.push(Promise.resolve(entry.session.close()));
+    }
+    this.entries.clear();
+    this.closingByKey.clear();
+    await Promise.allSettled(closePromises);
+  }
+}

package/src/mode4-atlas-sizing.js

@@ -1,32 +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
-  };
-}
+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
+  };
+}