@apocaliss92/scrypted-reolink-native 0.3.10 → 0.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.3.10",
+   "version": "0.3.12",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/camera.ts

@@ -347,6 +347,13 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
             type: 'number',
             defaultValue: 1,
         },
+        intercomMaxBacklogMs: {
+            subgroup: 'Advanced',
+            title: 'Intercom Max Backlog (ms)',
+            description: 'Maximum PCM backlog before dropping old audio to cap latency. Higher improves stability on slow systems but increases latency. Typical: 80-250. Requires restarting talk session to take effect.',
+            type: 'number',
+            defaultValue: 120,
+        },
         // PTZ Presets
         presets: {
             subgroup: 'PTZ',

package/src/intercom.ts

@@ -7,20 +7,25 @@ import { ReolinkCamera } from "./camera";
 // A small backlog avoids multi-second latency when the pipeline stalls.
 // Aim for ~1 block of latency (a block is ~64ms at 16kHz for Reolink talk).
 // This clamps the internal buffer to (approximately) one block.
-const DEFAULT_MAX_BACKLOG_MS = 40;
+const DEFAULT_MAX_BACKLOG_MS = 120;
 
 export class ReolinkBaichuanIntercom {
+    private intercomApi: ReolinkBaichuanApi | undefined;
     private session: Awaited<ReturnType<ReolinkBaichuanApi["createTalkSession"]>> | undefined;
     private ffmpeg: ChildProcessWithoutNullStreams | undefined;
     private stopping: Promise<void> | undefined;
     private loggedCodecInfo = false;
 
-    private readonly maxBacklogMs = DEFAULT_MAX_BACKLOG_MS;
+    private maxBacklogMs = DEFAULT_MAX_BACKLOG_MS;
     private maxBacklogBytes: number | undefined;
 
-    private sendChain: Promise<void> = Promise.resolve();
     private pcmBuffer: Buffer = Buffer.alloc(0);
 
+    private pumping = false;
+    private pumpPromise: Promise<void> | undefined;
+
+    private lastBacklogClampLogAtMs = 0;
+
     constructor(private camera: ReolinkCamera) {
     }
 
@@ -39,13 +44,20 @@ export class ReolinkBaichuanIntercom {
         await this.stop();
         const channel = this.camera.storageSettings.values.rtspChannel;
 
+        // IMPORTANT: intercom must run on its own independent Baichuan session (separate socket)
+        // to avoid interference with any other sessions (streams/events/etc).
+        const intercomStreamKey = `intercom_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+        const intercomApi = await this.camera.withBaichuanRetry(async () => {
+            return await this.camera.createStreamClient(intercomStreamKey);
+        });
+        this.intercomApi = intercomApi;
+
         // Best-effort: log codec requirements exposed by the camera.
         // This mirrors neolink's source of truth: TalkAbility (cmd_id=10).
         if (!this.loggedCodecInfo) {
             this.loggedCodecInfo = true;
             try {
-                const api = await this.camera.ensureClient();
-                const ability = await api.getTalkAbility(channel);
+                const ability = await intercomApi.getTalkAbility(channel);
                 const audioConfigs = ability.audioConfigList?.map((c) => ({
                     audioType: c.audioType,
                     sampleRate: c.sampleRate,
@@ -66,7 +78,7 @@ export class ReolinkBaichuanIntercom {
         }
 
         const session = await this.camera.withBaichuanRetry(async () => {
-            const api = await this.camera.ensureClient();
+            const api = intercomApi;
             
             // For UDP/battery cameras, wake up the camera if it's sleeping before creating talk session
             if (this.camera.options?.type === 'battery') {
@@ -90,11 +102,23 @@ export class ReolinkBaichuanIntercom {
 
         this.session = session;
         this.pcmBuffer = Buffer.alloc(0);
-        this.sendChain = Promise.resolve();
+        this.pumping = false;
+        this.pumpPromise = undefined;
 
         const { audioConfig, blockSize, fullBlockSize } = session.info;
         const sampleRate = audioConfig.sampleRate;
 
+        // Configurable backlog to trade latency vs stability.
+        // If the pipeline (ffmpeg decode + encode + send) can't keep up,
+        // dropping old audio avoids accumulating multi-second latency.
+        const configuredBacklog = Number(this.camera.storageSettings.values.intercomMaxBacklogMs);
+        if (Number.isFinite(configuredBacklog)) {
+            this.maxBacklogMs = Math.max(20, Math.min(5000, configuredBacklog));
+        }
+        else {
+            this.maxBacklogMs = DEFAULT_MAX_BACKLOG_MS;
+        }
+
         // Mirror native-api.ts: receive PCM s16le from the forwarder and encode IMA ADPCM in JS.
         const samplesPerBlock = blockSize * 2 + 1;
         const bytesNeeded = samplesPerBlock * 2; // Int16 PCM
@@ -183,6 +207,9 @@ export class ReolinkBaichuanIntercom {
             const session = this.session;
             this.session = undefined;
 
+            const intercomApi = this.intercomApi;
+            this.intercomApi = undefined;
+
             this.pcmBuffer = Buffer.alloc(0);
 
             const sleepMs = async (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
@@ -207,12 +234,12 @@ export class ReolinkBaichuanIntercom {
             }
 
             try {
-                await Promise.race([this.sendChain, sleepMs(250)]);
+                await Promise.race([this.pumpPromise ?? Promise.resolve(), sleepMs(250)]);
             }
             catch {
                 // ignore
             }
-            this.sendChain = Promise.resolve();
+            this.pumpPromise = undefined;
 
             if (session) {
                 try {
@@ -222,6 +249,16 @@ export class ReolinkBaichuanIntercom {
                     logger.warn("Intercom session stop error", e?.message || String(e));
                 }
             }
+
+            // Close the dedicated intercom API session to keep it independent and short-lived.
+            if (intercomApi) {
+                try {
+                    await Promise.race([intercomApi.close(), sleepMs(2000)]);
+                }
+                catch (e) {
+                    logger.warn("Intercom client close error", e?.message || String(e));
+                }
+            }
         })().finally(() => {
             this.stopping = undefined;
         });
@@ -243,23 +280,43 @@ export class ReolinkBaichuanIntercom {
     ): void {
         const logger = this.camera.getBaichuanLogger();
 
-        this.sendChain = this.sendChain
-            .then(async () => {
-                if (this.session !== session) return;
+        if (this.session !== session) return;
+
+        this.pcmBuffer = this.pcmBuffer.length
+            ? Buffer.concat([this.pcmBuffer, pcmChunk])
+            : pcmChunk;
+
+        // Cap backlog to keep latency bounded (drop oldest samples).
+        // IMPORTANT: do this on the shared buffer (not in a promise chain),
+        // otherwise old PCM chunks can pile up in queued closures and bypass
+        // this clamp, causing multi-second latency and degraded audio.
+        const maxBytes = this.maxBacklogBytes ?? bytesNeeded;
+        if (this.pcmBuffer.length > maxBytes) {
+            // Align to 16-bit samples.
+            const keep = maxBytes - (maxBytes % 2);
+            const dropped = this.pcmBuffer.length - keep;
+            this.pcmBuffer = this.pcmBuffer.subarray(this.pcmBuffer.length - keep);
+
+            const now = Date.now();
+            if (now - this.lastBacklogClampLogAtMs > 2000) {
+                this.lastBacklogClampLogAtMs = now;
+                logger.warn("Intercom backlog clamped (dropping PCM)", {
+                    droppedBytes: dropped,
+                    keptBytes: keep,
+                    maxBytes,
+                });
+            }
+        }
 
-                this.pcmBuffer = this.pcmBuffer.length
-                    ? Buffer.concat([this.pcmBuffer, pcmChunk])
-                    : pcmChunk;
+        if (this.pumping) return;
 
-                // Cap backlog to keep latency bounded (drop oldest samples).
-                const maxBytes = this.maxBacklogBytes ?? bytesNeeded;
-                if (this.pcmBuffer.length > maxBytes) {
-                    // Align to 16-bit samples.
-                    const keep = maxBytes - (maxBytes % 2);
-                    this.pcmBuffer = this.pcmBuffer.subarray(this.pcmBuffer.length - keep);
-                }
+        this.pumping = true;
+        this.pumpPromise = (async () => {
+            try {
+                while (true) {
+                    if (this.session !== session) return;
+                    if (this.pcmBuffer.length < bytesNeeded) return;
 
-                while (this.pcmBuffer.length >= bytesNeeded) {
                     const chunk = this.pcmBuffer.subarray(0, bytesNeeded);
                     this.pcmBuffer = this.pcmBuffer.subarray(bytesNeeded);
 
@@ -272,10 +329,14 @@ export class ReolinkBaichuanIntercom {
                     const adpcmChunk = this.encodeImaAdpcm(pcmSamples, blockSize);
                     await session.sendAudio(adpcmChunk);
                 }
-            })
-            .catch((e) => {
+            }
+            catch (e) {
                 logger.warn("Intercom PCM->ADPCM pipeline error", e?.message || String(e));
-            });
+            }
+            finally {
+                this.pumping = false;
+            }
+        })();
     }
 
     private buildFfmpegPcmArgs(