@camstack/addon-pipeline 0.1.9 → 0.1.11

package/dist/stream-broker/index.js

@@ -27,8 +27,8 @@ const net = require("node:net");
 const crypto = require("node:crypto");
 const net$1 = require("net");
 const events = require("events");
-const promises = require("node:dns/promises");
 const node_child_process = require("node:child_process");
+const promises = require("node:dns/promises");
 const fs = require("node:fs");
 const path = require("node:path");
 const os = require("node:os");
@@ -5816,6 +5816,305 @@ class RtspRestreamProviderImpl {
     }
   }
 }
+function normaliseCodec(codec) {
+  if (!codec) return null;
+  const c = codec.toLowerCase();
+  if (c === "h264" || c === "avc" || c === "avc1") return "H264";
+  if (c === "h265" || c === "hevc" || c === "hvc1" || c === "hev1") return "H265";
+  return null;
+}
+function pipelineKeyFor(deviceId, videoCodec, audioCodec, width, height) {
+  return `${deviceId}|v=${videoCodec}|a=${audioCodec}|${width}x${height}`;
+}
+function pickVideoEncoder(target, encoders) {
+  if (!encoders) return target === "H264" ? "libx264" : "libx265";
+  return target === "H264" ? encoders.defaultH264 : encoders.defaultH265;
+}
+function pickAudioEncoderArgs(audio) {
+  switch (audio) {
+    case "AAC":
+      return ["-c:a", "aac", "-b:a", "128k", "-ar", "48000", "-ac", "2"];
+    case "Opus":
+      return ["-c:a", "libopus", "-b:a", "64k", "-ar", "48000", "-ac", "2"];
+    case "PCMU":
+      return ["-c:a", "pcm_mulaw", "-ar", "8000", "-ac", "1"];
+    case "none":
+      return ["-an"];
+    default:
+      return ["-c:a", "aac", "-b:a", "128k"];
+  }
+}
+class TranscodePipelineManager {
+  entries = /* @__PURE__ */ new Map();
+  logger;
+  api;
+  cameraStreamLookup;
+  rtspEntryLookup;
+  localRtspPort;
+  releaseGraceMs;
+  ffmpegPath;
+  constructor(opts) {
+    this.logger = opts.logger;
+    this.api = opts.api;
+    this.cameraStreamLookup = opts.cameraStreamLookup;
+    this.rtspEntryLookup = opts.rtspEntryLookup;
+    this.localRtspPort = opts.localRtspPort;
+    this.releaseGraceMs = opts.releaseGraceMs ?? 5e3;
+    this.ffmpegPath = opts.ffmpegPath ?? "ffmpeg";
+  }
+  async acquire(input) {
+    const wantedVideo = input.videoCodec;
+    const wantedAudio = input.audioCodec ?? "AAC";
+    const direct = this.findDirectMatch(input.deviceId, wantedVideo, input.maxResolution);
+    if (direct) {
+      const key2 = pipelineKeyFor(
+        input.deviceId,
+        direct.videoCodec,
+        wantedAudio,
+        direct.resolution.width,
+        direct.resolution.height
+      );
+      return this.shareOrCreate(key2, () => ({
+        url: direct.url,
+        videoCodec: direct.videoCodec,
+        audioCodec: "passthrough",
+        resolution: direct.resolution,
+        transcoded: false,
+        encoder: "copy",
+        pipelineKey: key2
+      }), null);
+    }
+    const sourceStream = this.pickTranscodeSource(input.deviceId, input.maxResolution);
+    if (!sourceStream || !sourceStream.url) {
+      throw new Error(
+        `getStreamWithCodec: no source stream available for device ${input.deviceId}`
+      );
+    }
+    const targetCodec = wantedVideo === "auto" ? normaliseCodec(sourceStream.codec) ?? "H264" : wantedVideo;
+    const targetResolution = input.maxResolution ?? sourceStream.resolution ?? { width: 1280, height: 720 };
+    const key = pipelineKeyFor(
+      input.deviceId,
+      targetCodec,
+      wantedAudio,
+      targetResolution.width,
+      targetResolution.height
+    );
+    const existing = this.entries.get(key);
+    if (existing) {
+      return this.shareEntry(existing).source;
+    }
+    const encoders = await this.loadHardwareEncoders();
+    const encoder = pickVideoEncoder(targetCodec, encoders);
+    const dialableUrl = this.allocateLoopbackUrl(input.deviceId, key);
+    const child = this.spawnFfmpeg({
+      sourceUrl: sourceStream.url,
+      outputUrl: dialableUrl,
+      encoder,
+      targetCodec,
+      width: targetResolution.width,
+      height: targetResolution.height,
+      audio: wantedAudio,
+      tag: input.tag ?? `stream-with-codec:${input.deviceId}`
+    });
+    const source = {
+      url: dialableUrl,
+      videoCodec: targetCodec,
+      audioCodec: wantedAudio,
+      resolution: targetResolution,
+      transcoded: true,
+      encoder,
+      pipelineKey: key
+    };
+    const entry = { key, source, child, refcount: 1, releaseTimer: null };
+    this.entries.set(key, entry);
+    this.logger.info("Transcode pipeline started", {
+      meta: { key, encoder, sourceUrl: sourceStream.url, outputUrl: dialableUrl }
+    });
+    if (child) {
+      child.once("exit", (code, signal) => {
+        this.logger.info("Transcode pipeline exited", {
+          meta: { key, code, signal }
+        });
+        const cur = this.entries.get(key);
+        if (cur && cur.child === child) {
+          this.entries.delete(key);
+        }
+      });
+    }
+    return source;
+  }
+  release(pipelineKey) {
+    const entry = this.entries.get(pipelineKey);
+    if (!entry) return { released: false, refcount: 0 };
+    entry.refcount = Math.max(0, entry.refcount - 1);
+    if (entry.refcount > 0) {
+      return { released: true, refcount: entry.refcount };
+    }
+    if (entry.releaseTimer) {
+      clearTimeout(entry.releaseTimer);
+    }
+    entry.releaseTimer = setTimeout(() => {
+      const cur = this.entries.get(pipelineKey);
+      if (!cur || cur.refcount > 0) return;
+      this.shutdownEntry(cur);
+    }, this.releaseGraceMs);
+    return { released: true, refcount: 0 };
+  }
+  shutdownAll() {
+    for (const entry of this.entries.values()) {
+      this.shutdownEntry(entry);
+    }
+    this.entries.clear();
+  }
+  findDirectMatch(deviceId, wanted, maxRes) {
+    if (wanted === "auto") return null;
+    const streams = this.cameraStreamLookup(deviceId);
+    for (const s of streams) {
+      if (!s.url) continue;
+      const codec = normaliseCodec(s.codec);
+      if (codec !== wanted) continue;
+      if (maxRes && s.resolution) {
+        if (s.resolution.width > maxRes.width || s.resolution.height > maxRes.height) continue;
+      }
+      const resolution = s.resolution ?? { width: 1280, height: 720 };
+      return { url: s.url, videoCodec: codec, resolution };
+    }
+    return null;
+  }
+  pickTranscodeSource(deviceId, maxRes) {
+    const streams = this.cameraStreamLookup(deviceId);
+    if (streams.length === 0) return null;
+    if (!maxRes) return streams[0] ?? null;
+    let best = null;
+    let bestArea = -1;
+    for (const s of streams) {
+      if (!s.url) continue;
+      const w = s.resolution?.width ?? 1280;
+      const h = s.resolution?.height ?? 720;
+      if (w > maxRes.width || h > maxRes.height) continue;
+      const area = w * h;
+      if (area > bestArea) {
+        bestArea = area;
+        best = s;
+      }
+    }
+    if (best) return best;
+    let smallest = null;
+    let smallestArea = Number.MAX_SAFE_INTEGER;
+    for (const s of streams) {
+      if (!s.url) continue;
+      const w = s.resolution?.width ?? 1280;
+      const h = s.resolution?.height ?? 720;
+      const area = w * h;
+      if (area < smallestArea) {
+        smallestArea = area;
+        smallest = s;
+      }
+    }
+    return smallest;
+  }
+  allocateLoopbackUrl(deviceId, pipelineKey) {
+    const port = this.localRtspPort();
+    const token = `t-${deviceId}-${crypto.randomUUID().slice(0, 8)}`;
+    if (!port) {
+      return `rtsp://0.0.0.0:0/${token}`;
+    }
+    return `rtsp://127.0.0.1:${port}/${token}`;
+  }
+  async loadHardwareEncoders() {
+    if (!this.api) return null;
+    try {
+      const api = this.api;
+      const probe = api["platformProbe"];
+      if (!probe || typeof probe !== "object") return null;
+      const fn = probe["getHardwareEncoders"];
+      if (!fn || typeof fn !== "object") return null;
+      const query = fn["query"];
+      if (typeof query !== "function") return null;
+      const callable = query;
+      return await callable();
+    } catch (err) {
+      this.logger.warn("platformProbe.getHardwareEncoders failed — using software fallback", {
+        meta: { error: types.errMsg(err) }
+      });
+      return null;
+    }
+  }
+  spawnFfmpeg(opts) {
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-rtsp_transport",
+      "tcp",
+      "-i",
+      opts.sourceUrl,
+      "-vf",
+      `scale=${opts.width}:${opts.height}`,
+      "-c:v",
+      opts.encoder,
+      ...pickAudioEncoderArgs(opts.audio),
+      "-f",
+      "rtsp",
+      "-rtsp_transport",
+      "tcp",
+      opts.outputUrl
+    ];
+    try {
+      const child = node_child_process.spawn(this.ffmpegPath, args, { stdio: ["ignore", "ignore", "pipe"] });
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", (chunk) => {
+        this.logger.debug("ffmpeg", { meta: { tag: opts.tag, line: chunk.trim() } });
+      });
+      child.once("error", (err) => {
+        this.logger.error("ffmpeg spawn error", {
+          meta: { tag: opts.tag, error: types.errMsg(err) }
+        });
+      });
+      return child;
+    } catch (err) {
+      this.logger.error("Failed to spawn ffmpeg", {
+        meta: { tag: opts.tag, error: types.errMsg(err) }
+      });
+      return null;
+    }
+  }
+  shareEntry(entry) {
+    entry.refcount += 1;
+    if (entry.releaseTimer) {
+      clearTimeout(entry.releaseTimer);
+      entry.releaseTimer = null;
+    }
+    return entry;
+  }
+  shareOrCreate(key, factory, child) {
+    const existing = this.entries.get(key);
+    if (existing) {
+      this.shareEntry(existing);
+      return existing.source;
+    }
+    const source = factory();
+    const entry = { key, source, child, refcount: 1, releaseTimer: null };
+    this.entries.set(key, entry);
+    return source;
+  }
+  shutdownEntry(entry) {
+    if (entry.releaseTimer) {
+      clearTimeout(entry.releaseTimer);
+      entry.releaseTimer = null;
+    }
+    if (entry.child && !entry.child.killed) {
+      try {
+        entry.child.kill("SIGTERM");
+      } catch (err) {
+        this.logger.warn("ffmpeg kill error", {
+          meta: { key: entry.key, error: types.errMsg(err) }
+        });
+      }
+    }
+    this.entries.delete(entry.key);
+  }
+}
 const PUSH_KINDS = /* @__PURE__ */ new Set(["push-annexb"]);
 function findProfileForStream(map, camStreamId) {
   for (const profile of types.CAM_PROFILE_ORDER) {
@@ -5882,11 +6181,42 @@ class StreamBrokerManager {
   api = null;
   defaultPreBufferSec = 10;
   webrtcServer = null;
+  /**
+   * Transcode-pipeline manager — backs `getStreamWithCodec`. Lazily
+   * created on first acquire, lives until `destroyAll`.
+   */
+  transcodeManager = null;
   constructor(staticDecoders, logger) {
     this.staticDecoders = staticDecoders ?? [];
     this.logger = logger;
     this.rtspProvider = new RtspRestreamProviderImpl(this.rtspServer, logger.child("rtsp-restream"));
   }
+  /**
+   * Lazily create the transcode manager wired with closures rather than
+   * direct refs so it only sees the surface it needs.
+   */
+  getTranscodeManager() {
+    if (!this.transcodeManager) {
+      this.transcodeManager = new TranscodePipelineManager({
+        logger: this.logger.child("transcode"),
+        api: this.api,
+        cameraStreamLookup: (deviceId) => this.getCameraStreamsForDevice(deviceId),
+        rtspEntryLookup: (brokerId) => {
+          const entry = this.rtspProvider.getEntry(brokerId);
+          return entry ? { url: entry.url } : null;
+        },
+        localRtspPort: () => this.rtspProvider.getRtspPort()
+      });
+    }
+    return this.transcodeManager;
+  }
+  // ── Cap methods: getStreamWithCodec / releaseStreamWithCodec ─────────
+  async getStreamWithCodec(input) {
+    return this.getTranscodeManager().acquire(input);
+  }
+  async releaseStreamWithCodec(input) {
+    return this.getTranscodeManager().release(input.pipelineKey);
+  }
   // ── Decoder resolution ───────────────────────────────────────────────
   //
   // Routes every decoder call through `ctx.api.decoder.*` (tRPC). The
@@ -6336,6 +6666,10 @@ class StreamBrokerManager {
       clearInterval(this.streamHealthTimer);
       this.streamHealthTimer = void 0;
     }
+    if (this.transcodeManager) {
+      this.transcodeManager.shutdownAll();
+      this.transcodeManager = null;
+    }
     const stopPromises = [...this.brokers.values()].map((broker) => broker.stop());
     await Promise.all(stopPromises);
     this.brokers.clear();
@@ -9157,6 +9491,73 @@ class BrokerWebrtcServer {
   }
   // ── Session lifecycle ───────────────────────────────────────────────
   async createSession(streamId, hints = {}, opts = {}) {
+    const setup = await this.setupSessionForBroker(streamId, hints, opts);
+    try {
+      const offer = await setup.session.createOffer();
+      setup.sessionLogger.info("WebRTC session created", {
+        meta: {
+          sessionId: setup.sessionId,
+          brokerId: setup.brokerId,
+          iceServers: setup.iceServerCount,
+          codec: setup.sessionCodec,
+          useH265Repacketizer: setup.useH265Repacketizer
+        }
+      });
+      return { sessionId: setup.sessionId, sdpOffer: offer.sdp };
+    } catch (err) {
+      this.cleanupSession(setup.sessionId);
+      await setup.session.close().catch(() => {
+      });
+      throw err;
+    }
+  }
+  /**
+   * WHEP-style client-offer signaling: caller has already constructed
+   * an SDP offer (Alexa / WHEP / mobile clients that do
+   * `createOffer()` locally) and posts it here. We build the same
+   * broker subscription + AdaptiveSession plumbing as `createSession`,
+   * then call `session.handleOffer(clientOffer)` to produce the
+   * server's SDP answer.
+   *
+   * The session lifecycle is identical to `createSession` — broker
+   * unsubscribe and `closeSession(sessionId)` still apply — so the
+   * RTC controller / Alexa handler closes the session the same way.
+   */
+  async handleOffer(streamId, clientOfferSdp, hints = {}, opts = {}) {
+    const setup = await this.setupSessionForBroker(streamId, hints, opts);
+    try {
+      const answer = await setup.session.handleOffer({ sdp: clientOfferSdp, type: "offer" });
+      setup.sessionLogger.info("WebRTC session created (client-offer)", {
+        meta: {
+          sessionId: setup.sessionId,
+          brokerId: setup.brokerId,
+          iceServers: setup.iceServerCount,
+          codec: setup.sessionCodec,
+          useH265Repacketizer: setup.useH265Repacketizer
+        }
+      });
+      return { sessionId: setup.sessionId, sdpAnswer: answer.sdp };
+    } catch (err) {
+      this.cleanupSession(setup.sessionId);
+      await setup.session.close().catch(() => {
+      });
+      throw err;
+    }
+  }
+  /**
+   * Shared session bring-up: resolve broker → subscribe to encoded
+   * data + RTP → flush pre-buffer → seed H.265 codec info → register
+   * the SessionEntry. Returns the `AdaptiveSession` ready for SDP
+   * negotiation (either `createOffer()` for the server-offer flow or
+   * `handleOffer(clientOffer)` for the WHEP / Alexa flow).
+   *
+   * The returned session has its `onClosed` hook already wired to
+   * cleanup, and the SessionEntry is already in `this.sessions` keyed
+   * by `sessionId` — callers MUST cleanup + close on negotiation
+   * failure (both `createSession` and `handleOffer` do this in their
+   * catch blocks).
+   */
+  async setupSessionForBroker(streamId, hints, opts) {
     if (this.stopped) throw new Error("Server stopped");
     const brokerId = this.resolveBrokerId(streamId, hints);
     const broker = this.brokers.get(brokerId);
@@ -9268,7 +9669,11 @@ class BrokerWebrtcServer {
         });
       }
     }
-    const sessionId = crypto.randomUUID();
+    const requestedSessionId = opts.sessionId;
+    if (requestedSessionId !== void 0 && this.sessions.has(requestedSessionId)) {
+      throw new Error(`Session id already in use: ${requestedSessionId}`);
+    }
+    const sessionId = requestedSessionId ?? crypto.randomUUID();
     const iceServers = await this.resolveIceServers();
     const session = new AdaptiveSession({
       sessionId,
@@ -9328,18 +9733,15 @@ class BrokerWebrtcServer {
     const entry = { session, brokerId, unsubBroker, unsubRtp, unsubSdpParams, closeSource };
     this.sessions.set(sessionId, entry);
     session.onClosed = () => this.cleanupSession(sessionId);
-    try {
-      const offer = await session.createOffer();
-      sessionLogger.info("WebRTC session created", {
-        meta: { sessionId, brokerId, iceServers: iceServers.length, codec: sessionCodec, useH265Repacketizer }
-      });
-      return { sessionId, sdpOffer: offer.sdp };
-    } catch (err) {
-      this.cleanupSession(sessionId);
-      await session.close().catch(() => {
-      });
-      throw err;
-    }
+    return {
+      sessionId,
+      session,
+      sessionLogger,
+      brokerId,
+      sessionCodec,
+      useH265Repacketizer,
+      iceServerCount: iceServers.length
+    };
   }
   async handleAnswer(sessionId, sdpAnswer) {
     const entry = this.sessions.get(sessionId);
@@ -9620,6 +10022,15 @@ class WebrtcSessionProvider {
     const streamingDebug = typeof this.manager.isStreamingDebug === "function" ? this.manager.isStreamingDebug(input.deviceId) : false;
     return this.webrtcServer.createSession(streamId, input.hints, { streamingDebug });
   }
+  async handleOffer(input) {
+    const target = input.target ?? { kind: "adaptive" };
+    const streamId = this.resolveTargetToStreamId(input.deviceId, target);
+    const streamingDebug = typeof this.manager.isStreamingDebug === "function" ? this.manager.isStreamingDebug(input.deviceId) : false;
+    return this.webrtcServer.handleOffer(streamId, input.sdpOffer, void 0, {
+      streamingDebug,
+      sessionId: input.sessionId
+    });
+  }
   async handleAnswer(input) {
     await this.webrtcServer.handleAnswer(input.sessionId, input.sdpAnswer);
   }