@ahmedrowaihi/mediabunny-server 1.65.2-beta.539 → 1.65.2-beta.544

package/dist/bundles/mediabunny-server.cjs

@@ -80,6 +80,19 @@ var MediabunnyServer = (() => {
     await peer.closep().catch(() => {
     });
   };
+  var checkUrlAndOptions = (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.");
+    }
+  };
+  var positive = (value, name) => {
+    if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) {
+      throw new TypeError(`options.${name}, when provided, must be a positive number.`);
+    }
+  };
   var CODEC_TO_CODEC_ID = {
     avc: NodeAv.AV_CODEC_ID_H264,
     hevc: NodeAv.AV_CODEC_ID_HEVC,
@@ -4909,12 +4922,7 @@ var MediabunnyServer = (() => {
   };
   var NetworkSource = class extends import_mediabunny8.ReadableStreamSource {
     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.");
-      }
+      checkUrlAndOptions(url, options);
       if (options.connectTimeout !== void 0 && (!Number.isFinite(options.connectTimeout) || options.connectTimeout <= 0)) {
         throw new TypeError("options.connectTimeout, when provided, must be a positive number.");
       }
@@ -4936,11 +4944,6 @@ var MediabunnyServer = (() => {
   var import_node_stream = __require("node:stream");
   var PER_SECOND = 1e6;
   var MOVFLAGS = "frag_keyframe+empty_moov+default_base_moof";
-  var positive = (value, name) => {
-    if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) {
-      throw new TypeError(`options.${name}, when provided, must be a positive number.`);
-    }
-  };
   var inputOptions = (options) => {
     const result = {
       rw_timeout: String(Math.max(1, Math.round(options.readTimeout * PER_SECOND)))
@@ -5092,12 +5095,7 @@ var MediabunnyServer = (() => {
   };
   var RtmpSource = class extends import_mediabunny9.ReadableStreamSource {
     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.");
-      }
+      checkUrlAndOptions(url, options);
       if (options.mode !== void 0 && options.mode !== "listener" && options.mode !== "caller") {
         throw new TypeError("options.mode, when provided, must be 'listener' or 'caller'.");
       }
@@ -5130,11 +5128,6 @@ var MediabunnyServer = (() => {
   var RTCP_RTPFB = 205;
   var RTPFB_GENERIC_NACK = 1;
   var RIST_APP_NAME = 1380537172;
-  var positive2 = (value, name) => {
-    if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) {
-      throw new TypeError(`options.${name}, when provided, must be a positive number.`);
-    }
-  };
   var seqDistance = (a, b) => (a - b & 65535 ^ 32768) - 32768;
   var parseRtp = (bytes) => {
     if (bytes.length < RTP_HEADER_SIZE || bytes[0] >> 6 !== RTP_VERSION) {
@@ -5499,18 +5492,13 @@ var MediabunnyServer = (() => {
   };
   var RistSource = class extends import_mediabunny10.ReadableStreamSource {
     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.");
-      }
+      checkUrlAndOptions(url, options);
       if (options.mode !== void 0 && options.mode !== "listener" && options.mode !== "caller") {
         throw new TypeError("options.mode, when provided, must be 'listener' or 'caller'.");
       }
-      positive2(options.bufferMs, "bufferMs");
-      positive2(options.readTimeout, "readTimeout");
-      positive2(options.nackIntervalMs, "nackIntervalMs");
+      positive(options.bufferMs, "bufferMs");
+      positive(options.readTimeout, "readTimeout");
+      positive(options.nackIntervalMs, "nackIntervalMs");
       const scheme = url.slice(0, url.indexOf(":"));
       if (scheme !== "rist") {
         throw new TypeError(`RistSource: ${JSON.stringify(url)} is not a rist:// URL.`);
@@ -5532,12 +5520,13 @@ var MediabunnyServer = (() => {
   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 KEY_LENGTHS = [128, 192, 256];
   var SrtSink = class {
-    constructor(url, maxQueueBytes) {
+    constructor(url, maxQueueBytes, listening) {
       this.url = url;
       this.maxQueueBytes = maxQueueBytes;
-      this.opening = null;
+      this.listening = listening;
+      this.opening = false;
       this.pumping = null;
       this.failure = null;
       this.closed = false;
@@ -5549,22 +5538,13 @@ var MediabunnyServer = (() => {
       this.sentBytes = 0;
       this.writable = new WritableStream({
         write: (chunk) => this.enqueue(chunk),
-        close: () => this.finish(),
-        abort: () => this.finish(true)
+        close: () => this.finish()
       });
     }
-    /** @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.
+     * Takes the bytes and returns rather than awaiting the socket: pushing back here would stall the
+     * muxer for as long as the receiver was behind, which on a live feed is unbounded. Past the queue
+     * bound the *arriving* bytes go, not the queued ones, so what is queued stays a contiguous run.
      */
     enqueue(chunk) {
       if (this.failure) {
@@ -5577,11 +5557,15 @@ var MediabunnyServer = (() => {
       }
       this.queue.chunks.push(chunk);
       this.queue.bytes += chunk.byteLength;
+      void this.kick();
+    }
+    /** Starts the pump unless one is already running, which is the only way one ever starts. */
+    kick() {
       this.pumping ??= this.pump().finally(() => {
         this.pumping = null;
       });
+      return this.pumping;
     }
-    /** @internal */
     async writeDatagram(bytes) {
       const io = this.io;
       await io.write(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
@@ -5590,12 +5574,16 @@ var MediabunnyServer = (() => {
       }
       this.sentBytes += bytes.byteLength;
     }
-    /** @internal */
     async pump() {
       try {
         if (!this.io) {
-          this.opening ??= this.open();
-          await this.opening;
+          const context = new import_node_av4.IOContext();
+          this.opening = true;
+          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;
         }
         while (this.queue.chunks.length > 0) {
           const chunk = this.queue.chunks.shift();
@@ -5607,8 +5595,8 @@ var MediabunnyServer = (() => {
             this.partialLength += take;
             offset += take;
             if (this.partialLength === PAYLOAD_SIZE) {
-              this.partialLength = 0;
               await this.writeDatagram(this.partial);
+              this.partialLength = 0;
             }
           }
         }
@@ -5618,19 +5606,19 @@ var MediabunnyServer = (() => {
       }
     }
     /** Drains what is queued, then closes. Awaited by the output's `finalize()`. */
-    async finish(aborting = false) {
+    async finish() {
       if (this.closed) {
         return;
       }
       this.closed = true;
+      if (this.listening && this.io === void 0 && this.opening) {
+        await wakePendingAccept(this.url);
+      }
       while (this.pumping !== null || this.queue.chunks.length > 0) {
-        this.pumping ??= this.pump().finally(() => {
-          this.pumping = null;
-        });
-        await this.pumping.catch(() => {
+        await this.kick().catch(() => {
         });
       }
-      if (!aborting && !this.failure && this.io && this.partialLength > 0) {
+      if (!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));
         });
@@ -5641,7 +5629,7 @@ var MediabunnyServer = (() => {
         await this.io.closep().catch(() => {
         });
       }
-      if (this.failure && !aborting) {
+      if (this.failure) {
         throw this.failure;
       }
     }
@@ -5672,43 +5660,39 @@ var MediabunnyServer = (() => {
     }
     if (options.passphrase !== void 0) {
       url.searchParams.set("passphrase", options.passphrase);
-      url.searchParams.set("pbkeylen", String(PBKEYLEN_BY_BITS[options.keyLength ?? 128]));
+      url.searchParams.set("pbkeylen", String((options.keyLength ?? 128) / 8));
     }
     if (options.latency !== void 0) {
-      url.searchParams.set("latency", micros(options.latency / 1e3));
+      url.searchParams.set("latency", String(Math.max(1, Math.round(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();
+    return { url: url.toString(), listening: url.searchParams.get("mode") === "listener" };
   };
   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.");
-      }
+      checkUrlAndOptions(url, options);
+      positive(options.connectTimeout, "connectTimeout");
       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) {
+      if (options.keyLength !== void 0 && !KEY_LENGTHS.includes(options.keyLength)) {
         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.");
-      }
+      positive(options.latency, "latency");
       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);
+      const resolved = srtUrl(url, options);
+      const sink = new SrtSink(
+        resolved.url,
+        options.maxQueueBytes ?? DEFAULT_MAX_QUEUE_BYTES,
+        resolved.listening
+      );
       super(sink.writable);
       this.sink = sink;
     }