@blockcast/mmt-container 0.5.0-main.8fbc25eb9deb → 0.5.0-main.d53b0164c5de

package/dist/browser-runtime.js

@@ -19459,6 +19459,9 @@ var NO_BLOCK_SPAN_HORIZON = Object.freeze({
   reason: "no-block-span"
 });
 var DIRECT_RECOVERED_VIDEO_QUEUE_LIMIT = 512;
+var ASSIST_BLOCK_LIMIT = 64;
+var ASSIST_FAILED_DECODES_MAX = 2;
+var assistKey = (ownerPacketId, catalogTrackName, blockStart) => `${ownerPacketId}/${catalogTrackName ?? ""}/${blockStart}`;
 var DIRECT_RECOVERED_AUDIO_QUEUE_LIMIT = 512;
 function sourceSymbolEvidence(packet, header, rapFlag, packetSequenceNumber) {
   const identity = MmtpContainerParser.sourcePacketIdentity(packet, header);
@@ -19483,6 +19486,11 @@ var MmtpRouter = class {
   #provenance = /* @__PURE__ */ new Map();
   #onFlowProtected = null;
   #unadmittedListedDrops = 0;
+  #unlistedRepairSetAside = 0;
+  #assistBlocks = /* @__PURE__ */ new Map();
+  #scratchDecoderFactory = null;
+  #unlistedAssistedRecoveries = 0;
+  #unlistedAssistedRefusals = 0;
   /** The ingress a held datagram arrived with; the receiver returns the same bytes on release. */
   #heldIngress = /* @__PURE__ */ new WeakMap();
   #unicastRepair = false;
@@ -20198,14 +20206,13 @@ var MmtpRouter = class {
   updateProvenanceFlowIngress(ingress) {
     const entry = this.#provenance.get(ingress.flow);
     if (!entry) return;
+    const added = entry.protected ? ingress.tracks.filter(({ name, packetId }) => name && !entry.ingress.tracks.some((t) => t.name === name && t.packetId === packetId)) : [];
+    const governed = added.map(({ packetId }) => [...this.#repairOwnersByPacketId.get(packetId) ?? [packetId]].some((owner) => this.#governs(owner)));
     this.#provenance.set(ingress.flow, { ...entry, ingress });
-    if (entry.protected) {
-      for (const { name, packetId } of ingress.tracks) {
-        if (name && !entry.ingress.tracks.some((t) => t.name === name && t.packetId === packetId)) {
-          this.#fecManager?.resetTrack?.(packetId, name);
-        }
-      }
-    }
+    added.forEach(({ name, packetId }, i) => {
+      if (governed[i]) for (const block of this.#assistBlocks.values()) block.pooled.clear();
+      else this.#fecManager?.resetTrack?.(packetId, name);
+    });
   }
   /**
    * Called once per protection of a flow: at the admission that makes this
@@ -20226,11 +20233,138 @@ var MmtpRouter = class {
     if (!entry) return;
     entry.receiver.release();
     entry.protected = false;
+    this.#assistBlocks.clear();
   }
   /** MoQ packets of a track a protected flow lists, dropped on its unicast path: duplicate, overflow, or listed by more than one flow. */
   get unadmittedListedDropCount() {
     return this.#unadmittedListedDrops;
   }
+  /** MoQ repair symbols of an unlisted track kept out of a governed FEC instance (7.2.7 step 2). */
+  get unlistedRepairSetAsideCount() {
+    return this.#unlistedRepairSetAside;
+  }
+  /** Governed blocks recovered with the help of unlisted repair (7.2.7 step 2). */
+  get unlistedAssistedRecoveryCount() {
+    return this.#unlistedAssistedRecoveries;
+  }
+  /** Unlisted-assisted decodes refused because two already failed for the block (7.2.7 step 2). */
+  get unlistedAssistedRefusalCount() {
+    return this.#unlistedAssistedRefusals;
+  }
+  /**
+   * Wire the decoder an unlisted-assisted decode runs in: a fresh, configured
+   * decoder of the owner's track, used once and discarded, never the live one.
+   * Without it unlisted repair on a governed instance is set aside and dropped.
+   */
+  setScratchFecDecoderFactory(factory) {
+    this.#scratchDecoderFactory = factory;
+    if (!factory) this.#assistBlocks.clear();
+  }
+  /** Whether a protected flow lists `ownerPacketId`: its FEC instance is governed (7.2.7). */
+  #governs(ownerPacketId) {
+    for (const entry of this.#provenance.values()) {
+      if (entry.protected && ingressHasPacketId(entry.ingress, ownerPacketId)) return true;
+    }
+    return false;
+  }
+  /**
+   * A MoQ repair symbol no protected flow lists, owned by a source track one
+   * does: its FEC instance is governed (7.2.7 step 2) and takes only admitted
+   * symbols, so the symbol is set aside: pooled for an unlisted-assisted
+   * decode of a block admitted repair already delimits, else dropped. It
+   * never states a block, so the live locator and decoder are unchanged.
+   * Un-listing needs no hook: an unprotected or released flow lists nothing.
+   */
+  #setAsideUnlistedRepair(ownerPacketId, catalogTrackName, repair) {
+    if (!this.#governs(ownerPacketId)) return false;
+    this.#unlistedRepairSetAside++;
+    const key = assistKey(ownerPacketId, catalogTrackName, repair.ssStart);
+    const block = this.#assistBlocks.get(key);
+    if (block !== void 0 && block.ssbLength === repair.ssbLength && !block.repairs.has(repair.rsId) && block.pooled.size < block.ssbLength && repair.symbolData.byteLength === this.#symbolSizeForPacket(ownerPacketId) && this.#fecManager?.admitRepairBlockLength?.(ownerPacketId, repair.ssbLength, repair.rsbLength, repair.rsId) !== false) {
+      block.pooled.set(repair.rsId, repair.symbolData);
+      this.#tryAssistedDecode(key, block, ownerPacketId, catalogTrackName, repair.ssStart);
+    }
+    return true;
+  }
+  /**
+   * An admitted repair placed a governed block (its SSB_length delimits it):
+   * open the block's record, which the symbols its live decoder takes join.
+   */
+  #openAssistBlock(ownerPacketId, catalogTrackName, blockStart, ssbLength) {
+    const key = assistKey(ownerPacketId, catalogTrackName, blockStart);
+    if (!this.#scratchDecoderFactory || this.#assistBlocks.has(key) || !this.#governs(ownerPacketId)) return;
+    this.#assistBlocks.set(key, { ssbLength, sources: /* @__PURE__ */ new Map(), repairs: /* @__PURE__ */ new Map(), pooled: /* @__PURE__ */ new Map(), failed: 0 });
+    for (const oldest of this.#assistBlocks.keys()) {
+      if (this.#assistBlocks.size <= ASSIST_BLOCK_LIMIT) break;
+      this.#assistBlocks.delete(oldest);
+    }
+  }
+  /** A symbol fed to an open governed block's live decoder that did not recover it. */
+  #noteAssistAdmitted(ownerPacketId, catalogTrackName, blockStart, symbol, data) {
+    const key = assistKey(ownerPacketId, catalogTrackName, blockStart);
+    const block = this.#assistBlocks.get(key);
+    if (block === void 0) return;
+    if ("rsId" in symbol) {
+      block.repairs.set(symbol.rsId, data);
+      block.pooled.delete(symbol.rsId);
+    } else {
+      block.sources.set(symbol.esi, data);
+    }
+    this.#tryAssistedDecode(key, block, ownerPacketId, catalogTrackName, blockStart);
+  }
+  /**
+   * 7.2.7 step 2, phase two: a governed block its admitted symbols cannot
+   * decode (the live decoder already had them all) is decoded in a scratch
+   * decoder from its admitted symbols plus pooled unlisted repair, only as
+   * many as close the shortfall. What it recovers is released only through
+   * admission (#routeRecoveredBlock), so the live decoder is never touched and
+   * a refused recovery leaves the block to fail at its FEC deadline. At most
+   * two such decodes may fail per block; a third is refused.
+   */
+  #tryAssistedDecode(key, block, ownerPacketId, catalogTrackName, blockStart) {
+    const fec = this.#fecManager;
+    const admitted = block.sources.size + block.repairs.size;
+    if (!fec || block.pooled.size === 0) return;
+    if (admitted >= block.ssbLength || admitted + block.pooled.size < block.ssbLength) return;
+    if (fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName)) {
+      this.#assistBlocks.delete(key);
+      return;
+    }
+    if (block.failed >= ASSIST_FAILED_DECODES_MAX) {
+      this.#unlistedAssistedRefusals++;
+      return;
+    }
+    const decoder = this.#scratchDecoderFactory?.(ownerPacketId, catalogTrackName);
+    if (!decoder) return;
+    let recovered = null;
+    const fed = [];
+    try {
+      for (const [esi, data] of block.sources) decoder.add_source(serial32Add(blockStart, esi), data, 0);
+      for (const [rsId, data] of block.repairs) {
+        recovered ??= decoder.add_repair(blockStart, block.ssbLength, rsId, data, 0);
+      }
+      for (const [rsId, data] of block.pooled) {
+        if (recovered || fed.length >= block.ssbLength - admitted) break;
+        fed.push(rsId);
+        recovered = decoder.add_repair(blockStart, block.ssbLength, rsId, data, 0);
+      }
+    } catch {
+      recovered = null;
+    } finally {
+      decoder.free?.();
+    }
+    if (recovered && this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName, () => {
+      fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
+      fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
+      fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
+    })) {
+      this.#unlistedAssistedRecoveries++;
+      this.#assistBlocks.delete(key);
+      return;
+    }
+    for (const rsId of fed) block.pooled.delete(rsId);
+    block.failed++;
+  }
   /**
    * The admission that makes this router protected under `flow` (7.2.7):
    * its FEC instances discard what they hold of the flow's listed tracks so
@@ -20406,8 +20540,9 @@ var MmtpRouter = class {
       );
     }
     if (ownerPacketId != null && !admitted) {
-      const admit = this.#admitUnicast(ownerPacketId, packet, () => this.#feedRepairPacket(packet, ownerPacketIdHint, catalogTrackName, repairTrackName, true));
+      const admit = this.#admitUnicast(repairPacketId, packet, () => this.#feedRepairPacket(packet, ownerPacketIdHint, catalogTrackName, repairTrackName, true));
       if (admit === "held" || admit === "dropped") return;
+      if (admit === "unlisted" && this.#fecManager && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackName, parsed)) return;
     }
     if (ownerPacketId != null && this.#fecManager) {
       this.#moqRepairPidCounts[repairPacketId] = (this.#moqRepairPidCounts[repairPacketId] || 0) + 1;
@@ -20527,6 +20662,7 @@ var MmtpRouter = class {
     const placement = fec.placeIsoRepair(ownerPacketId, catalogTrackName, repair.ssStart, repair.ssbLength);
     if (placement.status !== "placed") return;
     const blockStart = placement.block.start;
+    this.#openAssistBlock(ownerPacketId, catalogTrackName, blockStart, repair.ssbLength);
     if (placement.span !== void 0) {
       this.#replayIsoSources(ownerPacketId, catalogTrackName, placement.span.block.start, placement.span.placed);
     }
@@ -20557,6 +20693,8 @@ var MmtpRouter = class {
         fec.countRecovery(ownerPacketId, blockStart, catalogTrackName);
         fec.markBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
       });
+    } else if (!recovered) {
+      this.#noteAssistAdmitted(ownerPacketId, catalogTrackName, blockStart, { rsId: repair.rsId }, repair.symbolData);
     }
   }
   /**
@@ -20596,6 +20734,7 @@ var MmtpRouter = class {
       if (payload.oversized) continue;
       const alreadyCompleted = fec.isBlockCompleted(blockStart, ownerPacketId, catalogTrackName);
       const recovered = fec.feedSourceSymbol(ownerPacketId, ssId, payload.symbolData, catalogTrackName);
+      if (!recovered) this.#noteAssistAdmitted(ownerPacketId, catalogTrackName, blockStart, { esi }, payload.symbolData);
       if (!recovered || alreadyCompleted) continue;
       this.#routeRecoveredBlock(blockStart, recovered, ownerPacketId, catalogTrackName, () => {
         fec.cancelBlockTimeout(blockStart, ownerPacketId, catalogTrackName);
@@ -20666,6 +20805,8 @@ var MmtpRouter = class {
       }
     }
     this.#parser.resetTrack(packetId, catalogTrackName);
+    const assistPrefix = assistKey(packetId, catalogTrackName, 0).slice(0, -1);
+    for (const key of this.#assistBlocks.keys()) if (key.startsWith(assistPrefix)) this.#assistBlocks.delete(key);
     const streamKey = this.#mediaStreamKey(packetId, catalogTrackName);
     this.#trackSynced.delete(streamKey);
     this.#droppedPreSyncVideo.delete(streamKey);
@@ -21326,6 +21467,7 @@ var MmtpRouter = class {
       const ownerPacketId = this.#resolveRepairOwnerPacketId(info.packetId, ingress);
       if (ownerPacketId != null && this.#fecManager) {
         if (hasAmbiguousCatalogTrackName(ingress, ownerPacketId)) return;
+        if (source === "moq" && !manifestAdmitted && this.#setAsideUnlistedRepair(ownerPacketId, catalogTrackNameForPacket(ingress, ownerPacketId), repair)) return;
         this.#repairPidCounts[info.packetId] = (this.#repairPidCounts[info.packetId] || 0) + 1;
         const count = this.#repairPidCounts[info.packetId];
         if (count <= 2 || count % 500 === 0) {
@@ -21493,6 +21635,15 @@ var MmtpRouter = class {
           sourceFec.symbolData,
           catalogTrackName
         );
+        if (!recovered) {
+          this.#noteAssistAdmitted(
+            info.packetId,
+            catalogTrackName,
+            sourceFec.sbn,
+            { esi: serial32Distance(sourceFec.sbn, sourceFec.ssId) },
+            sourceFec.symbolData
+          );
+        }
         if (recovered && !alreadyCompleted) {
           const fec = this.#fecManager;
           const sbn = sourceFec.sbn;
@@ -28120,6 +28271,14 @@ var MulticastManager = class {
         }
       }
     }
+    const factory = typeof wasmDecoderSource === "function" ? wasmDecoderSource : null;
+    const fecTracks = fecTrackIndexes.map((i) => catalog.tracks[i]);
+    this.#router.setScratchFecDecoderFactory(factory && ((ownerPacketId, catalogTrackName) => {
+      const track = fecTracks.find((t) => t.packetId === ownerPacketId && t.name === catalogTrackName);
+      if (!track) return null;
+      const decoder = factory(track);
+      return [...fecDecoders.values()].includes(decoder) ? null : decoder;
+    }));
     this.#switchingSets.clear();
     this.#repairPacketIds.clear();
     this.#router.clearRepairPacketIdOwners();