@blockcast/mmt-container 2.2.0-main.75b39a2cdddf → 2.2.0-main.7e8a9d13c01c

package/dist/mmtp-container-parser.no-modules.js

@@ -6005,7 +6005,10 @@ var BlockcastMmt = (() => {
   function ssIdAfter(a, b) {
     return (a - b | 0) > 0;
   }
-  var _streams2, _gate, _emit2, _recordStat2, _deferDepth, _deferredStreams, _FecReleaseSequencer_instances, drainUnlessDeferred_fn, streamFor_fn2, drain_fn, release_fn;
+  function holdsRebuilt(stream) {
+    return stream.buf.some(({ meta }) => meta.fecSbnFirst !== void 0);
+  }
+  var _streams2, _gate, _emit2, _recordStat2, _deferDepth, _deferredStreams, _FecReleaseSequencer_instances, drainUnlessDeferred_fn, streamFor_fn2, drain_fn, drainLoop_fn, cursorPassed_fn, release_fn;
   var FecReleaseSequencer = class {
     constructor(gate, emit, recordStat) {
       __privateAdd(this, _FecReleaseSequencer_instances);
@@ -6065,6 +6068,7 @@ var BlockcastMmt = (() => {
         stream.lastSbn = void 0;
         stream.discontinuity = false;
         stream.rapSsId = void 0;
+        stream.sourced = false;
       }
       if (stream.last !== null && compareFrameOrder(frame, stream.last) <= 0) {
         __privateGet(this, _recordStat2).call(this, "droppedStale");
@@ -6091,6 +6095,7 @@ var BlockcastMmt = (() => {
         if (compareFrameOrder(stream.buf[mid], frame) < 0) lo = mid + 1;
         else hi = mid;
       }
+      if (stream.buf[lo]?.passed === true) frame.passed = true;
       stream.buf.splice(lo, 0, frame);
       __privateMethod(this, _FecReleaseSequencer_instances, drainUnlessDeferred_fn).call(this, stream);
     }
@@ -6126,6 +6131,41 @@ var BlockcastMmt = (() => {
       }
       return false;
     }
+    /**
+     * These streams' sink is being replaced by one that has seen no source
+     * frame yet. First, from a stream that holds a frame the overlay rebuilt,
+     * release to the sink being replaced the frames the unanchored path had
+     * already released to it (#cursorPassed): there they waited in its queue,
+     * which its replacement flushes. A stream that holds none is not drained:
+     * it holds nothing the anchor kept back, and a drain would still force out
+     * a frame held past the hold limit, which before the anchor waited for the
+     * next push. Then treat the streams as unsourced until a source frame is
+     * released.
+     */
+    unsource(packetId, catalogTrackName) {
+      for (const stream of __privateGet(this, _streams2).values()) {
+        if (stream.packetId === packetId && (catalogTrackName === void 0 || stream.catalogTrackName === catalogTrackName)) {
+          if (stream.draining === 0 && holdsRebuilt(stream)) {
+            if (__privateGet(this, _deferDepth) > 0) __privateGet(this, _deferredStreams).add(stream);
+            else __privateMethod(this, _FecReleaseSequencer_instances, drain_fn).call(this, stream, true);
+          }
+          stream.sourced = false;
+        }
+      }
+    }
+    /**
+     * Whether a stream of `packetId` holds a frame the keyframe overlay rebuilt
+     * (FrameMeta.fecSbnFirst). Without `catalogTrackName`, every stream of the
+     * packetId.
+     */
+    holdsRebuilt(packetId, catalogTrackName) {
+      for (const stream of __privateGet(this, _streams2).values()) {
+        if (stream.packetId !== packetId) continue;
+        if (catalogTrackName !== void 0 && stream.catalogTrackName !== catalogTrackName) continue;
+        if (holdsRebuilt(stream)) return true;
+      }
+      return false;
+    }
     /** Re-evaluate held gaps after FEC state changed. */
     poke(streamKey) {
       if (streamKey !== void 0) {
@@ -6229,16 +6269,32 @@ var BlockcastMmt = (() => {
         last: null,
         lastSbn: void 0,
         discontinuity: false,
-        rapSsId: void 0
+        rapSsId: void 0,
+        sourced: false,
+        draining: 0
       };
       __privateGet(this, _streams2).set(streamKey, stream);
     }
     return stream;
   };
-  drain_fn = function(stream) {
+  /** `asUnanchored`: release overlay-rebuilt frames when unanchored did (#cursorPassed). */
+  drain_fn = function(stream, asUnanchored = false) {
+    stream.draining++;
+    try {
+      __privateMethod(this, _FecReleaseSequencer_instances, drainLoop_fn).call(this, stream, asUnanchored);
+    } finally {
+      stream.draining--;
+    }
+  };
+  drainLoop_fn = function(stream, asUnanchored) {
     while (stream.buf.length > 0 && stream.last !== null) {
       const head = stream.buf[0];
       const last = stream.last;
+      if (compareFrameOrder(head, last) <= 0) {
+        stream.buf.shift();
+        __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, void 0);
+        continue;
+      }
       if (stream.discontinuity) {
         stream.discontinuity = false;
         stream.buf.shift();
@@ -6252,9 +6308,10 @@ var BlockcastMmt = (() => {
       }
       const headSbn = head.meta.fecSbn;
       const from = stream.lastSbn ?? headSbn;
-      const to = headSbn ?? stream.lastSbn;
+      const to = head.meta.fecSbnFirst ?? headSbn ?? stream.lastSbn;
       let lost = [];
       const unanchored = from === void 0 && to === void 0;
+      let unresolved = false;
       if (from !== void 0 && to !== void 0) {
         const resolved = __privateGet(this, _gate).resolvedLoss(
           stream.packetId,
@@ -6263,7 +6320,8 @@ var BlockcastMmt = (() => {
           Math.max(from, to),
           from
         );
-        if (resolved === null) {
+        unresolved = resolved === null;
+        if (unresolved && !__privateMethod(this, _FecReleaseSequencer_instances, cursorPassed_fn).call(this, stream, asUnanchored)) {
           const heldMs = performance.now() - head.arrivedAtMs;
           if (heldMs <= __privateGet(this, _gate).holdLimitMs(stream.packetId, stream.catalogTrackName)) return;
           __privateGet(this, _recordStat2).call(this, "forcedWindowFlushes");
@@ -6271,18 +6329,52 @@ var BlockcastMmt = (() => {
           __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, __privateGet(this, _gate).decide(last, head, [], true));
           continue;
         }
-        lost = resolved;
+        lost = resolved ?? [];
       }
       stream.buf.shift();
-      __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, lost.length > 0 || unanchored || authoredGap(last.meta, head.meta) ? __privateGet(this, _gate).decide(last, head, lost, false) : void 0);
+      __privateMethod(this, _FecReleaseSequencer_instances, release_fn).call(this, stream, head, lost.length > 0 || unanchored || unresolved || authoredGap(last.meta, head.meta) ? __privateGet(this, _gate).decide(last, head, lost, false) : void 0);
     }
   };
+  /**
+   * An overlay-rebuilt frame (fecSbnFirst) waits no longer than the BLO-53342
+   * source cursor holds it unanchored, and neither does a later frame behind
+   * it. Unanchored, a frame that waits on no block (fecSbnFirst set, or no
+   * fecSbn) left the gate once every frame ahead of it had: mark it `passed`,
+   * like each frame that arrived in front of it since (stale there). The head
+   * then goes, decided as it would be unanchored, once a frame the base path
+   * delivered (a source frame, or one base FEC recovered) is buffered after a
+   * marked one: the base path has passed that one, so a frame still missing
+   * before it can only come from a repair. It also goes while no source frame
+   * has been released, when the direct path shows a recovered frame at once.
+   * And it goes at once while a staged switch decides on when frames arrive
+   * (FecReleaseGate.releaseUnanchored), and when unsource releases into a
+   * sink being replaced: unanchored, it had already reached the sink.
+   * The scan also writes: the `passed` marks it sets stay on the frames,
+   * and push marks a frame it inserts in front of a marked one from them.
+   */
+  cursorPassed_fn = function(stream, asUnanchored) {
+    let at = -1;
+    for (let i = 0; i < stream.buf.length; i++) {
+      const frame = stream.buf[i];
+      if (frame.meta.fecSbnFirst !== void 0 || frame.meta.fecSbn === void 0) {
+        frame.passed = true;
+        if (at < 0) at = i;
+      } else if (frame.passed !== true) break;
+    }
+    if (at < 0) return false;
+    return asUnanchored || !stream.sourced || __privateGet(this, _gate).releaseUnanchored?.(stream.packetId, stream.catalogTrackName) === true || stream.buf.some(({ meta }, i) => i > at && meta.fecSbnFirst === void 0 && (meta.recovered !== true || meta.fecSbn !== void 0));
+  };
   release_fn = function(stream, frame, decision) {
+    const stale = stream.last !== null && compareFrameOrder(frame, stream.last) <= 0;
+    if (stale) __privateGet(this, _recordStat2).call(this, "droppedStale");
     if (decision) frame.meta.gapBefore = decision;
     stream.last = frame;
-    if (frame.meta.fecSbn !== void 0) stream.lastSbn = frame.meta.fecSbn;
+    if (frame.meta.fecSbn !== void 0 && (frame.meta.fecSbnFirst === void 0 || stream.lastSbn !== void 0)) {
+      stream.lastSbn = frame.meta.fecSbn;
+    }
+    if (frame.meta.recovered !== true) stream.sourced = true;
     __privateGet(this, _gate).onReleased?.(frame.data, frame.meta);
-    __privateGet(this, _emit2).call(this, frame.data, frame.meta);
+    if (!stale) __privateGet(this, _emit2).call(this, frame.data, frame.meta);
   };
   var FMPU_BOX_TYPES = /* @__PURE__ */ new Set(["ftyp", "moov", "moof"]);
   function isFmp4Box(data) {
@@ -6525,6 +6617,14 @@ var BlockcastMmt = (() => {
     fecReleaseRapAbove(packetId, catalogTrackName, ssId) {
       return __privateGet(this, _fecSequencer)?.rapAbove(packetId, catalogTrackName, ssId) ?? false;
     }
+    /** See FecReleaseSequencer.unsource. */
+    unsourceFecRelease(packetId, catalogTrackName) {
+      __privateGet(this, _fecSequencer)?.unsource(packetId, catalogTrackName);
+    }
+    /** See FecReleaseSequencer.holdsRebuilt. */
+    fecReleaseHoldsRebuilt(packetId, catalogTrackName) {
+      return __privateGet(this, _fecSequencer)?.holdsRebuilt(packetId, catalogTrackName) ?? false;
+    }
     /** Re-evaluate held gaps after FEC block state changed. */
     pokeFecRelease(packetId, catalogTrackName) {
       if (!__privateGet(this, _fecSequencer)) return;
@@ -7149,7 +7249,7 @@ var BlockcastMmt = (() => {
         headTiming.size
       );
       if (readyOnRegister) {
-        const deferred = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, readyOnRegister, info, resolver, options?.recovered === true, options?.fecSbn);
+        const deferred = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, readyOnRegister, info, resolver, options?.recovered === true, options?.fecSbn, options?.fecSbnFirst);
         if (deferred.record === void 0) __privateMethod(this, _MmtpContainerParser_instances, countDeferredOutcome_fn).call(this, deferred.reason);
       }
     }
@@ -7236,7 +7336,7 @@ var BlockcastMmt = (() => {
         fragmentCounter: mpu.fragmentCounter
       };
     }
-    const outcome = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, combined, info, resolver, options?.recovered === true, options?.fecSbn);
+    const outcome = __privateMethod(this, _MmtpContainerParser_instances, emitCombinedSample_fn).call(this, combined, info, resolver, options?.recovered === true, options?.fecSbn, options?.fecSbnFirst);
     if (outcome.record !== void 0) return outcome.record;
     return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, outcome.reason);
   };
@@ -7255,7 +7355,7 @@ var BlockcastMmt = (() => {
    * attribution exists to keep readable. Leaving the choice at the call site
    * is what keeps both true.
    */
-  emitCombinedSample_fn = function(combined, info, resolver, recovered, fecSbn) {
+  emitCombinedSample_fn = function(combined, info, resolver, recovered, fecSbn, fecSbnFirst) {
     const timing = resolver.sampleTiming(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,
@@ -7266,6 +7366,7 @@ var BlockcastMmt = (() => {
     const meta = __privateMethod(this, _MmtpContainerParser_instances, buildFrameMeta_fn).call(this, combined, info.packetId, info.sequenceNumber, timing, recovered);
     if (!meta) return { reason: "combined-meta-build-failed" };
     if (fecSbn !== void 0) meta.fecSbn = fecSbn;
+    if (fecSbnFirst !== void 0) meta.fecSbnFirst = fecSbnFirst;
     if (!resolver.consumeSample(
       combined.mpuSequenceNumber,
       combined.movieFragmentSequenceNumber,