@ahmedrowaihi/mediabunny-server 1.65.2-beta.415 → 1.65.2-beta.534

package/dist/bundles/mediabunny-server.cjs

@@ -50,11 +50,12 @@ var MediabunnyServer = (() => {
     NetworkSource: () => NetworkSource,
     RistSource: () => RistSource,
     RtmpSource: () => RtmpSource,
+    SrtTarget: () => SrtTarget,
     _serverOptions: () => _serverOptions,
     registerMediabunnyServer: () => registerMediabunnyServer,
     toAvFrame: () => toAvFrame
   });
-  var import_mediabunny11 = __require("mediabunny");
+  var import_mediabunny12 = __require("mediabunny");
   var NodeAv8 = __toESM(__require("node-av"));
 
   // packages/server/src/video-decoder.ts
@@ -5524,10 +5525,206 @@ var MediabunnyServer = (() => {
     }
   };
 
+  // packages/server/src/srt-target.ts
+  var import_mediabunny11 = __require("mediabunny");
+  var import_node_av4 = __require("node-av");
+  var import_constants3 = __require("node-av/constants");
+  var PAYLOAD_SIZE = 1316;
+  var DEFAULT_MAX_QUEUE_BYTES = 2 * 1024 * 1024;
+  var DEFAULT_LINGER_SECONDS = 5;
+  var PBKEYLEN_BY_BITS = { 128: 16, 192: 24, 256: 32 };
+  var SrtSink = class {
+    constructor(url, maxQueueBytes) {
+      this.url = url;
+      this.maxQueueBytes = maxQueueBytes;
+      this.opening = null;
+      this.pumping = null;
+      this.failure = null;
+      this.closed = false;
+      this.queue = { chunks: [], bytes: 0 };
+      this.partial = new Uint8Array(PAYLOAD_SIZE);
+      this.partialLength = 0;
+      this.droppedBytes = 0;
+      this.droppedDatagrams = 0;
+      this.sentBytes = 0;
+      this.writable = new WritableStream({
+        write: (chunk) => this.enqueue(chunk),
+        close: () => this.finish(),
+        abort: () => this.finish(true)
+      });
+    }
+    /** @internal */
+    async open() {
+      const context = new import_node_av4.IOContext();
+      const ret = await context.open2(this.url, import_constants3.AVIO_FLAG_WRITE);
+      if (ret < 0) {
+        throw new Error(`SrtTarget: could not open ${this.url} (AVERROR ${ret}).`);
+      }
+      this.io = context;
+    }
+    /**
+     * Takes the bytes and returns, rather than awaiting the socket: a target that pushed back here would
+     * stall the muxer for as long as the receiver was behind, which for a live feed is unbounded.
+     */
+    enqueue(chunk) {
+      if (this.failure) {
+        throw this.failure;
+      }
+      if (this.queue.bytes + chunk.byteLength > this.maxQueueBytes) {
+        this.droppedBytes += chunk.byteLength;
+        this.droppedDatagrams += Math.ceil(chunk.byteLength / PAYLOAD_SIZE);
+        return;
+      }
+      this.queue.chunks.push(chunk);
+      this.queue.bytes += chunk.byteLength;
+      this.pumping ??= this.pump().finally(() => {
+        this.pumping = null;
+      });
+    }
+    /** @internal */
+    async writeDatagram(bytes) {
+      const io = this.io;
+      await io.write(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+      if (io.error < 0) {
+        throw new Error(`SrtTarget: the peer stopped accepting data (AVERROR ${io.error}).`);
+      }
+      this.sentBytes += bytes.byteLength;
+    }
+    /** @internal */
+    async pump() {
+      try {
+        if (!this.io) {
+          this.opening ??= this.open();
+          await this.opening;
+        }
+        while (this.queue.chunks.length > 0) {
+          const chunk = this.queue.chunks.shift();
+          this.queue.bytes -= chunk.byteLength;
+          let offset = 0;
+          while (offset < chunk.byteLength) {
+            const take = Math.min(PAYLOAD_SIZE - this.partialLength, chunk.byteLength - offset);
+            this.partial.set(chunk.subarray(offset, offset + take), this.partialLength);
+            this.partialLength += take;
+            offset += take;
+            if (this.partialLength === PAYLOAD_SIZE) {
+              this.partialLength = 0;
+              await this.writeDatagram(this.partial);
+            }
+          }
+        }
+      } catch (error) {
+        this.failure ??= error instanceof Error ? error : new Error(String(error));
+        this.queue = { chunks: [], bytes: 0 };
+      }
+    }
+    /** Drains what is queued, then closes. Awaited by the output's `finalize()`. */
+    async finish(aborting = false) {
+      if (this.closed) {
+        return;
+      }
+      this.closed = true;
+      await this.pumping?.catch(() => {
+      });
+      if (!aborting && !this.failure && this.io && this.partialLength > 0) {
+        await this.writeDatagram(this.partial.subarray(0, this.partialLength)).catch((error) => {
+          this.failure ??= error instanceof Error ? error : new Error(String(error));
+        });
+      }
+      if (this.io) {
+        await this.io.flush().catch(() => {
+        });
+        await this.io.closep().catch(() => {
+        });
+      }
+      if (this.failure && !aborting) {
+        throw this.failure;
+      }
+    }
+  };
+  var srtUrl = (rawUrl, options) => {
+    let url;
+    try {
+      url = new URL(rawUrl);
+    } catch {
+      throw new TypeError(`SrtTarget: ${JSON.stringify(rawUrl)} is not a URL.`);
+    }
+    if (url.protocol !== "srt:") {
+      throw new TypeError(`SrtTarget: expected an srt:// URL, got ${JSON.stringify(url.protocol)}.`);
+    }
+    const connectTimeout = options.connectTimeout ?? 30;
+    const micros = (seconds) => String(Math.max(1, Math.round(seconds * 1e6)));
+    if (!url.searchParams.has("transtype")) {
+      url.searchParams.set("transtype", "live");
+    }
+    if (!url.searchParams.has("payload_size")) {
+      url.searchParams.set("payload_size", String(PAYLOAD_SIZE));
+    }
+    if (!url.searchParams.has("mode")) {
+      url.searchParams.set("mode", "caller");
+    }
+    if (!url.searchParams.has("linger")) {
+      url.searchParams.set("linger", String(DEFAULT_LINGER_SECONDS));
+    }
+    if (options.passphrase !== void 0) {
+      url.searchParams.set("passphrase", options.passphrase);
+      url.searchParams.set("pbkeylen", String(PBKEYLEN_BY_BITS[options.keyLength ?? 128]));
+    }
+    if (options.latency !== void 0) {
+      url.searchParams.set("latency", micros(options.latency / 1e3));
+    }
+    if (url.searchParams.get("mode") === "listener") {
+      url.searchParams.set("listen_timeout", micros(connectTimeout));
+    }
+    url.searchParams.set("timeout", micros(connectTimeout));
+    return url.toString();
+  };
+  var SrtTarget = class extends import_mediabunny11.AppendOnlyStreamTarget {
+    constructor(url, options = {}) {
+      if (typeof url !== "string") {
+        throw new TypeError("url must be a string.");
+      }
+      if (!options || typeof options !== "object") {
+        throw new TypeError("options must be an object.");
+      }
+      if (options.connectTimeout !== void 0 && (!Number.isFinite(options.connectTimeout) || options.connectTimeout <= 0)) {
+        throw new TypeError("options.connectTimeout, when provided, must be a positive number.");
+      }
+      if (options.passphrase !== void 0 && (typeof options.passphrase !== "string" || options.passphrase.length < 10 || options.passphrase.length > 79)) {
+        throw new TypeError("options.passphrase, when provided, must be a string of 10 to 79 characters.");
+      }
+      if (options.keyLength !== void 0 && PBKEYLEN_BY_BITS[options.keyLength] === void 0) {
+        throw new TypeError("options.keyLength, when provided, must be 128, 192 or 256.");
+      }
+      if (options.latency !== void 0 && (!Number.isFinite(options.latency) || options.latency <= 0)) {
+        throw new TypeError("options.latency, when provided, must be a positive number of milliseconds.");
+      }
+      if (options.maxQueueBytes !== void 0 && (!Number.isInteger(options.maxQueueBytes) || options.maxQueueBytes < PAYLOAD_SIZE)) {
+        throw new TypeError(
+          `options.maxQueueBytes, when provided, must be an integer of at least ${PAYLOAD_SIZE}.`
+        );
+      }
+      const sink = new SrtSink(srtUrl(url, options), options.maxQueueBytes ?? DEFAULT_MAX_QUEUE_BYTES);
+      super(sink.writable);
+      this.sink = sink;
+    }
+    /** Bytes handed to the socket so far. */
+    get sentBytes() {
+      return this.sink.sentBytes;
+    }
+    /** Bytes dropped because the receiver was not keeping up. Stays 0 for a receiver that keeps up. */
+    get droppedBytes() {
+      return this.sink.droppedBytes;
+    }
+    /** Datagrams' worth of dropped bytes, which is the unit a receiver sees missing. */
+    get droppedDatagrams() {
+      return this.sink.droppedDatagrams;
+    }
+  };
+
   // packages/server/src/index.ts
   var SERVER_LOADED_SYMBOL = Symbol.for("@mediabunny/server loaded");
   if (globalThis[SERVER_LOADED_SYMBOL]) {
-    import_mediabunny11.Logging._error(
+    import_mediabunny12.Logging._error(
       "[WARNING]\n@mediabunny/server was loaded twice. This will likely cause the package not to work correctly. Check if multiple dependencies are importing different versions of @mediabunny/server, or if something is being bundled incorrectly."
     );
   }
@@ -5549,21 +5746,21 @@ var MediabunnyServer = (() => {
     registered2 = true;
     _serverOptions = options;
     NodeAv8.Log.setLevel(NodeAv8.AV_LOG_ERROR);
-    (0, import_mediabunny11.registerDecoder)(NodeAvVideoDecoder);
+    (0, import_mediabunny12.registerDecoder)(NodeAvVideoDecoder);
     registerProresDecoder();
-    (0, import_mediabunny11.registerEncoder)(NodeAvVideoEncoder);
-    (0, import_mediabunny11.registerDecoder)(NodeAvAudioDecoder);
-    (0, import_mediabunny11.registerEncoder)(NodeAvAudioEncoder);
-    (0, import_mediabunny11.registerVideoSampleTransformer)(transformVideoSample);
+    (0, import_mediabunny12.registerEncoder)(NodeAvVideoEncoder);
+    (0, import_mediabunny12.registerDecoder)(NodeAvAudioDecoder);
+    (0, import_mediabunny12.registerEncoder)(NodeAvAudioEncoder);
+    (0, import_mediabunny12.registerVideoSampleTransformer)(transformVideoSample);
   };
   var toAvFrame = async (sample, frame) => {
-    if (!(sample instanceof import_mediabunny11.VideoSample) && !(sample instanceof import_mediabunny11.AudioSample)) {
+    if (!(sample instanceof import_mediabunny12.VideoSample) && !(sample instanceof import_mediabunny12.AudioSample)) {
       throw new TypeError("sample must be a VideoSample or an AudioSample.");
     }
     if (!(frame instanceof NodeAv8.Frame)) {
       throw new TypeError("frame must be a NodeAv.Frame.");
     }
-    if (sample instanceof import_mediabunny11.VideoSample) {
+    if (sample instanceof import_mediabunny12.VideoSample) {
       if (sample._data instanceof AvFrameVideoSampleResource) {
         frame.unref();
         frame.ref(sample._data.frame);