@apocaliss92/nodelink-js 0.4.35 → 0.4.36

package/dist/index.cjs

@@ -8310,6 +8310,7 @@ __export(index_exports, {
   BaichuanHlsServer: () => BaichuanHlsServer,
   BaichuanHttpStreamServer: () => BaichuanHttpStreamServer,
   BaichuanMjpegServer: () => BaichuanMjpegServer,
+  BaichuanRtspBackchannelServer: () => BaichuanRtspBackchannelServer,
   BaichuanRtspServer: () => BaichuanRtspServer,
   BaichuanVideoStream: () => BaichuanVideoStream,
   BaichuanWebRTCServer: () => BaichuanWebRTCServer,
@@ -8335,10 +8336,12 @@ __export(index_exports, {
   ReolinkCgiApi: () => ReolinkCgiApi,
   ReolinkHttpClient: () => ReolinkHttpClient,
   Rfc4571Muxer: () => Rfc4571Muxer,
+  RtspBackchannel: () => RtspBackchannel,
   _resetEmailPushBusForTests: () => _resetEmailPushBusForTests,
   abilitiesHasAny: () => abilitiesHasAny,
   aesDecrypt: () => aesDecrypt,
   aesEncrypt: () => aesEncrypt,
+  alawToPcm16: () => alawToPcm16,
   applyStreamPatch: () => applyStreamPatch,
   applyXmlTagPatch: () => applyXmlTagPatch,
   asLogger: () => asLogger,
@@ -8411,6 +8414,7 @@ __export(index_exports, {
   discoverViaUdpDirect: () => discoverViaUdpDirect,
   emitEmailPushEvent: () => emitEmailPushEvent,
   encodeHeader: () => encodeHeader,
+  encodeImaAdpcm: () => encodeImaAdpcm,
   encodeMotionScopeBitmap: () => encodeMotionScopeBitmap,
   encodeMotionSensitivityListXml: () => encodeMotionSensitivityListXml,
   encodeShelterCoord: () => encodeShelterCoord,
@@ -8453,6 +8457,7 @@ __export(index_exports, {
   maskUid: () => maskUid,
   md5HexUpper: () => md5HexUpper,
   md5StrModern: () => md5StrModern,
+  mulawToPcm16: () => mulawToPcm16,
   normalizeDayNightMode: () => normalizeDayNightMode,
   normalizeOpenClose: () => normalizeOpenClose,
   normalizeUid: () => normalizeUid,
@@ -8464,6 +8469,7 @@ __export(index_exports, {
   parseAdtsHeader: () => parseAdtsHeader,
   parseBcMedia: () => parseBcMedia,
   parseRecordingFileName: () => parseRecordingFileName,
+  parseRtpPacket: () => parseRtpPacket,
   parseSupportXml: () => parseSupportXml,
   patchAiDetectCfgXml: () => patchAiDetectCfgXml,
   patchMotionSensitivityListXml: () => patchMotionSensitivityListXml,
@@ -8481,6 +8487,7 @@ __export(index_exports, {
   splitAnnexBToNals: () => splitAnnexBToNals,
   splitH265AnnexBToNalPayloads: () => splitAnnexBToNalPayloads2,
   testChannelStreams: () => testChannelStreams,
+  upsamplePcm16: () => upsamplePcm16,
   upsertXmlTag: () => upsertXmlTag,
   xmlEscape: () => xmlEscape,
   xmlIndicatesFloodlight: () => xmlIndicatesFloodlight,
@@ -27576,8 +27583,18 @@ ${xml}`
    * This is more reliable than autoPt in SupportInfo which can be a false positive
    * (e.g., NVR channels report autoPt=1 but don't actually support autotracking).
    *
+   * Doorbell exception (mirrors the {@link computeDeviceCapabilities} floodlight
+   * rule): video-doorbell firmwares (doorbellVersion > 0) ship AiCfg with
+   * `smartTrackMode=1` (the current mode) yet `smartTrackModeAbility=0` (the
+   * firmware's own "no, this device cannot autotrack" flag). Without a PT
+   * motor a doorbell physically cannot autotrack, so when the caller flags the
+   * device as a doorbell AND the firmware admits `smartTrackModeAbility=0`,
+   * trust the firmware and return false. Verified against UID
+   * 9527000ICL1T1MDS: smartTrackMode=1, smartTrackModeAbility=0,
+   * ptzType=0, ptzMode="none", doorbellVersion=31.
+   *
    * @param channel - Channel number (0-based)
-   * @param options - Optional timeout
+   * @param options - Optional timeout and doorbell context hint
    * @returns true if autotracking is supported, false otherwise
    */
   async probeAutotrackingSupport(channel, options) {
@@ -27587,6 +27604,14 @@ ${xml}`
       const xml = await this.sendXml({ cmdId: 299, channel: ch, timeoutMs });
       const smartTrackModeRaw = getXmlText(xml, "smartTrackMode");
       const smartTrackMode = Number(smartTrackModeRaw ?? 0);
+      const smartTrackModeAbilityRaw = getXmlText(
+        xml,
+        "smartTrackModeAbility"
+      );
+      const smartTrackModeAbility = smartTrackModeAbilityRaw === void 0 ? void 0 : Number(smartTrackModeAbilityRaw);
+      if (options?.isDoorbell && Number.isFinite(smartTrackModeAbility) && smartTrackModeAbility === 0) {
+        return false;
+      }
       return smartTrackMode > 0;
     } catch {
       return false;
@@ -27679,7 +27704,8 @@ ${xml}`
     const features = this.parseFeaturesFromSupport(support);
     const objects = await this.getAiDetectTypes(ch, { timeoutMs: 1500 });
     const autotrackingProbed = await this.probeAutotrackingSupport(ch, {
-      timeoutMs: 1500
+      timeoutMs: 1500,
+      isDoorbell: capabilities.isDoorbell === true
     });
     capabilities.hasAutotracking = autotrackingProbed;
     let presets;
@@ -31013,10 +31039,10 @@ ${scheduleItems}
     const os2 = await import("os");
     const path7 = await import("path");
     const fs7 = await import("fs/promises");
-    const crypto3 = await import("crypto");
+    const crypto4 = await import("crypto");
     const tempDir = path7.join(
       os2.tmpdir(),
-      `reolink-hls-${crypto3.randomBytes(8).toString("hex")}`
+      `reolink-hls-${crypto4.randomBytes(8).toString("hex")}`
     );
     await fs7.mkdir(tempDir, { recursive: true });
     const playlistPath = path7.join(tempDir, "playlist.m3u8");
@@ -41147,6 +41173,946 @@ function base64DecodeToBytes(b64) {
   return out.subarray(0, outIdx);
 }
 
+// src/reolink/baichuan/utils/imaAdpcm.ts
+var IMA_INDEX_TABLE = [
+  -1,
+  -1,
+  -1,
+  -1,
+  2,
+  4,
+  6,
+  8,
+  -1,
+  -1,
+  -1,
+  -1,
+  2,
+  4,
+  6,
+  8
+];
+var IMA_STEP_TABLE = [
+  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
+];
+function clamp16(x) {
+  if (x > 32767) return 32767;
+  if (x < -32768) return -32768;
+  return x | 0;
+}
+function encodeImaAdpcm(pcm, blockSizeBytes) {
+  if (pcm.length === 0) return Buffer.alloc(0);
+  if (!Number.isInteger(blockSizeBytes) || blockSizeBytes <= 0) {
+    throw new RangeError(
+      `encodeImaAdpcm: blockSizeBytes must be a positive integer, got ${blockSizeBytes}`
+    );
+  }
+  const samplesPerBlock = blockSizeBytes * 2 + 1;
+  const totalBlocks = Math.ceil(pcm.length / samplesPerBlock);
+  const out = Buffer.alloc(totalBlocks * (4 + blockSizeBytes));
+  let sampleIndex = 0;
+  let outOffset = 0;
+  for (let b = 0; b < totalBlocks; b++) {
+    const blockStart = outOffset;
+    const first = pcm[sampleIndex] ?? 0;
+    let predictor = first;
+    let index = 0;
+    out.writeInt16LE(predictor, blockStart);
+    out.writeUInt8(index, blockStart + 2);
+    out.writeUInt8(0, blockStart + 3);
+    sampleIndex++;
+    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 = IMA_STEP_TABLE[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;
+      }
+      predictor = clamp16(sign ? predictor - vpdiff : predictor + vpdiff);
+      index += IMA_INDEX_TABLE[delta] ?? 0;
+      if (index < 0) index = 0;
+      if (index > 88) index = 88;
+      codes[i] = (delta | sign) & 15;
+    }
+    for (let i = 0; i < blockSizeBytes; i++) {
+      const lo = codes[i * 2] ?? 0;
+      const hi = codes[i * 2 + 1] ?? 0;
+      out[blockStart + 4 + i] = lo & 15 | (hi & 15) << 4;
+    }
+    outOffset += 4 + blockSizeBytes;
+  }
+  return out;
+}
+
+// src/reolink/baichuan/utils/audioMulaw.ts
+var import_alawmulaw = require("alawmulaw");
+function mulawToPcm16(bytes) {
+  if (bytes.length === 0) return new Int16Array(0);
+  return import_alawmulaw.mulaw.decode(bytes);
+}
+function alawToPcm16(bytes) {
+  if (bytes.length === 0) return new Int16Array(0);
+  return import_alawmulaw.alaw.decode(bytes);
+}
+
+// src/reolink/baichuan/utils/audioResample.ts
+function clamp162(x) {
+  if (x > 32767) return 32767;
+  if (x < -32768) return -32768;
+  return x | 0;
+}
+function upsamplePcm16(src, factor) {
+  if (!Number.isInteger(factor) || factor < 1) {
+    throw new RangeError(
+      `upsamplePcm16: factor must be a positive integer, got ${factor}`
+    );
+  }
+  if (src.length === 0) return new Int16Array(0);
+  if (factor === 1) return Int16Array.from(src);
+  const out = new Int16Array(src.length * factor);
+  const last = src.length - 1;
+  for (let i = 0; i < last; i++) {
+    const a = src[i];
+    const b = src[i + 1];
+    const base = i * factor;
+    for (let k = 0; k < factor; k++) {
+      const v = a + Math.round((b - a) * k / factor);
+      out[base + k] = clamp162(v);
+    }
+  }
+  const tail = src[last] | 0;
+  for (let k = 0; k < factor; k++) {
+    out[last * factor + k] = tail;
+  }
+  return out;
+}
+
+// src/baichuan/stream/RtspBackchannel.ts
+var RTP_PT_PCMA = 8;
+var RTP_FIXED_HEADER_BYTES = 12;
+var G711_SOURCE_RATE_HZ = 8e3;
+var TALK_TARGET_RATE_HZ = 16e3;
+function parseRtpPacket(packet) {
+  if (packet.length < RTP_FIXED_HEADER_BYTES) return null;
+  const b0 = packet.readUInt8(0);
+  const version = b0 >> 6;
+  if (version !== 2) return null;
+  const padding = (b0 & 32) !== 0;
+  const extension = (b0 & 16) !== 0;
+  const csrcCount = b0 & 15;
+  const b1 = packet.readUInt8(1);
+  const payloadType = b1 & 127;
+  let offset = RTP_FIXED_HEADER_BYTES + csrcCount * 4;
+  if (offset > packet.length) return null;
+  if (extension) {
+    if (offset + 4 > packet.length) return null;
+    const extensionLengthWords = packet.readUInt16BE(offset + 2);
+    offset += 4 + extensionLengthWords * 4;
+    if (offset > packet.length) return null;
+  }
+  let end = packet.length;
+  if (padding) {
+    if (end - offset < 1) return null;
+    const padLength = packet.readUInt8(end - 1);
+    if (padLength < 1 || padLength > end - offset) return null;
+    end -= padLength;
+  }
+  if (end <= offset) return null;
+  return {
+    payloadType,
+    payload: packet.subarray(offset, end)
+  };
+}
+var RtspBackchannel = class _RtspBackchannel {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  session = void 0;
+  pcmTail = new Int16Array(0);
+  // residual samples below one full ADPCM block
+  pcmBacklogBytes = 0;
+  pumping = false;
+  active = false;
+  starting = void 0;
+  stopping = void 0;
+  lastBacklogClampLogMs = 0;
+  rtpPacketsReceived = 0;
+  rtpPacketsDropped = 0;
+  adpcmBlocksSent = 0;
+  /** Lazily-set on the first decoded RTP packet so we log the negotiated codec exactly once. */
+  observedCodec = void 0;
+  /** Sampled every `STATS_LOG_INTERVAL_MS` while audio flows. */
+  lastStatsLogMs = 0;
+  lastStatsAdpcmBlocks = 0;
+  lastStatsRtpPackets = 0;
+  startedAtMs = 0;
+  static STATS_LOG_INTERVAL_MS = 5e3;
+  get isActive() {
+    return this.active;
+  }
+  get stats() {
+    return {
+      rtpPacketsReceived: this.rtpPacketsReceived,
+      rtpPacketsDropped: this.rtpPacketsDropped,
+      adpcmBlocksSent: this.adpcmBlocksSent
+    };
+  }
+  /** Open the underlying TalkSession. Safe to call concurrently; resolves to the same session. */
+  async start() {
+    if (this.session) return this.session;
+    if (!this.starting) {
+      const openStart = Date.now();
+      this.opts.logger?.log?.(
+        `[RtspBackchannel] opening TalkSession on camera\u2026`
+      );
+      this.starting = (async () => {
+        const s = await this.opts.openTalkSession();
+        this.session = s;
+        this.active = true;
+        this.startedAtMs = Date.now();
+        this.lastStatsLogMs = this.startedAtMs;
+        this.opts.logger?.log?.(
+          `[RtspBackchannel] TalkSession opened channel=${s.info.channel} block=${s.info.blockSize} fullBlock=${s.info.fullBlockSize} audioType=${s.info.audioConfig.audioType} sampleRate=${s.info.audioConfig.sampleRate} samplePrecision=${s.info.audioConfig.samplePrecision} soundTrack=${s.info.audioConfig.soundTrack} openMs=${Date.now() - openStart}`
+        );
+        return s;
+      })().catch((e) => {
+        this.starting = void 0;
+        this.opts.logger?.log?.(
+          `[RtspBackchannel] TalkSession open FAILED openMs=${Date.now() - openStart} error="${e.message}"`
+        );
+        throw e;
+      });
+    }
+    return this.starting;
+  }
+  /**
+   * Feed one inbound RTP packet (as carried in TCP-interleaved framing or UDP
+   * datagram). Discards malformed packets and packets received before `start()`.
+   * The actual audio dispatch to the TalkSession is awaited internally; callers
+   * may fire-and-forget.
+   */
+  feedRtp(packet) {
+    this.rtpPacketsReceived++;
+    if (!this.active || !this.session) {
+      this.rtpPacketsDropped++;
+      if (this.rtpPacketsDropped === 1) {
+        this.opts.logger?.log?.(
+          `[RtspBackchannel] dropping RTP packets \u2014 session not active yet (received ${packet.length}B before start())`
+        );
+      }
+      return;
+    }
+    const parsed = parseRtpPacket(packet);
+    if (!parsed) {
+      this.rtpPacketsDropped++;
+      this.opts.logger?.log?.(
+        `[RtspBackchannel] malformed RTP packet \u2014 dropping (len=${packet.length} firstByte=0x${packet.length ? (packet[0] ?? 0).toString(16) : "??"})`
+      );
+      return;
+    }
+    const codec = this.opts.forceCodec ?? (parsed.payloadType === RTP_PT_PCMA ? "pcma" : "pcmu");
+    if (this.observedCodec === void 0) {
+      this.observedCodec = codec;
+      const firstPacketMs = Date.now() - this.startedAtMs;
+      this.opts.logger?.log?.(
+        `[RtspBackchannel] first RTP packet \u2014 codec=${codec} payloadType=${parsed.payloadType} payload=${parsed.payload.length}B firstByteMs=${firstPacketMs}` + (this.opts.forceCodec ? " (forced by config)" : "")
+      );
+    } else if (codec !== this.observedCodec) {
+      this.opts.logger?.log?.(
+        `[RtspBackchannel] codec switched mid-stream ${this.observedCodec} \u2192 ${codec} (payloadType=${parsed.payloadType})`
+      );
+      this.observedCodec = codec;
+    }
+    const decoded = codec === "pcma" ? alawToPcm16(parsed.payload) : mulawToPcm16(parsed.payload);
+    if (decoded.length === 0) return;
+    const upsampled = upsamplePcm16(decoded, TALK_TARGET_RATE_HZ / G711_SOURCE_RATE_HZ);
+    this.enqueuePcm(upsampled);
+    this.maybeLogStats();
+  }
+  /**
+   * Throttled progress log (~every 5s while audio is flowing) so operators
+   * can confirm the pipeline is making progress without per-packet noise.
+   */
+  maybeLogStats() {
+    const now = Date.now();
+    if (now - this.lastStatsLogMs < _RtspBackchannel.STATS_LOG_INTERVAL_MS) return;
+    const elapsedSec = (now - this.lastStatsLogMs) / 1e3;
+    const rtpDelta = this.rtpPacketsReceived - this.lastStatsRtpPackets;
+    const adpcmDelta = this.adpcmBlocksSent - this.lastStatsAdpcmBlocks;
+    this.lastStatsLogMs = now;
+    this.lastStatsRtpPackets = this.rtpPacketsReceived;
+    this.lastStatsAdpcmBlocks = this.adpcmBlocksSent;
+    this.opts.logger?.log?.(
+      `[RtspBackchannel] stats codec=${this.observedCodec ?? "?"} rtpRx=${this.rtpPacketsReceived} (+${rtpDelta} in ${elapsedSec.toFixed(1)}s) dropped=${this.rtpPacketsDropped} adpcmBlocks=${this.adpcmBlocksSent} (+${adpcmDelta}) pcmBacklog=${this.pcmBacklogBytes}B`
+    );
+  }
+  /** Flush remaining audio and stop the talk session. Idempotent. */
+  async stop() {
+    if (this.stopping) return this.stopping;
+    this.active = false;
+    this.stopping = (async () => {
+      const s = this.session;
+      this.session = void 0;
+      this.pcmTail = new Int16Array(0);
+      this.pcmBacklogBytes = 0;
+      const durationMs = this.startedAtMs ? Date.now() - this.startedAtMs : 0;
+      this.opts.logger?.log?.(
+        `[RtspBackchannel] closing TalkSession durationMs=${durationMs} rtpRx=${this.rtpPacketsReceived} rtpDropped=${this.rtpPacketsDropped} adpcmBlocks=${this.adpcmBlocksSent} pcmBacklogResidual=${this.pcmBacklogBytes}B codec=${this.observedCodec ?? "(none)"}`
+      );
+      if (s) {
+        try {
+          await s.stop();
+        } catch (e) {
+          this.opts.logger?.log?.(
+            `[RtspBackchannel] TalkSession stop error: ${e.message}`
+          );
+        }
+      }
+    })();
+    return this.stopping;
+  }
+  enqueuePcm(chunk) {
+    if (chunk.length === 0) return;
+    const tailLen = this.pcmTail.length;
+    const merged = new Int16Array(tailLen + chunk.length);
+    merged.set(this.pcmTail, 0);
+    merged.set(chunk, tailLen);
+    this.pcmBacklogBytes = merged.length * 2;
+    const maxBytes = Math.max(2, this.opts.maxPcmBacklogBytes ?? 96e3);
+    if (this.pcmBacklogBytes > maxBytes) {
+      const keepSamples = Math.floor(maxBytes / 2);
+      const dropSamples = merged.length - keepSamples;
+      this.pcmTail = merged.subarray(merged.length - keepSamples);
+      this.pcmBacklogBytes = this.pcmTail.length * 2;
+      const now = Date.now();
+      if (now - this.lastBacklogClampLogMs > 2e3) {
+        this.lastBacklogClampLogMs = now;
+        this.opts.logger?.log?.(
+          `[RtspBackchannel] PCM backlog clamped \u2014 dropped ${dropSamples} samples, kept ${keepSamples}`
+        );
+      }
+    } else {
+      this.pcmTail = merged;
+    }
+    void this.pumpAdpcm();
+  }
+  async pumpAdpcm() {
+    if (this.pumping) return;
+    const session = this.session;
+    if (!session) return;
+    this.pumping = true;
+    try {
+      const samplesPerBlock = session.info.blockSize * 2 + 1;
+      const blockSizeBytes = session.info.blockSize;
+      while (this.active && this.pcmTail.length >= samplesPerBlock) {
+        const consumeSamples = Math.floor(this.pcmTail.length / samplesPerBlock) * samplesPerBlock;
+        const head = this.pcmTail.subarray(0, consumeSamples);
+        const adpcm = encodeImaAdpcm(head, blockSizeBytes);
+        const blocksInBatch = consumeSamples / samplesPerBlock;
+        this.pcmTail = this.pcmTail.slice(consumeSamples);
+        this.pcmBacklogBytes = this.pcmTail.length * 2;
+        try {
+          await session.sendAudio(adpcm);
+          this.adpcmBlocksSent += blocksInBatch;
+        } catch (e) {
+          this.opts.logger?.log?.(
+            `[RtspBackchannel] sendAudio FAILED \u2014 disabling pipeline blocksInBatch=${blocksInBatch} adpcmBytes=${adpcm.length} pcmBacklogBefore=${this.pcmBacklogBytes + adpcm.length}B error="${e.message}"`
+          );
+          this.pcmTail = new Int16Array(0);
+          this.pcmBacklogBytes = 0;
+          this.active = false;
+          break;
+        }
+      }
+    } finally {
+      this.pumping = false;
+    }
+  }
+};
+
+// src/baichuan/stream/BaichuanRtspBackchannelServer.ts
+var import_node_events15 = require("events");
+var net6 = __toESM(require("net"), 1);
+var crypto3 = __toESM(require("crypto"), 1);
+var md5Hex = (s) => crypto3.createHash("md5").update(s).digest("hex");
+var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends import_node_events15.EventEmitter {
+  api;
+  channel;
+  listenHost;
+  listenPort;
+  path;
+  logger;
+  authCredentials;
+  requireAuth;
+  authRealm;
+  deviceId;
+  server = void 0;
+  /** Active backchannel sessions keyed by their per-client unique id. */
+  sessionByClient = /* @__PURE__ */ new Map();
+  nonces = /* @__PURE__ */ new Map();
+  static NONCE_TTL_MS = 5 * 60 * 1e3;
+  constructor(options) {
+    super();
+    this.api = options.api;
+    this.channel = options.channel;
+    this.listenHost = options.listenHost ?? "127.0.0.1";
+    this.listenPort = options.listenPort ?? 8555;
+    this.path = options.path ?? "/talk";
+    this.logger = options.logger ?? console;
+    this.authCredentials = (options.credentials ?? []).map((c) => ({
+      username: c.username,
+      ...c.password !== void 0 ? { password: c.password } : {},
+      ...c.ha1 !== void 0 ? { ha1: c.ha1 } : {}
+    }));
+    this.requireAuth = options.requireAuth ?? this.authCredentials.length > 0;
+    this.authRealm = options.authRealm ?? "BaichuanRtspBackchannelServer";
+    this.deviceId = options.deviceId;
+  }
+  get listening() {
+    return this.server !== void 0 && this.server.listening;
+  }
+  async start() {
+    if (this.server) return;
+    await new Promise((resolve, reject) => {
+      const server = net6.createServer((socket) => this.handleConnection(socket));
+      const onError = (err) => {
+        server.removeListener("error", onError);
+        reject(err);
+      };
+      server.once("error", onError);
+      server.listen(this.listenPort, this.listenHost, () => {
+        server.removeListener("error", onError);
+        this.server = server;
+        this.logger.info?.(
+          `[BaichuanRtspBackchannelServer] listening on ${this.listenHost}:${this.listenPort} path=${this.path}`
+        );
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    const server = this.server;
+    this.server = void 0;
+    for (const session of this.sessionByClient.values()) {
+      this.sessionByClient.delete(session.clientId);
+      if (session.handler) {
+        void session.handler.stop();
+      }
+      try {
+        session.socket.destroy();
+      } catch {
+      }
+    }
+    if (!server) return;
+    await new Promise((resolve) => {
+      server.close(() => resolve());
+    });
+  }
+  handleConnection(socket) {
+    const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
+    const connectedAt = Date.now();
+    let buffer = Buffer.alloc(0);
+    this.logger.info?.(
+      `[BaichuanRtspBackchannelServer] client connected client=${clientId} path=${this.path}`
+    );
+    this.emit("client", clientId);
+    const cleanup = () => {
+      const session = this.sessionByClient.get(clientId);
+      const durationMs = Date.now() - connectedAt;
+      if (session) {
+        this.sessionByClient.delete(clientId);
+        if (session.handler) {
+          const stats = session.handler.stats;
+          this.logger.info?.(
+            `[BaichuanRtspBackchannelServer] client disconnected client=${clientId} session=${session.sessionId} duration=${durationMs}ms rtpRx=${stats.rtpPacketsReceived} rtpDropped=${stats.rtpPacketsDropped} adpcmBlocks=${stats.adpcmBlocksSent}`
+          );
+          void session.handler.stop();
+        } else {
+          this.logger.info?.(
+            `[BaichuanRtspBackchannelServer] client disconnected client=${clientId} session=${session.sessionId} duration=${durationMs}ms (no RECORD)`
+          );
+        }
+      } else {
+        this.logger.info?.(
+          `[BaichuanRtspBackchannelServer] client disconnected client=${clientId} duration=${durationMs}ms (no SETUP)`
+        );
+      }
+      this.nonces.delete(clientId);
+      this.emit("clientDisconnected", clientId);
+    };
+    socket.on("close", cleanup);
+    socket.on("error", (err) => {
+      this.logger.warn?.(
+        `[BaichuanRtspBackchannelServer] socket error client=${clientId}: ${err.message}`
+      );
+      cleanup();
+    });
+    socket.on("data", (data) => {
+      buffer = Buffer.concat([buffer, data]);
+      this.drainBuffer(socket, clientId, (b) => {
+        buffer = b;
+      }, () => buffer);
+    });
+  }
+  /**
+   * Drain pending bytes from the per-client buffer. Each iteration first
+   * peels off any TCP-interleaved `$` frames at the head (routing them to
+   * the session's RtspBackchannel handler when their channel matches) and
+   * then attempts to parse a complete RTSP request.
+   *
+   * Implemented as a thin loop so the parser can yield back to the event
+   * loop when the buffer is partial — no async work between frames keeps
+   * the data path tight.
+   */
+  drainBuffer(socket, clientId, setBuffer, getBuffer) {
+    const tryDrainInterleaved = () => {
+      let consumed = false;
+      while (true) {
+        const buf = getBuffer();
+        if (buf.length === 0 || buf[0] !== 36) return consumed;
+        if (buf.length < 4) return consumed;
+        const channel = buf[1] ?? 0;
+        const len = buf.readUInt16BE(2);
+        if (buf.length < 4 + len) return consumed;
+        const rtpPacket = buf.subarray(4, 4 + len);
+        setBuffer(buf.subarray(4 + len));
+        consumed = true;
+        const session = this.sessionByClient.get(clientId);
+        if (session && session.rtpChannel === channel && session.handler) {
+          session.handler.feedRtp(Buffer.from(rtpPacket));
+        }
+      }
+    };
+    void (async () => {
+      while (true) {
+        tryDrainInterleaved();
+        const buf = getBuffer();
+        if (buf.length === 0) return;
+        if (buf[0] === 36) return;
+        const headerEnd = buf.indexOf("\r\n\r\n");
+        if (headerEnd < 0) return;
+        const requestText = buf.subarray(0, headerEnd).toString("utf8");
+        setBuffer(buf.subarray(headerEnd + 4));
+        try {
+          await this.handleRequest(socket, clientId, requestText);
+        } catch (e) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] handleRequest failed for ${clientId}: ${e.message}`
+          );
+          try {
+            socket.destroy();
+          } catch {
+          }
+          return;
+        }
+      }
+    })();
+  }
+  async handleRequest(socket, clientId, requestText) {
+    const lines = requestText.split("\r\n");
+    const head = lines[0]?.split(" ") ?? [];
+    if (head.length < 3) {
+      this.logger.warn?.(
+        `[BaichuanRtspBackchannelServer] malformed request from ${clientId}: "${(lines[0] ?? "").slice(0, 120)}"`
+      );
+      return;
+    }
+    const method = head[0] ?? "";
+    const url = head[1] ?? "";
+    const protocol = head[2] ?? "RTSP/1.0";
+    const cseqMatch = requestText.match(/CSeq:\s*(\d+)/i);
+    const cseq = cseqMatch ? parseInt(cseqMatch[1] ?? "0", 10) : 0;
+    const sessionMatch = requestText.match(/Session:\s*([^;\r\n]+)/i);
+    let sessionId = sessionMatch?.[1]?.trim();
+    const userAgent = requestText.match(/User-Agent:\s*([^\r\n]+)/i)?.[1]?.trim();
+    this.logger.info?.(
+      `[BaichuanRtspBackchannelServer] >> ${method} ${url} client=${clientId} cseq=${cseq}` + (sessionId ? ` session=${sessionId}` : "") + (userAgent ? ` ua="${userAgent}"` : "")
+    );
+    const send = (status, reason, headers = {}, body) => {
+      let r = `${protocol} ${status} ${reason}\r
+CSeq: ${cseq}\r
+`;
+      for (const [k, v] of Object.entries(headers)) {
+        r += `${k}: ${v}\r
+`;
+      }
+      if (body) {
+        const buf = Buffer.from(body, "utf8");
+        r += `Content-Length: ${buf.length}\r
+\r
+`;
+        socket.write(r);
+        socket.write(buf);
+      } else {
+        r += "\r\n";
+        socket.write(r);
+      }
+      const headerSummary = Object.entries(headers).map(([k, v]) => `${k}=${v}`).join(", ");
+      this.logger.info?.(
+        `[BaichuanRtspBackchannelServer] << ${status} ${reason} client=${clientId} cseq=${cseq}` + (headerSummary ? ` [${headerSummary}]` : "") + (body ? ` body=${body.length}B` : "")
+      );
+    };
+    if (this.requireAuth && method !== "OPTIONS") {
+      const authHeader = requestText.match(/Authorization:\s*([^\r\n]+)/i)?.[1] ?? "";
+      if (!authHeader) {
+        this.logger.info?.(
+          `[BaichuanRtspBackchannelServer] auth challenge issued client=${clientId} method=${method}`
+        );
+        send(401, "Unauthorized", {
+          "WWW-Authenticate": this.wwwAuthenticate(clientId)
+        });
+        return;
+      }
+      if (!this.validateDigest(authHeader, method, url, clientId)) {
+        this.logger.warn?.(
+          `[BaichuanRtspBackchannelServer] auth rejected client=${clientId} method=${method}`
+        );
+        this.nonces.delete(clientId);
+        send(401, "Unauthorized", {
+          "WWW-Authenticate": this.wwwAuthenticate(clientId)
+        });
+        return;
+      }
+    }
+    switch (method) {
+      case "OPTIONS":
+        send(200, "OK", {
+          Public: "OPTIONS, DESCRIBE, SETUP, RECORD, TEARDOWN"
+        });
+        return;
+      case "DESCRIBE": {
+        const sdp = this.buildSdp();
+        this.logger.debug?.(
+          `[BaichuanRtspBackchannelServer] DESCRIBE sdp for ${clientId}:
+${sdp.trimEnd()}`
+        );
+        send(
+          200,
+          "OK",
+          {
+            "Content-Type": "application/sdp",
+            "Content-Base": `rtsp://${this.listenHost}:${this.listenPort}${this.path}/`
+          },
+          sdp
+        );
+        return;
+      }
+      case "SETUP": {
+        if (!url.includes("audiobackchannel")) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] SETUP rejected (unknown track) client=${clientId} url=${url}`
+          );
+          send(404, "Not Found");
+          return;
+        }
+        const transportLine = requestText.match(/Transport:\s*([^\r\n]+)/i)?.[1] ?? "";
+        this.logger.info?.(
+          `[BaichuanRtspBackchannelServer] SETUP transport="${transportLine}" client=${clientId}`
+        );
+        if (!transportLine.toUpperCase().includes("RTP/AVP/TCP") && !transportLine.toLowerCase().includes("interleaved")) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] SETUP rejected (non-TCP transport) client=${clientId}`
+          );
+          send(461, "Unsupported Transport");
+          return;
+        }
+        const interleaved = parseInterleavedChannels(transportLine) ?? {
+          rtp: 0,
+          rtcp: 1
+        };
+        if (!sessionId) {
+          sessionId = newSessionId();
+        }
+        this.sessionByClient.set(clientId, {
+          sessionId,
+          clientId,
+          socket,
+          rtpChannel: interleaved.rtp,
+          rtcpChannel: interleaved.rtcp
+        });
+        this.logger.info?.(
+          `[BaichuanRtspBackchannelServer] SETUP ok client=${clientId} session=${sessionId} interleaved=${interleaved.rtp}-${interleaved.rtcp}`
+        );
+        send(200, "OK", {
+          Transport: `RTP/AVP/TCP;unicast;interleaved=${interleaved.rtp}-${interleaved.rtcp};mode=record`,
+          Session: sessionId
+        });
+        return;
+      }
+      case "RECORD": {
+        const session = sessionId ? Array.from(this.sessionByClient.values()).find(
+          (s) => s.sessionId === sessionId
+        ) : this.sessionByClient.get(clientId);
+        if (!session) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] RECORD without active session client=${clientId} requestedSession=${sessionId ?? "(none)"}`
+          );
+          send(454, "Session Not Found");
+          return;
+        }
+        if (session.handler) {
+          this.logger.info?.(
+            `[BaichuanRtspBackchannelServer] RECORD idempotent (already recording) client=${clientId} session=${session.sessionId}`
+          );
+          send(200, "OK", { Session: session.sessionId });
+          return;
+        }
+        const apiRef = this.api;
+        const channelForCamera = this.channel;
+        const loggerRef = this.logger;
+        const deviceIdRef = this.deviceId ?? `rtsp-backchannel-${clientId}`;
+        const handler = new RtspBackchannel({
+          openTalkSession: () => apiRef.createDedicatedTalkSession(channelForCamera, {
+            deviceId: deviceIdRef,
+            logger: loggerRef
+          }),
+          logger: loggerRef
+        });
+        const recordStart = Date.now();
+        this.logger.info?.(
+          `[BaichuanRtspBackchannelServer] RECORD opening TalkSession client=${clientId} session=${session.sessionId} channel=${channelForCamera} deviceId="${deviceIdRef}"`
+        );
+        try {
+          const talk = await handler.start();
+          this.logger.info?.(
+            `[BaichuanRtspBackchannelServer] RECORD talk session ready client=${clientId} session=${session.sessionId} blockSize=${talk.info.blockSize} fullBlockSize=${talk.info.fullBlockSize} sampleRate=${talk.info.audioConfig.sampleRate} audioType=${talk.info.audioConfig.audioType} duplex setupMs=${Date.now() - recordStart}`
+          );
+        } catch (e) {
+          this.logger.warn?.(
+            `[BaichuanRtspBackchannelServer] RECORD failed to open TalkSession client=${clientId} session=${session.sessionId} setupMs=${Date.now() - recordStart} error="${e.message}"`
+          );
+          send(503, "Service Unavailable");
+          return;
+        }
+        session.handler = handler;
+        send(200, "OK", { Session: session.sessionId });
+        return;
+      }
+      case "TEARDOWN": {
+        const session = this.sessionByClient.get(clientId);
+        if (session) {
+          this.sessionByClient.delete(clientId);
+          if (session.handler) {
+            const stats = session.handler.stats;
+            this.logger.info?.(
+              `[BaichuanRtspBackchannelServer] TEARDOWN client=${clientId} session=${session.sessionId} rtpRx=${stats.rtpPacketsReceived} rtpDropped=${stats.rtpPacketsDropped} adpcmBlocks=${stats.adpcmBlocksSent}`
+            );
+            void session.handler.stop();
+          } else {
+            this.logger.info?.(
+              `[BaichuanRtspBackchannelServer] TEARDOWN client=${clientId} session=${session.sessionId} (no RECORD)`
+            );
+          }
+        } else {
+          this.logger.info?.(
+            `[BaichuanRtspBackchannelServer] TEARDOWN client=${clientId} (no active session)`
+          );
+        }
+        send(200, "OK", { Session: sessionId ?? "" });
+        try {
+          socket.end();
+        } catch {
+        }
+        return;
+      }
+      default:
+        this.logger.warn?.(
+          `[BaichuanRtspBackchannelServer] unknown method ${method} from ${clientId} \u2014 replying 501`
+        );
+        send(501, "Not Implemented");
+    }
+  }
+  buildSdp() {
+    return `v=0\r
+o=- ${Date.now()} ${Date.now()} IN IP4 ${this.listenHost}\r
+s=Baichuan Backchannel\r
+c=IN IP4 ${this.listenHost}\r
+t=0 0\r
+a=control:*\r
+m=audio 0 RTP/AVP 0\r
+a=rtpmap:0 PCMU/8000\r
+a=sendonly\r
+a=control:audiobackchannel\r
+`;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Digest auth helpers (mirror BaichuanRtspServer's behaviour so
+  // operators can re-use the same credentials store across both servers).
+  // ─────────────────────────────────────────────────────────────────────
+  wwwAuthenticate(clientId) {
+    const nonce = this.nonceFor(clientId);
+    return `Digest realm="${this.authRealm}", nonce="${nonce}"`;
+  }
+  nonceFor(clientId) {
+    const now = Date.now();
+    const existing = this.nonces.get(clientId);
+    if (existing && now - existing.ts < _BaichuanRtspBackchannelServer.NONCE_TTL_MS) {
+      return existing.nonce;
+    }
+    const nonce = crypto3.randomBytes(16).toString("hex");
+    this.nonces.set(clientId, { nonce, ts: now });
+    return nonce;
+  }
+  validateDigest(header, method, uri, clientId) {
+    const params = parseDigestHeader(header);
+    if (!params) return false;
+    if (params.realm && params.realm !== this.authRealm) return false;
+    const nonce = this.nonces.get(clientId);
+    if (!nonce || nonce.nonce !== params.nonce) return false;
+    if (Date.now() - nonce.ts > _BaichuanRtspBackchannelServer.NONCE_TTL_MS)
+      return false;
+    const cred = this.authCredentials.find((c) => c.username === params.username);
+    if (!cred) return false;
+    const ha1 = cred.ha1 ?? (cred.password !== void 0 ? md5Hex(`${cred.username}:${this.authRealm}:${cred.password}`) : void 0);
+    if (!ha1) return false;
+    const ha2 = md5Hex(`${method}:${params.uri || uri}`);
+    const expected = md5Hex(`${ha1}:${params.nonce}:${ha2}`);
+    return expected === params.response;
+  }
+};
+function newSessionId() {
+  return `talk_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+function parseInterleavedChannels(transport) {
+  const m = transport.match(/interleaved\s*=\s*(\d+)\s*-\s*(\d+)/i);
+  if (!m) return void 0;
+  const rtp = parseInt(m[1] ?? "", 10);
+  const rtcp = parseInt(m[2] ?? "", 10);
+  if (!Number.isFinite(rtp) || !Number.isFinite(rtcp)) return void 0;
+  return { rtp, rtcp };
+}
+function parseDigestHeader(header) {
+  if (!/^digest\s+/i.test(header)) return null;
+  const params = {};
+  const re = /(\w+)\s*=\s*("([^"]*)"|([^,\s]+))/g;
+  let match;
+  while ((match = re.exec(header)) !== null) {
+    const key = (match[1] ?? "").toLowerCase();
+    const value = match[3] ?? match[4] ?? "";
+    params[key] = value;
+  }
+  if (!params.username || !params.nonce || !params.uri || !params.response) {
+    return null;
+  }
+  return {
+    username: params.username,
+    realm: params.realm ?? "",
+    nonce: params.nonce,
+    uri: params.uri,
+    response: params.response
+  };
+}
+
 // src/emailPush/server.ts
 var import_node_util2 = require("util");
 var import_smtp_server = require("smtp-server");
@@ -41610,6 +42576,7 @@ function buildInitialStatus(config) {
   BaichuanHlsServer,
   BaichuanHttpStreamServer,
   BaichuanMjpegServer,
+  BaichuanRtspBackchannelServer,
   BaichuanRtspServer,
   BaichuanVideoStream,
   BaichuanWebRTCServer,
@@ -41635,10 +42602,12 @@ function buildInitialStatus(config) {
   ReolinkCgiApi,
   ReolinkHttpClient,
   Rfc4571Muxer,
+  RtspBackchannel,
   _resetEmailPushBusForTests,
   abilitiesHasAny,
   aesDecrypt,
   aesEncrypt,
+  alawToPcm16,
   applyStreamPatch,
   applyXmlTagPatch,
   asLogger,
@@ -41711,6 +42680,7 @@ function buildInitialStatus(config) {
   discoverViaUdpDirect,
   emitEmailPushEvent,
   encodeHeader,
+  encodeImaAdpcm,
   encodeMotionScopeBitmap,
   encodeMotionSensitivityListXml,
   encodeShelterCoord,
@@ -41753,6 +42723,7 @@ function buildInitialStatus(config) {
   maskUid,
   md5HexUpper,
   md5StrModern,
+  mulawToPcm16,
   normalizeDayNightMode,
   normalizeOpenClose,
   normalizeUid,
@@ -41764,6 +42735,7 @@ function buildInitialStatus(config) {
   parseAdtsHeader,
   parseBcMedia,
   parseRecordingFileName,
+  parseRtpPacket,
   parseSupportXml,
   patchAiDetectCfgXml,
   patchMotionSensitivityListXml,
@@ -41781,6 +42753,7 @@ function buildInitialStatus(config) {
   splitAnnexBToNals,
   splitH265AnnexBToNalPayloads,
   testChannelStreams,
+  upsamplePcm16,
   upsertXmlTag,
   xmlEscape,
   xmlIndicatesFloodlight,