rx-player 3.26.1 → 3.26.2

package/src/core/init/stall_avoider.ts

@@ -14,17 +14,15 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-  merge as observableMerge,
-} from "rxjs";
 import {
   ignoreElements,
   map,
+  merge as observableMerge,
+  Observable,
   scan,
   tap,
   withLatestFrom,
-} from "rxjs/operators";
+} from "rxjs";
 import isSeekingApproximate from "../../compat/is_seeking_approximate";
 import config from "../../config";
 import { MediaError } from "../../errors";
@@ -33,11 +31,15 @@ import Manifest, {
   Period,
 } from "../../manifest";
 import { getNextRangeGap } from "../../utils/ranges";
+import {
+  IPlaybackObservation,
+  PlaybackObserver,
+} from "../api";
 import { IBufferType } from "../segment_buffers";
 import EVENTS from "../stream/events_generators";
 import {
-  IInitClockTick,
   IStalledEvent,
+  IStallingSituation,
   IUnstalledEvent,
   IWarningEvent,
 } from "./types";
@@ -122,10 +124,7 @@ interface IDiscontinuityStoredInfo {
  * Monitor situations where playback is stalled and try to get out of those.
  * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
  * encountered and exited.
- * @param {Observable} clock$ - Observable emitting the current playback
- * conditions.
- * @param {HTMLMediaElement} mediaElement - The HTMLMediaElement on which the
- * media is played.
+ * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
@@ -133,12 +132,10 @@ interface IDiscontinuityStoredInfo {
  * @returns {Observable}
  */
 export default function StallAvoider(
-  clock$: Observable<IInitClockTick>,
-  mediaElement : HTMLMediaElement,
+  playbackObserver : PlaybackObserver,
   manifest: Manifest | null,
-  discontinuityUpdate$: Observable<IDiscontinuityEvent>,
   lockedStream$ : Observable<ILockedStreamEvent>,
-  setCurrentTime: (nb: number) => void
+  discontinuityUpdate$: Observable<IDiscontinuityEvent>
 ) : Observable<IStalledEvent | IUnstalledEvent | IWarningEvent> {
   const initialDiscontinuitiesStore : IDiscontinuityStoredInfo[] = [];
 
@@ -147,10 +144,10 @@ export default function StallAvoider(
    * order (first ordered by Period's start, then by bufferType in any order.
    */
   const discontinuitiesStore$ = discontinuityUpdate$.pipe(
-    withLatestFrom(clock$), // listen to clock to clean-up old discontinuities
+    withLatestFrom(playbackObserver.observe(true)),
     scan(
-      (discontinuitiesStore, [evt, tick]) =>
-        updateDiscontinuitiesStore(discontinuitiesStore, evt, tick),
+      (discontinuitiesStore, [evt, observation]) =>
+        updateDiscontinuitiesStore(discontinuitiesStore, evt, observation),
       initialDiscontinuitiesStore));
 
   /**
@@ -187,41 +184,47 @@ export default function StallAvoider(
    * Period handled by that stream to unlock the situation.
    */
   const unlock$ = lockedStream$.pipe(
-    withLatestFrom(clock$),
-    tap(([lockedStreamEvt, tick]) => {
+    withLatestFrom(playbackObserver.observe(true)),
+    tap(([lockedStreamEvt, observation]) => {
       // TODO(PaulB) also skip when the user's wanted speed is set to `0`, as we
       // might not want to seek in that case?
       if (
-        !tick.rebuffering ||
-        tick.paused || (
+        !observation.rebuffering ||
+        observation.paused || (
           lockedStreamEvt.bufferType !== "audio" &&
           lockedStreamEvt.bufferType !== "video"
         )
       ) {
         return;
       }
-      const currPos = tick.position;
-      const rebufferingPos = tick.rebuffering.position ?? currPos;
+      const currPos = observation.position;
+      const rebufferingPos = observation.rebuffering.position ?? currPos;
       const lockedPeriodStart = lockedStreamEvt.period.start;
       if (currPos < lockedPeriodStart &&
           Math.abs(rebufferingPos - lockedPeriodStart) < 1)
       {
         log.warn("Init: rebuffering because of a future locked stream.\n" +
                  "Trying to unlock by seeking to the next Period");
-        setCurrentTime(lockedPeriodStart + 0.001);
+        playbackObserver.setCurrentTime(lockedPeriodStart + 0.001);
       }
     }),
+    // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+    // first type parameter as `any` instead of the perfectly fine `unknown`,
+    // leading to linter issues, as it forbids the usage of `any`.
+    // This is why we're disabling the eslint rule.
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
     ignoreElements()
   );
 
-  const stall$ = clock$.pipe(
+  const stall$ = playbackObserver.observe(true).pipe(
     withLatestFrom(discontinuitiesStore$),
-    map(([tick, discontinuitiesStore]) => {
+    map(([observation, discontinuitiesStore]) => {
       const { buffered,
               position,
               readyState,
               rebuffering,
-              freezing } = tick;
+              freezing } = observation;
+
       if (freezing !== null) {
         const now = performance.now();
 
@@ -231,7 +234,8 @@ export default function StallAvoider(
 
         if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
           log.warn("Init: trying to seek to un-freeze player");
-          setCurrentTime(tick.getCurrentTime() + UNFREEZING_DELTA_POSITION);
+          playbackObserver.setCurrentTime(
+            playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
           prevFreezingState = { attemptTimestamp: now };
         }
 
@@ -245,28 +249,41 @@ export default function StallAvoider(
 
       if (rebuffering === null) {
         if (readyState === 1) {
-          // With a readyState set to 1, we should still be not able to play,
-          // anounce that we're stalled due to an unknown "freezing" status.
+          // With a readyState set to 1, we should still not be able to play:
+          // Return that we're stalled
+          let reason : IStallingSituation;
+          if (observation.seeking) {
+            reason = observation.internalSeeking ? "internal-seek" :
+                                                   "seeking";
+          } else {
+            reason = "not-ready";
+          }
           return { type: "stalled" as const,
-                   value: "freezing" as const };
+                   value: reason };
         }
         return { type: "unstalled" as const,
                  value: null };
       }
 
-      if (tick.seeking) {
-        lastSeekingPosition = tick.position;
+      // We want to separate a stall situation when a seek is due to a seek done
+      // internally by the player to when its due to a regular user seek.
+      const stalledReason = rebuffering.reason === "seeking" &&
+                            observation.internalSeeking ? "internal-seek" as const :
+                                                          rebuffering.reason;
+
+      if (observation.seeking) {
+        lastSeekingPosition = observation.position;
       } else if (lastSeekingPosition !== null) {
         const now = performance.now();
         if (ignoredStallTimeStamp === null) {
           ignoredStallTimeStamp = now;
         }
         if (isSeekingApproximate &&
-            tick.position < lastSeekingPosition &&
+            observation.position < lastSeekingPosition &&
             now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY)
         {
           return { type: "stalled" as const,
-                   value: rebuffering.reason };
+                   value: stalledReason };
         }
         lastSeekingPosition = null;
       }
@@ -275,7 +292,7 @@ export default function StallAvoider(
 
       if (manifest === null) {
         return { type: "stalled" as const,
-                 value: rebuffering.reason };
+                 value: stalledReason };
       }
 
       /** Position at which data is awaited. */
@@ -287,13 +304,13 @@ export default function StallAvoider(
                                                                  stalledPosition);
         if (skippableDiscontinuity !== null) {
           const realSeekTime = skippableDiscontinuity + 0.001;
-          if (realSeekTime <= mediaElement.currentTime) {
+          if (realSeekTime <= playbackObserver.getCurrentTime()) {
             log.info("Init: position to seek already reached, no seeking",
-                     mediaElement.currentTime, realSeekTime);
+                     playbackObserver.getCurrentTime(), realSeekTime);
           } else {
             log.warn("SA: skippable discontinuity found in the stream",
                      position, realSeekTime);
-            setCurrentTime(realSeekTime);
+            playbackObserver.setCurrentTime(realSeekTime);
             return EVENTS.warning(generateDiscontinuityError(stalledPosition,
                                                              realSeekTime));
           }
@@ -312,10 +329,10 @@ export default function StallAvoider(
       const nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
       if (nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
         const seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
-        if (mediaElement.currentTime < seekTo) {
+        if (playbackObserver.getCurrentTime() < seekTo) {
           log.warn("Init: discontinuity encountered inferior to the threshold",
                    freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
-          setCurrentTime(seekTo);
+          playbackObserver.setCurrentTime(seekTo);
           return EVENTS.warning(generateDiscontinuityError(freezePosition, seekTo));
         }
       }
@@ -326,10 +343,10 @@ export default function StallAvoider(
         const period = manifest.periods[i];
         if (period.end !== undefined && period.end <= freezePosition) {
           if (manifest.periods[i + 1].start > freezePosition &&
-              manifest.periods[i + 1].start > mediaElement.currentTime)
+              manifest.periods[i + 1].start > playbackObserver.getCurrentTime())
           {
             const nextPeriod = manifest.periods[i + 1];
-            setCurrentTime(nextPeriod.start);
+            playbackObserver.setCurrentTime(nextPeriod.start);
             return EVENTS.warning(generateDiscontinuityError(freezePosition,
                                                              nextPeriod.start));
 
@@ -339,7 +356,7 @@ export default function StallAvoider(
       }
 
       return { type: "stalled" as const,
-               value: rebuffering.reason };
+               value: stalledReason };
     }));
   return observableMerge(unlock$, stall$);
 }
@@ -418,18 +435,18 @@ function eventContainsDiscontinuity(
  *     store it in Period's chronological order in the Array.
  * @param {Array.<Object>} discontinuitiesStore
  * @param {Object} evt
- * @param {Object} tick
+ * @param {Object} observation
  * @returns {Array.<Object>}
  */
 function updateDiscontinuitiesStore(
   discontinuitiesStore : IDiscontinuityStoredInfo[],
   evt : IDiscontinuityEvent,
-  tick : IInitClockTick
+  observation : IPlaybackObservation
 ) : IDiscontinuityStoredInfo[] {
   // First, perform clean-up of old discontinuities
   while (discontinuitiesStore.length > 0 &&
          discontinuitiesStore[0].period.end !== undefined &&
-         discontinuitiesStore[0].period.end + 10 < tick.position)
+         discontinuitiesStore[0].period.end + 10 < observation.position)
   {
     discontinuitiesStore.shift();
   }

package/src/core/init/stream_events_emitter/stream_events_emitter.ts

@@ -17,26 +17,24 @@
 import {
   combineLatest as observableCombineLatest,
   concat as observableConcat,
-  EMPTY,
-  interval,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
   distinctUntilChanged,
+  EMPTY,
   ignoreElements,
+  interval,
   map,
   mergeMap,
+  Observable,
   pairwise,
   scan,
   startWith,
   switchMap,
   tap,
-} from "rxjs/operators";
+  of as observableOf,
+} from "rxjs";
 import config from "../../../config";
 import Manifest from "../../../manifest";
 import { fromEvent } from "../../../utils/event_emitter";
-import { IInitClockTick } from "../types";
+import { IPlaybackObservation } from "../../api";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
 import {
   INonFiniteStreamEventPayload,
@@ -66,7 +64,7 @@ function isFiniteStreamEvent(
  */
 function streamEventsEmitter(manifest: Manifest,
                              mediaElement: HTMLMediaElement,
-                             clock$: Observable<IInitClockTick>
+                             observation$: Observable<IPlaybackObservation>
 ): Observable<IStreamEvent> {
   const eventsBeingPlayed =
     new WeakMap<IStreamEventPayload|INonFiniteStreamEventPayload, true>();
@@ -79,20 +77,20 @@ function streamEventsEmitter(manifest: Manifest,
   );
 
   /**
-   * Examine playback situation from clock ticks to emit stream events and
+   * Examine playback situation from playback observations to emit stream events and
    * prepare set onExit callbacks if needed.
    * @param {Array.<Object>} scheduledEvents
-   * @param {Object} oldTick
-   * @param {Object} newTick
+   * @param {Object} oldObservation
+   * @param {Object} newObservation
    * @returns {Observable}
    */
   function emitStreamEvents$(
     scheduledEvents: Array<IStreamEventPayload|INonFiniteStreamEventPayload>,
-    oldClockTick: { currentTime: number; isSeeking: boolean },
-    newClockTick: { currentTime: number; isSeeking: boolean }
+    oldObservation: { currentTime: number; isSeeking: boolean },
+    newObservation: { currentTime: number; isSeeking: boolean }
   ): Observable<IStreamEvent> {
-    const { currentTime: previousTime } = oldClockTick;
-    const { isSeeking, currentTime } = newClockTick;
+    const { currentTime: previousTime } = oldObservation;
+    const { isSeeking, currentTime } = newObservation;
     const eventsToSend: IStreamEvent[] = [];
     const eventsToExit: IPublicStreamEvent[] = [];
 
@@ -141,6 +139,11 @@ function streamEventsEmitter(manifest: Manifest,
             evt.onExit();
           }
         }),
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
         ignoreElements()
       ) : EMPTY
     );
@@ -160,16 +163,16 @@ function streamEventsEmitter(manifest: Manifest,
       }
       return observableCombineLatest([
         interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
-        clock$,
+        observation$,
       ]).pipe(
-        map(([_, clockTick]) => {
-          const { seeking } = clockTick;
+        map(([_, observation]) => {
+          const { seeking } = observation;
           return { isSeeking: seeking,
                    currentTime: mediaElement.currentTime };
         }),
         pairwise(),
-        mergeMap(([oldTick, newTick]) =>
-          emitStreamEvents$(lastScheduledEvents, oldTick, newTick))
+        mergeMap(([oldObservation, newObservation]) =>
+          emitStreamEvents$(lastScheduledEvents, oldObservation, newObservation))
       );
     })
   );

package/src/core/init/throw_on_media_error.ts

@@ -16,9 +16,9 @@
 
 import {
   fromEvent as observableFromEvent,
+  mergeMap,
   Observable,
 } from "rxjs";
-import { mergeMap } from "rxjs/operators";
 import { MediaError } from "../../errors";
 
 /**

package/src/core/init/types.ts

@@ -20,11 +20,6 @@ import Manifest, {
   Period,
   Representation,
 } from "../../manifest";
-import {
-  IClockMediaEventType,
-  IFreezingStatus,
-  IRebufferingStatus,
-} from "../api";
 import {
   IAttachedMediaKeysEvent,
   IBlacklistProtectionDataEvent,
@@ -60,25 +55,6 @@ import {
   IStreamEventSkipEvent,
 } from "./stream_events_emitter";
 
-/** Object awaited by the `Init` on each clock tick. */
-export interface IInitClockTick { position : number;
-                                  getCurrentTime : () => number;
-                                  buffered : TimeRanges;
-                                  duration : number;
-                                  bufferGap : number;
-                                  event : IClockMediaEventType;
-                                  playbackRate : number;
-                                  currentRange : { start : number;
-                                                   end : number; } |
-                                                 null;
-                                  readyState : number;
-                                  paused : boolean;
-                                  rebuffering : IRebufferingStatus |
-                                                null;
-                                  freezing : IFreezingStatus |
-                                             null;
-                                  seeking : boolean; }
-
 /** Event sent after the Manifest has been loaded and parsed for the first time. */
 export interface IManifestReadyEvent {
   type : "manifestReady";

package/src/core/init/update_playback_rate.ts

@@ -16,18 +16,17 @@
 
 import {
   defer as observableDefer,
-  Observable,
-  of as observableOf,
-} from "rxjs";
-import {
   distinctUntilChanged,
   map,
+  Observable,
+  of as observableOf,
   startWith,
   switchMap,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import log from "../../log";
-import { IInitClockTick } from "./types";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IPlaybackObservation } from "../api";
 
 export interface IPlaybackRateOptions { pauseWhenRebuffering? : boolean }
 
@@ -37,18 +36,18 @@ export interface IPlaybackRateOptions { pauseWhenRebuffering? : boolean }
  * rebuffering and restore the speed once it appears to exit rebuffering status.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} speed$ - emit speed set by the user
- * @param {Observable} clock$ - Current playback conditions
+ * @param {Observable} speed - last speed set by the user
+ * @param {Observable} observation$ - Current playback conditions
  * @returns {Observable}
  */
 export default function updatePlaybackRate(
   mediaElement : HTMLMediaElement,
-  speed$ : Observable<number>,
-  clock$ : Observable<IInitClockTick>
+  speed : IReadOnlySharedReference<number>,
+  observation$ : Observable<IPlaybackObservation>
 ) : Observable<number> {
-  const forcePause$ = clock$
+  const forcePause$ = observation$
     .pipe(
-      map((timing) => timing.rebuffering !== null),
+      map((observation) => observation.rebuffering !== null),
       startWith(false),
       distinctUntilChanged()
     );
@@ -62,10 +61,10 @@ export default function updatePlaybackRate(
           return observableOf(0);
         });
       }
-      return speed$
-        .pipe(tap((speed) => {
-          log.info("Init: Resume playback speed", speed);
-          mediaElement.playbackRate = speed;
+      return speed.asObservable()
+        .pipe(tap((lastSpeed) => {
+          log.info("Init: Resume playback speed", lastSpeed);
+          mediaElement.playbackRate = lastSpeed;
         }));
     }));
 }

package/src/core/segment_buffers/README.md

@@ -134,8 +134,8 @@ periodically perform "garbage collection" manually on a given
 
 It is based on the following building bricks:
 
-  - A clock, which is an observable emitting the current time (in seconds) when
-    the garbage collection task should be performed
+  - An observable emitting the current time (in seconds) when the garbage
+    collection task should be performed
 
   - The `SegmentBuffer` on which the garbage collection task should run
 
@@ -145,7 +145,7 @@ It is based on the following building bricks:
   - The maximum time margin authorized for the buffer ahead of the current
     position
 
-Basically, each times the given clock ticks, the BufferGarbageCollector will
+Basically, each times the given Observable emits, the BufferGarbageCollector will
 ensure that the volume of data before and ahead of the current position does not
 grow into a larger value than what is configured.
 

package/src/core/segment_buffers/garbage_collector.ts

@@ -16,15 +16,13 @@
 
 import {
   combineLatest as observableCombineLatest,
+  concatAll,
   EMPTY,
   from as observableFrom,
-  Observable,
-} from "rxjs";
-import {
-  concatAll,
   ignoreElements,
   mergeMap,
-} from "rxjs/operators";
+  Observable,
+} from "rxjs";
 import log from "../../log";
 import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
 import { SegmentBuffer } from "./implementations";
@@ -33,7 +31,7 @@ export interface IGarbageCollectorArgument {
   /** SegmentBuffer implementation */
   segmentBuffer : SegmentBuffer;
   /** Emit current position in seconds regularly */
-  clock$ : Observable<number>;
+  currentTime$ : Observable<number>;
   /** Maximum time to keep behind current time position, in seconds */
   maxBufferBehind$ : Observable<number>;
   /** Minimum time to keep behind current time position, in seconds */
@@ -42,19 +40,19 @@ export interface IGarbageCollectorArgument {
 
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * at each clock tick and each times the maxBufferBehind/maxBufferAhead values
- * change.
+ * each time `currentTime$` emits and each times the
+ * maxBufferBehind/maxBufferAhead values change.
  *
  * @param {Object} opt
  * @returns {Observable}
  */
 export default function BufferGarbageCollector({
   segmentBuffer,
-  clock$,
+  currentTime$,
   maxBufferBehind$,
   maxBufferAhead$,
 } : IGarbageCollectorArgument) : Observable<never> {
-  return observableCombineLatest([clock$, maxBufferBehind$, maxBufferAhead$]).pipe(
+  return observableCombineLatest([currentTime$, maxBufferBehind$, maxBufferAhead$]).pipe(
     mergeMap(([currentTime, maxBufferBehind, maxBufferAhead]) => {
       return clearBuffer(segmentBuffer,
                          currentTime,
@@ -156,7 +154,13 @@ function clearBuffer(
       log.debug("GC: cleaning range from SegmentBuffer", range);
       return segmentBuffer.removeBuffer(range.start, range.end);
     })
-  ).pipe(concatAll(), ignoreElements());
+  ).pipe(concatAll(),
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+         ignoreElements());
 
   return clean$;
 }

package/src/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.ts

@@ -20,17 +20,16 @@ import {
   Observable,
   Observer,
   Subject,
-} from "rxjs";
-import {
   takeUntil,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import {
   ICompatSourceBuffer,
   tryToChangeSourceBufferType,
 } from "../../../../compat";
 import config from "../../../../config";
 import log from "../../../../log";
+import { getLoggableSegmentId } from "../../../../manifest";
 import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
 import { toUint8Array } from "../../../../utils/byte_parsing";
@@ -224,7 +223,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     assertPushedDataIsBufferSource(infos);
     log.debug("AVSB: receiving order to push data to the SourceBuffer",
               this.bufferType,
-              infos);
+              getLoggableSegmentId(infos.inventoryInfos));
     return this._addToQueue({ type: SegmentBufferOperation.Push,
                               value: infos });
   }
@@ -256,7 +255,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
   public endOfSegment(infos : IEndOfSegmentInfos) : Observable<void> {
     log.debug("AVSB: receiving order for validating end of segment",
               this.bufferType,
-              infos.segment);
+              getLoggableSegmentId(infos));
     return this._addToQueue({ type: SegmentBufferOperation.EndOfSegment,
                               value: infos });
   }
@@ -449,7 +448,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
       switch (this._pendingTask.type) {
         case SegmentBufferOperation.EndOfSegment:
           // nothing to do, we will just acknowledge the segment.
-          log.debug("AVSB: Acknowledging complete segment", this._pendingTask.value);
+          log.debug("AVSB: Acknowledging complete segment",
+                    getLoggableSegmentId(this._pendingTask.value));
           this._flush();
           return;
 
@@ -459,6 +459,9 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
             this._flush();
             return;
           }
+          log.debug("AVSB: pushing segment",
+                    this.bufferType,
+                    getLoggableSegmentId(this._pendingTask.inventoryData));
           this._sourceBuffer.appendBuffer(segmentData);
           break;
 
@@ -593,7 +596,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
 function assertPushedDataIsBufferSource(
   pushedData : IPushChunkInfos<unknown>
 ) : asserts pushedData is IPushChunkInfos<BufferSource> {
-  if (!__DEV__) {
+  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
   const { chunk, initSegment } = pushedData.data;