@apocaliss92/scrypted-reolink-native 0.3.15 → 0.4.0

package/src/intercom.ts

@@ -1,5 +1,11 @@
-import type { ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { FFmpegInput, MediaObject, ScryptedMimeTypes } from "@scrypted/sdk";
+import type { ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with {
+  "resolution-mode": "import",
+};
+import sdk, {
+  FFmpegInput,
+  MediaObject,
+  ScryptedMimeTypes,
+} from "@scrypted/sdk";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { ReolinkCamera } from "./camera";
 
@@ -10,520 +16,534 @@ import { ReolinkCamera } from "./camera";
 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 maxBacklogMs = DEFAULT_MAX_BACKLOG_MS;
-    private maxBacklogBytes: number | undefined;
-
-    private pcmBuffer: Buffer = Buffer.alloc(0);
+  private session:
+    | Awaited<ReturnType<ReolinkBaichuanApi["createDedicatedTalkSession"]>>
+    | undefined;
+  private ffmpeg: ChildProcessWithoutNullStreams | undefined;
+  private stopping: Promise<void> | undefined;
+  private loggedCodecInfo = false;
+
+  private maxBacklogMs = DEFAULT_MAX_BACKLOG_MS;
+  private maxBacklogBytes: number | undefined;
+
+  private pcmBuffer: Buffer = Buffer.alloc(0);
+
+  private pumping = false;
+  private pumpPromise: Promise<void> | undefined;
+
+  private lastBacklogClampLogAtMs = 0;
+
+  constructor(private camera: ReolinkCamera) {}
+
+  get blocksPerPayload(): number {
+    return Math.max(
+      1,
+      Math.min(
+        8,
+        this.camera.storageSettings.values.intercomBlocksPerPayload ?? 1,
+      ),
+    );
+  }
+
+  private get outputGain(): number {
+    const configured = Number(this.camera.storageSettings.values.intercomGain);
+    // Keep safe bounds: too high can clip and distort.
+    if (Number.isFinite(configured))
+      return Math.max(0.1, Math.min(10, configured));
+    return 1.0;
+  }
+
+  async start(media: MediaObject): Promise<void> {
+    const logger = this.camera.getBaichuanLogger();
+
+    const ffmpegInput =
+      await sdk.mediaManager.convertMediaObjectToJSON<FFmpegInput>(
+        media,
+        ScryptedMimeTypes.FFmpegInput,
+      );
+
+    await this.stop();
+    const channel = this.camera.storageSettings.values.rtspChannel;
+
+    try {
+      // Get the main API - library manages dedicated sockets internally
+      const api = await this.camera.withBaichuanRetry(async () => {
+        return await this.camera.ensureBaichuanClient();
+      });
+
+      // 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 ability = await api.getTalkAbility(channel);
+          logger.log("Intercom TalkAbility", {
+            channel,
+            duplexList: ability.duplexList,
+            audioStreamModeList: ability.audioStreamModeList,
+            audioConfigList: ability.audioConfigList,
+          });
+        } catch (e) {
+          logger.warn(
+            "Intercom: unable to fetch TalkAbility",
+            e?.message || String(e),
+          );
+        }
+      }
 
-    private pumping = false;
-    private pumpPromise: Promise<void> | undefined;
+      // For UDP/battery cameras, wake up the camera if it's sleeping before creating talk session
+      if (this.camera.options?.type === "battery") {
+        try {
+          const sleepStatus = api.getSleepStatus({ channel });
+          if (sleepStatus.state === "sleeping") {
+            logger.log("Camera is sleeping, waking up for intercom...");
+            await api.wakeUp(channel, { waitAfterWakeMs: 2000 });
+            // Wait a bit more to ensure camera is fully awake
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          }
+        } catch (e) {
+          logger.debug(
+            "Failed to check/wake camera for intercom, proceeding anyway",
+            e?.message || String(e),
+          );
+        }
+      }
+
+      // Use createDedicatedTalkSession - library manages dedicated socket internally
+      // with auto-teardown on idle or when stop() is called
+      const session = await this.camera.withBaichuanRetry(async () => {
+        return await api.createDedicatedTalkSession(channel, {
+          blocksPerPayload: this.blocksPerPayload,
+          idleTimeoutMs: 30000, // Auto-teardown if no audio for 30s
+          deviceId: this.camera.nativeId,
+          logger,
+        });
+      });
+
+      this.session = session;
+      this.pcmBuffer = Buffer.alloc(0);
+      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
+      this.maxBacklogBytes = Math.max(
+        bytesNeeded,
+        // bytes/sec = sampleRate * channels * 2 (s16)
+        Math.floor((this.maxBacklogMs / 1000) * sampleRate * 1 * 2),
+      );
+
+      if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+        await this.stop();
+        throw new Error(`Invalid talk sampleRate: ${sampleRate}`);
+      }
+      if (
+        !Number.isFinite(blockSize) ||
+        blockSize <= 0 ||
+        !Number.isFinite(fullBlockSize) ||
+        fullBlockSize !== blockSize + 4
+      ) {
+        await this.stop();
+        throw new Error(
+          `Invalid talk block sizes: blockSize=${blockSize} fullBlockSize=${fullBlockSize}`,
+        );
+      }
+
+      logger.log("Starting intercom (baichuan/native-api flow)", {
+        channel,
+        audioType: audioConfig.audioType,
+        sampleRate: audioConfig.sampleRate,
+        samplePrecision: audioConfig.samplePrecision,
+        lengthPerEncoder: audioConfig.lengthPerEncoder,
+        soundTrack: audioConfig.soundTrack,
+        blockSize,
+        fullBlockSize,
+        samplesPerBlock,
+        bytesNeeded,
+        maxBacklogMs: this.maxBacklogMs,
+        maxBacklogBytes: this.maxBacklogBytes,
+        blocksPerPayload: this.blocksPerPayload,
+      });
+
+      // IMPORTANT: incoming audio from Scrypted/WebRTC is typically Opus.
+      // We must decode to PCM before IMA ADPCM encoding, otherwise it will be noise.
+      const gain = this.outputGain;
+      const ffmpegArgs = this.buildFfmpegPcmArgs(ffmpegInput, {
+        sampleRate,
+        channels: 1,
+        gain,
+        logger,
+      });
+
+      logger.log("Intercom ffmpeg decode args", ffmpegArgs);
+
+      const ffmpeg = spawn("ffmpeg", ffmpegArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      if (this.session !== session) {
+        try {
+          ffmpeg.kill("SIGKILL");
+        } catch {}
+        return;
+      }
 
-    private lastBacklogClampLogAtMs = 0;
+      this.ffmpeg = ffmpeg;
 
-    constructor(private camera: ReolinkCamera) {
+      ffmpeg.stdout.on("data", (chunk: Buffer) => {
+        if (this.session !== session) return;
+        if (!chunk?.length) return;
+        this.enqueuePcm(session, chunk, bytesNeeded, blockSize);
+      });
+
+      let stderrLines = 0;
+      ffmpeg.stderr.on("data", (d: Buffer) => {
+        // Avoid spamming logs.
+        if (stderrLines++ < 12) {
+          logger.warn("Intercom ffmpeg", d.toString().trim());
+        }
+      });
+
+      ffmpeg.on("exit", (code, signal) => {
+        logger.warn(`Intercom ffmpeg exited code=${code} signal=${signal}`);
+        this.stop().catch(() => {});
+      });
+
+      logger.log("Intercom started (ffmpeg decode -> PCM -> IMA ADPCM)");
+    } catch (e) {
+      // Ensure the dedicated session gets torn down even if start fails half-way.
+      await this.stop();
+      throw e;
     }
+  }
 
-    get blocksPerPayload(): number {
-        return Math.max(1, Math.min(8, this.camera.storageSettings.values.intercomBlocksPerPayload ?? 1));
-    }
+  stop(): Promise<void> {
+    if (this.stopping) return this.stopping;
 
-    private get outputGain(): number {
-        const configured = Number(this.camera.storageSettings.values.intercomGain);
-        // Keep safe bounds: too high can clip and distort.
-        if (Number.isFinite(configured)) return Math.max(0.1, Math.min(10, configured));
-        return 1.0;
-    }
+    this.stopping = (async () => {
+      const logger = this.camera.getBaichuanLogger();
 
-    async start(media: MediaObject): Promise<void> {
-        const logger = this.camera.getBaichuanLogger();
+      const ffmpeg = this.ffmpeg;
+      this.ffmpeg = undefined;
 
-        const ffmpegInput = await sdk.mediaManager.convertMediaObjectToJSON<FFmpegInput>(
-            media,
-            ScryptedMimeTypes.FFmpegInput,
-        );
+      const session = this.session;
+      this.session = undefined;
 
-        await this.stop();
-        const channel = this.camera.storageSettings.values.rtspChannel;
+      this.pcmBuffer = Buffer.alloc(0);
+
+      const sleepMs = async (ms: number) =>
+        new Promise<void>((resolve) => setTimeout(resolve, ms));
 
+      if (ffmpeg && ffmpeg.exitCode == null) {
         try {
-            // 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 ability = await intercomApi.getTalkAbility(channel);
-                const audioConfigs = ability.audioConfigList?.map((c) => ({
-                    audioType: c.audioType,
-                    sampleRate: c.sampleRate,
-                    samplePrecision: c.samplePrecision,
-                    lengthPerEncoder: c.lengthPerEncoder,
-                    soundTrack: c.soundTrack,
-                }));
-                logger.log("Intercom TalkAbility", {
-                    channel,
-                    duplexList: ability.duplexList,
-                    audioStreamModeList: ability.audioStreamModeList,
-                    audioConfigList: audioConfigs,
-                });
-            }
-            catch (e) {
-                logger.warn("Intercom: unable to fetch TalkAbility", e?.message || String(e));
-            }
+          ffmpeg.kill("SIGKILL");
+        } catch {
+          // ignore
         }
 
-        const session = await this.camera.withBaichuanRetry(async () => {
-            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') {
-                try {
-                    const sleepStatus = api.getSleepStatus({ channel });
-                    if (sleepStatus.state === 'sleeping') {
-                        logger.log('Camera is sleeping, waking up for intercom...');
-                        await api.wakeUp(channel, { waitAfterWakeMs: 2000 });
-                        // Wait a bit more to ensure camera is fully awake
-                        await new Promise(resolve => setTimeout(resolve, 1000));
-                    }
-                } catch (e) {
-                    logger.debug('Failed to check/wake camera for intercom, proceeding anyway', e?.message || String(e));
-                }
-            }
-            
-            return await api.createTalkSession(channel, {
-                blocksPerPayload: this.blocksPerPayload,
-                // IMPORTANT: for dedicated intercom sessions, teardown should be owned by the socket/session.
-                // This mirrors stream behavior (closeApiOnTeardown) but for talk: session.stop() will close.
-                closeSocketOnStop: true,
-            });
-        });
-
-        this.session = session;
-        this.pcmBuffer = Buffer.alloc(0);
-        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;
+        try {
+          await Promise.race([
+            new Promise<void>((resolve) =>
+              ffmpeg.once("exit", () => resolve()),
+            ),
+            sleepMs(1000),
+          ]);
+        } catch {
+          // ignore
         }
+      }
 
-        // 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
-        this.maxBacklogBytes = Math.max(
-            bytesNeeded,
-            // bytes/sec = sampleRate * channels * 2 (s16)
-            Math.floor((this.maxBacklogMs / 1000) * sampleRate * 1 * 2),
-        );
+      try {
+        await Promise.race([
+          this.pumpPromise ?? Promise.resolve(),
+          sleepMs(250),
+        ]);
+      } catch {
+        // ignore
+      }
+      this.pumpPromise = undefined;
 
-        if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
-            await this.stop();
-            throw new Error(`Invalid talk sampleRate: ${sampleRate}`);
-        }
-        if (!Number.isFinite(blockSize) || blockSize <= 0 || !Number.isFinite(fullBlockSize) || fullBlockSize !== blockSize + 4) {
-            await this.stop();
-            throw new Error(`Invalid talk block sizes: blockSize=${blockSize} fullBlockSize=${fullBlockSize}`);
+      // session.stop() handles socket teardown - library manages dedicated socket internally
+      if (session) {
+        try {
+          await Promise.race([session.stop(), sleepMs(2000)]);
+        } catch (e) {
+          logger.warn("Intercom session stop error", e?.message || String(e));
         }
-
-        logger.log("Starting intercom (baichuan/native-api flow)", {
-            channel,
-            audioType: audioConfig.audioType,
-            sampleRate: audioConfig.sampleRate,
-            samplePrecision: audioConfig.samplePrecision,
-            lengthPerEncoder: audioConfig.lengthPerEncoder,
-            soundTrack: audioConfig.soundTrack,
-            blockSize,
-            fullBlockSize,
-            samplesPerBlock,
-            bytesNeeded,
-            maxBacklogMs: this.maxBacklogMs,
-            maxBacklogBytes: this.maxBacklogBytes,
-            blocksPerPayload: this.blocksPerPayload,
-        });
-
-        // IMPORTANT: incoming audio from Scrypted/WebRTC is typically Opus.
-        // We must decode to PCM before IMA ADPCM encoding, otherwise it will be noise.
-        const gain = this.outputGain;
-        const ffmpegArgs = this.buildFfmpegPcmArgs(ffmpegInput, {
-            sampleRate,
-            channels: 1,
-            gain,
-            logger,
+      }
+    })().finally(() => {
+      this.stopping = undefined;
+    });
+
+    return this.stopping;
+  }
+
+  private clamp16(x: number): number {
+    if (x > 32767) return 32767;
+    if (x < -32768) return -32768;
+    return x | 0;
+  }
+
+  private enqueuePcm(
+    session: Awaited<ReturnType<ReolinkBaichuanApi["createTalkSession"]>>,
+    pcmChunk: Buffer,
+    bytesNeeded: number,
+    blockSize: number,
+  ): void {
+    const logger = this.camera.getBaichuanLogger();
+
+    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,
         });
+      }
+    }
 
-        logger.log("Intercom ffmpeg decode args", ffmpegArgs);
-
-        const ffmpeg = spawn("ffmpeg", ffmpegArgs, {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-
-        if (this.session !== session) {
-            try { ffmpeg.kill("SIGKILL"); } catch { }
-            return;
-        }
-
-        this.ffmpeg = ffmpeg;
+    if (this.pumping) return;
 
-        ffmpeg.stdout.on("data", (chunk: Buffer) => {
-            if (this.session !== session) return;
-            if (!chunk?.length) return;
-            this.enqueuePcm(session, chunk, bytesNeeded, blockSize);
-        });
+    this.pumping = true;
+    this.pumpPromise = (async () => {
+      try {
+        while (true) {
+          if (this.session !== session) return;
+          if (this.pcmBuffer.length < bytesNeeded) return;
 
-        let stderrLines = 0;
-        ffmpeg.stderr.on("data", (d: Buffer) => {
-            // Avoid spamming logs.
-            if (stderrLines++ < 12) {
-                logger.warn("Intercom ffmpeg", d.toString().trim());
-            }
-        });
+          const chunk = this.pcmBuffer.subarray(0, bytesNeeded);
+          this.pcmBuffer = this.pcmBuffer.subarray(bytesNeeded);
 
-        ffmpeg.on("exit", (code, signal) => {
-            logger.warn(`Intercom ffmpeg exited code=${code} signal=${signal}`);
-            this.stop().catch(() => { });
-        });
+          const pcmSamples = new Int16Array(
+            chunk.buffer,
+            chunk.byteOffset,
+            chunk.length / 2,
+          );
 
-        logger.log("Intercom started (ffmpeg decode -> PCM -> IMA ADPCM)");
+          const adpcmChunk = this.encodeImaAdpcm(pcmSamples, blockSize);
+          await session.sendAudio(adpcmChunk);
         }
-        catch (e) {
-            // Ensure the dedicated session gets torn down even if start fails half-way.
-            await this.stop();
-            throw e;
+      } catch (e) {
+        logger.warn(
+          "Intercom PCM->ADPCM pipeline error",
+          e?.message || String(e),
+        );
+      } finally {
+        this.pumping = false;
+      }
+    })();
+  }
+
+  private buildFfmpegPcmArgs(
+    ffmpegInput: FFmpegInput,
+    options: {
+      sampleRate: number;
+      channels: number;
+      gain?: number;
+      logger?: any;
+    },
+  ): string[] {
+    const inputArgs = ffmpegInput.inputArguments ?? [];
+
+    // FFmpegInput may already contain one or more "-i" entries.
+    // For intercom decode, we only need a single input and only the first audio stream.
+    const sanitizedArgs: string[] = [];
+    let chosenInput: string | undefined;
+
+    for (let i = 0; i < inputArgs.length; i++) {
+      const arg = inputArgs[i];
+      if (arg === "-i") {
+        const maybeUrl = inputArgs[i + 1];
+        if (typeof maybeUrl === "string") {
+          if (!chosenInput) {
+            chosenInput = maybeUrl;
+          }
+          // Skip all inputs after the first.
+          i++;
+          continue;
         }
-    }
-
-    stop(): Promise<void> {
-        if (this.stopping) return this.stopping;
-
-        this.stopping = (async () => {
-            const logger = this.camera.getBaichuanLogger();
-
-            const ffmpeg = this.ffmpeg;
-            this.ffmpeg = undefined;
-
-            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));
-
-            if (ffmpeg && ffmpeg.exitCode == null) {
-                try {
-                    ffmpeg.kill("SIGKILL");
-                }
-                catch {
-                    // ignore
-                }
-
-                try {
-                    await Promise.race([
-                        new Promise<void>((resolve) => ffmpeg.once("exit", () => resolve())),
-                        sleepMs(1000),
-                    ]);
-                }
-                catch {
-                    // ignore
-                }
-            }
-
-            try {
-                await Promise.race([this.pumpPromise ?? Promise.resolve(), sleepMs(250)]);
-            }
-            catch {
-                // ignore
-            }
-            this.pumpPromise = undefined;
-
-            if (session) {
-                try {
-                    await Promise.race([session.stop(), sleepMs(2000)]);
-                }
-                catch (e) {
-                    logger.warn("Intercom session stop error", e?.message || String(e));
-                }
-            }
-
-            // Socket teardown is handled by session.stop() (closeSocketOnStop).
-            // Fallback cleanup: if we never created a session but we did create a dedicated client,
-            // ensure it doesn't leak.
-            if (!session && 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;
-        });
+      }
 
-        return this.stopping;
+      sanitizedArgs.push(arg);
     }
 
-    private clamp16(x: number): number {
-        if (x > 32767) return 32767;
-        if (x < -32768) return -32768;
-        return x | 0;
+    const url = chosenInput ?? ffmpegInput.url;
+    if (!url) {
+      throw new Error("FFmpegInput missing url/input");
     }
 
-    private enqueuePcm(
-        session: Awaited<ReturnType<ReolinkBaichuanApi["createTalkSession"]>>,
-        pcmChunk: Buffer,
-        bytesNeeded: number,
-        blockSize: number,
-    ): void {
-        const logger = this.camera.getBaichuanLogger();
-
-        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,
-                });
-            }
+    const gain = options.gain ?? 1.0;
+    const hasExistingAudioFilter =
+      sanitizedArgs.includes("-af") ||
+      sanitizedArgs.includes("-filter:a") ||
+      sanitizedArgs.includes("-filter_complex");
+    const gainArgs =
+      gain !== 1.0
+        ? hasExistingAudioFilter
+          ? (options.logger?.warn?.(
+              "Intercom gain skipped: FFmpegInput already contains audio filters",
+            ) ?? undefined,
+            [])
+          : ["-filter:a", `volume=${gain}`]
+        : [];
+
+    return [
+      ...sanitizedArgs,
+      "-i",
+      url,
+      // Ensure we only decode the first input's audio stream.
+      "-map",
+      "0:a:0?",
+
+      // Low-latency decode settings.
+      "-fflags",
+      "nobuffer",
+      "-flags",
+      "low_delay",
+      "-flush_packets",
+      "1",
+
+      "-vn",
+      "-sn",
+      "-dn",
+      ...gainArgs,
+      "-acodec",
+      "pcm_s16le",
+      "-ar",
+      options.sampleRate.toString(),
+      "-ac",
+      options.channels.toString(),
+      "-f",
+      "s16le",
+      "pipe:1",
+    ];
+  }
+
+  private encodeImaAdpcm(pcm: Int16Array, blockSizeBytes: number): Buffer {
+    const samplesPerBlock = blockSizeBytes * 2 + 1;
+    const totalBlocks = Math.ceil(pcm.length / samplesPerBlock);
+    const outBlocks: Buffer[] = [];
+
+    const imaIndexTable = Int8Array.from([
+      -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8,
+    ]);
+
+    const imaStepTable = Int16Array.from([
+      7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41,
+      45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190,
+      209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
+      876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499,
+      2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845,
+      8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385,
+      24623, 27086, 29794, 32767,
+    ]);
+
+    let sampleIndex = 0;
+
+    for (let b = 0; b < totalBlocks; b++) {
+      const block = Buffer.alloc(4 + blockSizeBytes);
+
+      // Block header
+      const first = pcm[sampleIndex] ?? 0;
+      let predictor = first;
+      let index = 0;
+
+      block.writeInt16LE(predictor, 0);
+      block.writeUInt8(index, 2);
+      block.writeUInt8(0, 3);
+
+      sampleIndex++;
+
+      // Encode samples into nibbles
+      const codes = new Uint8Array(blockSizeBytes * 2);
+      for (let i = 0; i < codes.length; i++) {
+        const sample = pcm[sampleIndex] ?? predictor;
+        sampleIndex++;
+
+        let diff = sample - predictor;
+        let sign = 0;
+        if (diff < 0) {
+          sign = 8;
+          diff = -diff;
         }
 
-        if (this.pumping) return;
-
-        this.pumping = true;
-        this.pumpPromise = (async () => {
-            try {
-                while (true) {
-                    if (this.session !== session) return;
-                    if (this.pcmBuffer.length < bytesNeeded) return;
-
-                    const chunk = this.pcmBuffer.subarray(0, bytesNeeded);
-                    this.pcmBuffer = this.pcmBuffer.subarray(bytesNeeded);
-
-                    const pcmSamples = new Int16Array(
-                        chunk.buffer,
-                        chunk.byteOffset,
-                        chunk.length / 2,
-                    );
-
-                    const adpcmChunk = this.encodeImaAdpcm(pcmSamples, blockSize);
-                    await session.sendAudio(adpcmChunk);
-                }
-            }
-            catch (e) {
-                logger.warn("Intercom PCM->ADPCM pipeline error", e?.message || String(e));
-            }
-            finally {
-                this.pumping = false;
-            }
-        })();
-    }
+        let step = imaStepTable[index] ?? 7;
+        let delta = 0;
+        let vpdiff = step >> 3;
 
-    private buildFfmpegPcmArgs(
-        ffmpegInput: FFmpegInput,
-        options: {
-            sampleRate: number;
-            channels: number;
-            gain?: number;
-            logger?: any;
-        },
-    ): string[] {
-        const inputArgs = ffmpegInput.inputArguments ?? [];
-
-        // FFmpegInput may already contain one or more "-i" entries.
-        // For intercom decode, we only need a single input and only the first audio stream.
-        const sanitizedArgs: string[] = [];
-        let chosenInput: string | undefined;
-
-        for (let i = 0; i < inputArgs.length; i++) {
-            const arg = inputArgs[i];
-            if (arg === "-i") {
-                const maybeUrl = inputArgs[i + 1];
-                if (typeof maybeUrl === "string") {
-                    if (!chosenInput) {
-                        chosenInput = maybeUrl;
-                    }
-                    // Skip all inputs after the first.
-                    i++;
-                    continue;
-                }
-            }
-
-            sanitizedArgs.push(arg);
+        if (diff >= step) {
+          delta |= 4;
+          diff -= step;
+          vpdiff += step;
         }
-
-        const url = chosenInput ?? ffmpegInput.url;
-        if (!url) {
-            throw new Error("FFmpegInput missing url/input");
+        step >>= 1;
+        if (diff >= step) {
+          delta |= 2;
+          diff -= step;
+          vpdiff += step;
+        }
+        step >>= 1;
+        if (diff >= step) {
+          delta |= 1;
+          vpdiff += step;
         }
 
-        const gain = options.gain ?? 1.0;
-        const hasExistingAudioFilter = sanitizedArgs.includes("-af") || sanitizedArgs.includes("-filter:a") || sanitizedArgs.includes("-filter_complex");
-        const gainArgs = (gain !== 1.0)
-            ? (
-                hasExistingAudioFilter
-                    ? (options.logger?.warn?.("Intercom gain skipped: FFmpegInput already contains audio filters") ?? undefined, [])
-                    : ["-filter:a", `volume=${gain}`]
-            )
-            : [];
-
-        return [
-            ...sanitizedArgs,
-            "-i", url,
-            // Ensure we only decode the first input's audio stream.
-            "-map", "0:a:0?",
-
-            // Low-latency decode settings.
-            "-fflags", "nobuffer",
-            "-flags", "low_delay",
-            "-flush_packets", "1",
-
-            "-vn", "-sn", "-dn",
-            ...gainArgs,
-            "-acodec", "pcm_s16le",
-            "-ar", options.sampleRate.toString(),
-            "-ac", options.channels.toString(),
-            "-f", "s16le",
-            "pipe:1",
-        ];
-    }
+        if (sign) predictor -= vpdiff;
+        else predictor += vpdiff;
 
-    private encodeImaAdpcm(pcm: Int16Array, blockSizeBytes: number): Buffer {
-        const samplesPerBlock = blockSizeBytes * 2 + 1;
-        const totalBlocks = Math.ceil(pcm.length / samplesPerBlock);
-        const outBlocks: Buffer[] = [];
+        predictor = this.clamp16(predictor);
 
-        const imaIndexTable = Int8Array.from([
-            -1, -1, -1, -1, 2, 4, 6, 8,
-            -1, -1, -1, -1, 2, 4, 6, 8,
-        ]);
+        index += imaIndexTable[delta] ?? 0;
+        if (index < 0) index = 0;
+        if (index > 88) index = 88;
 
-        const imaStepTable = Int16Array.from([
-            7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
-            19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
-            50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
-            130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
-            337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
-            876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
-            2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
-            5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
-            15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767,
-        ]);
+        codes[i] = (delta | sign) & 0x0f;
+      }
 
-        let sampleIndex = 0;
-
-        for (let b = 0; b < totalBlocks; b++) {
-            const block = Buffer.alloc(4 + blockSizeBytes);
-
-            // Block header
-            const first = pcm[sampleIndex] ?? 0;
-            let predictor = first;
-            let index = 0;
-
-            block.writeInt16LE(predictor, 0);
-            block.writeUInt8(index, 2);
-            block.writeUInt8(0, 3);
-
-            sampleIndex++;
-
-            // Encode samples into nibbles
-            const codes = new Uint8Array(blockSizeBytes * 2);
-            for (let i = 0; i < codes.length; i++) {
-                const sample = pcm[sampleIndex] ?? predictor;
-                sampleIndex++;
-
-                let diff = sample - predictor;
-                let sign = 0;
-                if (diff < 0) {
-                    sign = 8;
-                    diff = -diff;
-                }
-
-                let step = imaStepTable[index] ?? 7;
-                let delta = 0;
-                let vpdiff = step >> 3;
-
-                if (diff >= step) {
-                    delta |= 4;
-                    diff -= step;
-                    vpdiff += step;
-                }
-                step >>= 1;
-                if (diff >= step) {
-                    delta |= 2;
-                    diff -= step;
-                    vpdiff += step;
-                }
-                step >>= 1;
-                if (diff >= step) {
-                    delta |= 1;
-                    vpdiff += step;
-                }
-
-                if (sign) predictor -= vpdiff;
-                else predictor += vpdiff;
-
-                predictor = this.clamp16(predictor);
-
-                index += imaIndexTable[delta] ?? 0;
-                if (index < 0) index = 0;
-                if (index > 88) index = 88;
-
-                codes[i] = (delta | sign) & 0x0f;
-            }
-
-            // Pack nibble: low nibble first, then high nibble
-            for (let i = 0; i < blockSizeBytes; i++) {
-                const lo = codes[i * 2] ?? 0;
-                const hi = codes[i * 2 + 1] ?? 0;
-                block[4 + i] = (lo & 0x0f) | ((hi & 0x0f) << 4);
-            }
-
-            outBlocks.push(block);
-        }
+      // Pack nibble: low nibble first, then high nibble
+      for (let i = 0; i < blockSizeBytes; i++) {
+        const lo = codes[i * 2] ?? 0;
+        const hi = codes[i * 2 + 1] ?? 0;
+        block[4 + i] = (lo & 0x0f) | ((hi & 0x0f) << 4);
+      }
 
-        return Buffer.concat(outBlocks);
+      outBlocks.push(block);
     }
+
+    return Buffer.concat(outBlocks);
+  }
 }