@blockcast/mmt-container 2.2.0-main.da2e7cd1dd5d → 2.2.0-main.e75bbd7576a6

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

@@ -5633,13 +5633,21 @@ var BlockcastMmt = (() => {
   function sameSample(a, b) {
     return a.decodeTime === b.decodeTime && a.presentationTime === b.presentationTime && a.duration === b.duration && a.timescale === b.timescale && a.size === b.size && a.bytePosition === b.bytePosition;
   }
-  var _track, _fragments, _pendingSamples, _evictedSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, evictOldestFragment_fn, clearSlot_fn;
+  var _track, _fragments, _firstSamples, _delivered, _pendingSamples, _evictedSamples, _lastMovieFragmentRejection, _IsoBmffTimingResolver_instances, evictOldestFragment_fn, clearSlot_fn;
   var IsoBmffTimingResolver = class {
     constructor(maxPendingSamples) {
       this.maxPendingSamples = maxPendingSamples;
       __privateAdd(this, _IsoBmffTimingResolver_instances);
       __privateAdd(this, _track, null);
       __privateAdd(this, _fragments, /* @__PURE__ */ new Map());
+      /** First sample of each pending fragment, kept in `#delivered` with its sample count. */
+      __privateAdd(this, _firstSamples, /* @__PURE__ */ new Map());
+      /**
+       * First sample and sample count of the newest fragments whose every slot was
+       * cleared. Abandonment counts: `releaseSample` clears a slot too, which
+       * matches the combiner, since it retires an abandoned sample as well.
+       */
+      __privateAdd(this, _delivered, /* @__PURE__ */ new Map());
       __privateAdd(this, _pendingSamples, 0);
       __privateAdd(this, _evictedSamples, 0);
       __privateAdd(this, _lastMovieFragmentRejection, null);
@@ -5647,6 +5655,10 @@ var BlockcastMmt = (() => {
         throw new Error("[IsoBmffTimingResolver] maxPendingSamples must be a positive integer");
       }
     }
+    /** True once an FT=0 has bound the track that FT=1 timing is read against. */
+    get initialized() {
+      return __privateGet(this, _track) !== null;
+    }
     get pendingSampleCount() {
       return __privateGet(this, _pendingSamples);
     }
@@ -5670,7 +5682,14 @@ var BlockcastMmt = (() => {
       __privateSet(this, _track, timing);
       return true;
     }
-    addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples) {
+    /**
+     * `recovered` marks an FEC-recovered copy. A recovered block hands back
+     * every FT=1 it holds, the received ones included, so a recovered copy of a
+     * fragment whose samples are all done is a duplicate: admitting it again
+     * would charge stale timing and could displace the live MPU's. A source
+     * copy is still admitted again (a rendition switch re-arms timing that way).
+     */
+    addMovieFragment(mpuSequenceNumber, data, additionalSampleLimit = this.maxPendingSamples, recovered = false) {
       __privateSet(this, _lastMovieFragmentRejection, null);
       if (!Number.isInteger(additionalSampleLimit) || additionalSampleLimit < 0) {
         __privateSet(this, _lastMovieFragmentRejection, "invalid");
@@ -5696,6 +5715,8 @@ var BlockcastMmt = (() => {
           (sample, index) => sample !== null && sameSample(sample, parsed.samples[index])
         );
       }
+      const delivered = recovered ? __privateGet(this, _delivered).get(key) : void 0;
+      if (delivered && delivered.sampleCount === parsed.samples.length && sameSample(delivered.first, parsed.samples[0])) return true;
       let freed = 0;
       while (__privateGet(this, _fragments).size > 0 && (__privateGet(this, _pendingSamples) + parsed.samples.length > this.maxPendingSamples || parsed.samples.length - freed > additionalSampleLimit)) {
         freed += __privateMethod(this, _IsoBmffTimingResolver_instances, evictOldestFragment_fn).call(this);
@@ -5709,6 +5730,7 @@ var BlockcastMmt = (() => {
         return false;
       }
       __privateGet(this, _fragments).set(key, [...parsed.samples]);
+      __privateGet(this, _firstSamples).set(key, parsed.samples[0]);
       __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) + parsed.samples.length);
       return true;
     }
@@ -5755,11 +5777,15 @@ var BlockcastMmt = (() => {
     reset() {
       __privateSet(this, _track, null);
       __privateGet(this, _fragments).clear();
+      __privateGet(this, _firstSamples).clear();
+      __privateGet(this, _delivered).clear();
       __privateSet(this, _pendingSamples, 0);
     }
   };
   _track = new WeakMap();
   _fragments = new WeakMap();
+  _firstSamples = new WeakMap();
+  _delivered = new WeakMap();
   _pendingSamples = new WeakMap();
   _evictedSamples = new WeakMap();
   _lastMovieFragmentRejection = new WeakMap();
@@ -5778,6 +5804,7 @@ var BlockcastMmt = (() => {
     let live = 0;
     for (const sample of samples) if (sample !== null) live++;
     __privateGet(this, _fragments).delete(oldest);
+    __privateGet(this, _firstSamples).delete(oldest);
     __privateSet(this, _pendingSamples, __privateGet(this, _pendingSamples) - live);
     __privateSet(this, _evictedSamples, __privateGet(this, _evictedSamples) + live);
     return live;
@@ -5793,7 +5820,16 @@ var BlockcastMmt = (() => {
     if (!samples || !samples[index]) return false;
     samples[index] = null;
     __privateWrapper(this, _pendingSamples)._--;
-    if (samples.every((value) => value === null)) __privateGet(this, _fragments).delete(key);
+    if (samples.every((value) => value === null)) {
+      __privateGet(this, _fragments).delete(key);
+      const first = __privateGet(this, _firstSamples).get(key);
+      __privateGet(this, _firstSamples).delete(key);
+      __privateGet(this, _delivered).delete(key);
+      __privateGet(this, _delivered).set(key, { first, sampleCount: samples.length });
+      if (__privateGet(this, _delivered).size > this.maxPendingSamples) {
+        __privateGet(this, _delivered).delete(__privateGet(this, _delivered).keys().next().value);
+      }
+    }
     return true;
   };
   function fragmentKey(mpuSequenceNumber, movieFragmentSequenceNumber) {
@@ -6255,7 +6291,7 @@ var BlockcastMmt = (() => {
     return FMPU_BOX_TYPES.has(type);
   }
   var MAX_AWAITING_TIMING_HEADS = 8;
-  var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _reclaimedTimingSamples, _evictedTimingSamples, _rejectedMovieFragments, _sequencers, _fecGate, _fecSequencer, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed, _replayingAwaitingTiming, _fedObjects, _reassemblerFragmentsFed, _reassemblerDataUnitsReturned, _feedOutcomes, _deferredFeedOutcomes, _lastOutcome, _lastOutcomeCount, _MmtpContainerParser_instances, streamKey_fn, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, countOutcome_fn, countDeferredOutcome_fn, drop_fn, feedCounted_fn, feed_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, awaitTiming_fn, replayAwaitingTiming_fn, dropTimingStream_fn, validateReassemblyPolicy_fn, buildFrameMeta_fn, sequencerFor_fn, flushSequencers_fn, emitFrame_fn2, _MmtpContainerParser_static, scanForKeyframe_fn, scanLengthPrefixedHevcForKeyframe_fn, scanAnnexBForKeyframe_fn;
+  var _tracks, _defaultTrack, _reassembler, _sampleCombiners, _sampleCombinerOptions, _retiredSampleCombinerStats, _timingStreams, _maxPendingTimingSamples, _pendingTimingSamples, _reclaimedTimingSamples, _evictedTimingSamples, _rejectedMovieFragments, _recoveredHeadsAwaitingTiming, _sequencers, _fecGate, _fecSequencer, _reorderWindow, _reassemblyPolicy, _frameCb, _initCb, _sourceSymbolCb, _trackFrameCbs, _reorderStats, _reliableMoqStartupGate, _disposed, _replayingAwaitingTiming, _fedObjects, _reassemblerFragmentsFed, _reassemblerDataUnitsReturned, _feedOutcomes, _deferredFeedOutcomes, _lastOutcome, _lastOutcomeCount, _MmtpContainerParser_instances, streamKey_fn, sampleCombinerFor_fn, releaseTimingSlot_fn, dropSampleCombiner_fn, countOutcome_fn, countDeferredOutcome_fn, drop_fn, feedCounted_fn, feed_fn, emitCombinedSample_fn, passReliableMoqStartupGate_fn, timingResolver_fn, awaitTiming_fn, leaveAwaitingTiming_fn, replayAwaitingTiming_fn, dropTimingStream_fn, validateReassemblyPolicy_fn, buildFrameMeta_fn, sequencerFor_fn, flushSequencers_fn, emitFrame_fn2, _MmtpContainerParser_static, scanForKeyframe_fn, scanLengthPrefixedHevcForKeyframe_fn, scanAnnexBForKeyframe_fn;
   var _MmtpContainerParser = class _MmtpContainerParser {
     constructor(config) {
       __privateAdd(this, _MmtpContainerParser_instances);
@@ -6291,6 +6327,12 @@ var BlockcastMmt = (() => {
       __privateAdd(this, _reclaimedTimingSamples, 0);
       __privateAdd(this, _evictedTimingSamples, 0);
       __privateAdd(this, _rejectedMovieFragments, 0);
+      __privateAdd(this, _recoveredHeadsAwaitingTiming, {
+        held: 0,
+        expired: 0,
+        discarded: 0,
+        superseded: 0
+      });
       __privateAdd(this, _sequencers, /* @__PURE__ */ new Map());
       __privateAdd(this, _fecGate, null);
       __privateAdd(this, _fecSequencer, null);
@@ -6433,6 +6475,14 @@ var BlockcastMmt = (() => {
         rejectedMovieFragments: __privateGet(this, _rejectedMovieFragments)
       };
     }
+    /** Recovered heads parked for FT=1 timing (BLO-53369). Survives dispose(). */
+    get recoveredHeadsAwaitingTiming() {
+      let pending = 0;
+      for (const { awaitingTiming } of __privateGet(this, _timingStreams).values()) {
+        for (const head of awaitingTiming) if (head.options?.recovered) pending++;
+      }
+      return { ...__privateGet(this, _recoveredHeadsAwaitingTiming), pending };
+    }
     get reorderStats() {
       let bufferedFrames = __privateGet(this, _fecSequencer)?.buffered ?? 0;
       for (const { sequencer } of __privateGet(this, _sequencers).values()) bufferedFrames += sequencer.buffered;
@@ -6584,7 +6634,7 @@ var BlockcastMmt = (() => {
       const now = Date.now();
       for (const { awaitingTiming } of __privateGet(this, _timingStreams).values()) {
         while (awaitingTiming.length > 0 && now - awaitingTiming[0].arrivedAt > timeoutMs) {
-          awaitingTiming.shift();
+          __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, awaitingTiming.shift(), "expired");
         }
       }
     }
@@ -6837,6 +6887,9 @@ var BlockcastMmt = (() => {
       for (const { sequencer } of __privateGet(this, _sequencers).values()) sequencer.discard();
       __privateGet(this, _sequencers).clear();
       __privateGet(this, _fecSequencer)?.discard();
+      for (const { awaitingTiming } of __privateGet(this, _timingStreams).values()) {
+        for (const head of awaitingTiming) __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, head, "discarded");
+      }
       __privateGet(this, _timingStreams).clear();
       __privateSet(this, _pendingTimingSamples, 0);
       __privateGet(this, _reliableMoqStartupGate).clear();
@@ -6865,6 +6918,7 @@ var BlockcastMmt = (() => {
   _reclaimedTimingSamples = new WeakMap();
   _evictedTimingSamples = new WeakMap();
   _rejectedMovieFragments = new WeakMap();
+  _recoveredHeadsAwaitingTiming = new WeakMap();
   _sequencers = new WeakMap();
   _fecGate = new WeakMap();
   _fecSequencer = new WeakMap();
@@ -7023,11 +7077,16 @@ var BlockcastMmt = (() => {
       if (mpu.fragmentationIndicator !== 0 || mpu.fragmentCounter !== 0)
         return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "fragment-unexpected-fragmentation");
       const resolver2 = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, false);
-      if (!resolver2) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "fragment-no-resolver");
+      if (!resolver2?.initialized) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "fragment-no-resolver");
       const pendingBefore = resolver2.pendingSampleCount;
       const evictedBefore = resolver2.evictedSampleCount;
       const remaining = __privateGet(this, _maxPendingTimingSamples) - __privateGet(this, _pendingTimingSamples);
-      const admitted = resolver2.addMovieFragment(mpu.mpuSequenceNumber, data, remaining);
+      const admitted = resolver2.addMovieFragment(
+        mpu.mpuSequenceNumber,
+        data,
+        remaining,
+        options?.recovered === true
+      );
       __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) + (resolver2.pendingSampleCount - pendingBefore));
       __privateSet(this, _evictedTimingSamples, __privateGet(this, _evictedTimingSamples) + (resolver2.evictedSampleCount - evictedBefore));
       if (!admitted) {
@@ -7047,7 +7106,7 @@ var BlockcastMmt = (() => {
       };
     }
     if (fragmentType !== 2) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "unknown-fragment-type");
-    const resolver = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, false);
+    const resolver = __privateMethod(this, _MmtpContainerParser_instances, timingResolver_fn).call(this, streamKey, info.packetId, true);
     if (!resolver) return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-no-resolver");
     if (!Number.isSafeInteger(data.byteLength) || data.byteLength <= 0)
       return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-empty-payload");
@@ -7068,6 +7127,7 @@ var BlockcastMmt = (() => {
           mpuSequenceNumber: mpu.mpuSequenceNumber,
           movieFragmentSequenceNumber: mfuDuHeader.movieFragmentSequenceNumber,
           sampleNumber: mfuDuHeader.sampleNumber,
+          sequenceNumber: info.sequenceNumber,
           arrivedAt: Date.now()
         });
         return __privateMethod(this, _MmtpContainerParser_instances, drop_fn).call(this, "mfu-sample-timing-missing");
@@ -7249,10 +7309,23 @@ var BlockcastMmt = (() => {
     return resolver;
   };
   awaitTiming_fn = function(streamKey, head) {
-    const awaitingTiming = __privateGet(this, _timingStreams).get(streamKey)?.awaitingTiming;
-    if (!awaitingTiming) return;
+    const state = __privateGet(this, _timingStreams).get(streamKey);
+    if (!state) return;
+    if (!head.options?.recovered) {
+      const kept = state.awaitingTiming.filter((queued) => !queued.options?.recovered || queued.sequenceNumber !== head.sequenceNumber);
+      __privateGet(this, _recoveredHeadsAwaitingTiming).superseded += state.awaitingTiming.length - kept.length;
+      state.awaitingTiming = kept;
+    }
+    const awaitingTiming = state.awaitingTiming;
     awaitingTiming.push(head);
-    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) awaitingTiming.shift();
+    if (head.options?.recovered) __privateGet(this, _recoveredHeadsAwaitingTiming).held++;
+    if (awaitingTiming.length > MAX_AWAITING_TIMING_HEADS) {
+      __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, awaitingTiming.shift(), "expired");
+    }
+  };
+  /** Count a recovered head leaving the queue other than by replay or its source copy. */
+  leaveAwaitingTiming_fn = function(head, outcome) {
+    if (head.options?.recovered) __privateGet(this, _recoveredHeadsAwaitingTiming)[outcome]++;
   };
   /**
    * Feed again the heads whose timing the FT=1 just admitted declares. That
@@ -7280,6 +7353,7 @@ var BlockcastMmt = (() => {
     const state = __privateGet(this, _timingStreams).get(streamKey);
     if (!state) return;
     __privateGet(this, _timingStreams).delete(streamKey);
+    for (const head of state.awaitingTiming) __privateMethod(this, _MmtpContainerParser_instances, leaveAwaitingTiming_fn).call(this, head, "discarded");
     __privateSet(this, _pendingTimingSamples, __privateGet(this, _pendingTimingSamples) - state.resolver.pendingSampleCount);
     if (__privateGet(this, _pendingTimingSamples) < 0) {
       throw new Error("[MmtpContainerParser] pending timing sample accounting underflow");