rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/src/core/init/utils/initial_seek_and_play.ts

@@ -19,8 +19,7 @@ import { READY_STATES } from "../../../compat/browser_compatibility_types";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
 import { IPlayerError } from "../../../public_types";
-import {
-  createSharedReference,
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../../utils/reference";
 import { CancellationError, CancellationSignal } from "../../../utils/task_canceller";
@@ -82,19 +81,20 @@ export default function performInitialSeekAndPlay(
     rejectAutoPlay = rej;
   });
 
-  const initialSeekPerformed = createSharedReference(false, cancelSignal);
-  const initialPlayPerformed = createSharedReference(false, cancelSignal);
+  const initialSeekPerformed = new SharedReference(false, cancelSignal);
+  const initialPlayPerformed = new SharedReference(false, cancelSignal);
 
   mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-  if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
-    onLoadedMetadata();
-  }
 
   const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
     mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
     rejectAutoPlay(err);
   });
 
+  if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
+    onLoadedMetadata();
+  }
+
   return { autoPlayResult, initialPlayPerformed, initialSeekPerformed };
 
   function onLoadedMetadata() {

package/src/core/init/utils/initialize_content_decryption.ts

@@ -1,18 +1,17 @@
-import { hasEMEAPIs } from "../../../compat";
 import { EncryptedMediaError } from "../../../errors";
+import features from "../../../features";
 import log from "../../../log";
 import {
   IKeySystemOption,
   IPlayerError,
 } from "../../../public_types";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
-  ISharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, {
   CancellationSignal,
 } from "../../../utils/task_canceller";
-import ContentDecryptor, {
+import {
   ContentDecryptorState,
   IContentProtection,
 } from "../../decrypt";
@@ -49,53 +48,31 @@ export default function initializeContentDecryption(
   cancelSignal : CancellationSignal
 ) : IReadOnlySharedReference<IDrmInitializationStatus> {
   if (keySystems.length === 0) {
-    protectionRef.onUpdate((data, stopListening) => {
-      if (data === null) { // initial value
-        return;
-      }
-      stopListening();
-      log.error("Init: Encrypted event but EME feature not activated");
-      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
-                                          "EME feature not activated.");
-      callbacks.onError(err);
-    }, { clearSignal: cancelSignal });
-    const ref = createSharedReference({
-      initializationState: { type: "initialized" as const, value: null },
-      drmSystemId: undefined });
-    ref.finish(); // We know that no new value will be triggered
-    return ref;
-  } else if (!hasEMEAPIs()) {
-    protectionRef.onUpdate((data, stopListening) => {
-      if (data === null) { // initial value
-        return;
-      }
-      stopListening();
-      log.error("Init: Encrypted event but no EME API available");
-      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
-                                          "Encryption APIs not found.");
-      callbacks.onError(err);
-    }, { clearSignal: cancelSignal });
-    const ref = createSharedReference({
-      initializationState: { type: "initialized" as const, value: null },
-      drmSystemId: undefined });
-    ref.finish(); // We know that no new value will be triggered
-    return ref;
+    return createEmeDisabledReference("No `keySystems` option given.");
+  } else if (features.decrypt === null) {
+    return createEmeDisabledReference("EME feature not activated.");
   }
 
   const decryptorCanceller = new TaskCanceller();
   decryptorCanceller.linkToSignal(cancelSignal);
-  const drmStatusRef = createSharedReference<IDrmInitializationStatus>({
+  const drmStatusRef = new SharedReference<IDrmInitializationStatus>({
     initializationState: { type: "uninitialized", value: null },
     drmSystemId: undefined,
   }, cancelSignal);
 
+  const ContentDecryptor = features.decrypt;
+
+  if (!ContentDecryptor.hasEmeApis()) {
+    return createEmeDisabledReference("EME API not available on the current page.");
+  }
+
   log.debug("Init: Creating ContentDecryptor");
   const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
 
   contentDecryptor.addEventListener("stateChange", (state) => {
     if (state === ContentDecryptorState.WaitingForAttachment) {
 
-      const isMediaLinked = createSharedReference(false);
+      const isMediaLinked = new SharedReference(false);
       isMediaLinked.onUpdate((isAttached, stopListening) => {
         if (isAttached) {
           stopListening();
@@ -136,6 +113,22 @@ export default function initializeContentDecryption(
   });
 
   return drmStatusRef;
+
+  function createEmeDisabledReference(errMsg : string) {
+    protectionRef.onUpdate((data, stopListening) => {
+      if (data === null) { // initial value
+        return;
+      }
+      stopListening();
+      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+      callbacks.onError(err);
+    }, { clearSignal: cancelSignal });
+    const ref = new SharedReference({
+      initializationState: { type: "initialized" as const, value: null },
+      drmSystemId: undefined });
+    ref.finish(); // We know that no new value will be triggered
+    return ref;
+  }
 }
 
 /** Status of content decryption initialization. */
@@ -162,7 +155,7 @@ type IDecryptionInitializationState =
    * The `MediaSource` or media url has to be linked to the `HTMLMediaElement`
    * before continuing.
    * Once it has been linked with success (e.g. the `MediaSource` has "opened"),
-   * the `isMediaLinked` `ISharedReference` should be set to `true`.
+   * the `isMediaLinked` `SharedReference` should be set to `true`.
    *
    * In the `MediaSource` case, you should wait until the `"initialized"`
    * state before pushing segment.
@@ -171,7 +164,7 @@ type IDecryptionInitializationState =
    * skipped to directly `"initialized"` instead.
    */
   { type: "awaiting-media-link";
-    value: { isMediaLinked : ISharedReference<boolean> }; } |
+    value: { isMediaLinked : SharedReference<boolean> }; } |
   /**
    * The `MediaSource` or media url can be linked AND segments can be pushed to
    * the `HTMLMediaElement` on which decryption capabilities were wanted.

package/src/core/init/utils/media_source_duration_updater.ts

@@ -22,7 +22,7 @@ import {
 /* eslint-disable-next-line max-len */
 import hasIssuesWithHighMediaSourceDuration from "../../../compat/has_issues_with_high_media_source_duration";
 import log from "../../../log";
-import createSharedReference, {
+import SharedReference, {
   IReadOnlySharedReference,
 } from "../../../utils/reference";
 import TaskCanceller, {
@@ -195,8 +195,9 @@ function setMediaSourceDuration(
       log.info("Init: Updating duration", newDuration);
       mediaSource.duration = newDuration;
       if (mediaSource.readyState === "open" && !isFinite(newDuration)) {
-        mediaSource.setLiveSeekableRange(0,
-                                         getMaximumLiveSeekablePosition(duration));
+        const maxSeekable = getMaximumLiveSeekablePosition(duration);
+        log.info("Init: calling `mediaSource.setLiveSeekableRange`", maxSeekable);
+        mediaSource.setLiveSeekableRange(0, maxSeekable);
       }
     } catch (err) {
       log.warn("Duration Updater: Can't update duration on the MediaSource.",
@@ -234,7 +235,7 @@ const enum MediaSourceDurationUpdateStatus {
 }
 
 /**
- * Returns an `ISharedReference` wrapping a boolean that tells if all the
+ * Returns a `SharedReference` wrapping a boolean that tells if all the
  * SourceBuffers ended all pending updates.
  * @param {SourceBufferList} sourceBuffers
  * @param {Object} cancelSignal
@@ -245,12 +246,12 @@ function createSourceBuffersUpdatingReference(
   cancelSignal : CancellationSignal
 ) : IReadOnlySharedReference<boolean> {
   if (sourceBuffers.length === 0) {
-    const notOpenedRef = createSharedReference(false);
+    const notOpenedRef = new SharedReference(false);
     notOpenedRef.finish();
     return notOpenedRef;
   }
 
-  const areUpdatingRef = createSharedReference(false, cancelSignal);
+  const areUpdatingRef = new SharedReference(false, cancelSignal);
   reCheck();
 
   for (let i = 0; i < sourceBuffers.length; i++) {
@@ -278,7 +279,7 @@ function createSourceBuffersUpdatingReference(
 }
 
 /**
- * Returns an `ISharedReference` wrapping a boolean that tells if the media
+ * Returns a `SharedReference` wrapping a boolean that tells if the media
  * source is opened or not.
  * @param {MediaSource} mediaSource
  * @param {Object} cancelSignal
@@ -288,15 +289,18 @@ function createMediaSourceOpenReference(
   mediaSource : MediaSource,
   cancelSignal : CancellationSignal
 ): IReadOnlySharedReference<boolean> {
-  const isMediaSourceOpen = createSharedReference(mediaSource.readyState === "open",
-                                                  cancelSignal);
+  const isMediaSourceOpen = new SharedReference(mediaSource.readyState === "open",
+                                                cancelSignal);
   onSourceOpen(mediaSource, () => {
+    log.debug("Init: Reacting to MediaSource open in duration updater");
     isMediaSourceOpen.setValueIfChanged(true);
   }, cancelSignal);
   onSourceEnded(mediaSource, () => {
+    log.debug("Init: Reacting to MediaSource ended in duration updater");
     isMediaSourceOpen.setValueIfChanged(false);
   }, cancelSignal);
   onSourceClose(mediaSource, () => {
+    log.debug("Init: Reacting to MediaSource close in duration updater");
     isMediaSourceOpen.setValueIfChanged(false);
   }, cancelSignal);
   return isMediaSourceOpen;

package/src/core/init/utils/rebuffering_controller.ts

@@ -23,7 +23,8 @@ import Manifest, {
 } from "../../../manifest";
 import { IPlayerError } from "../../../public_types";
 import EventEmitter from "../../../utils/event_emitter";
-import { getNextRangeGap } from "../../../utils/ranges";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
+import { getNextBufferedTimeRangeGap } from "../../../utils/ranges";
 import { IReadOnlySharedReference } from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
 import {
@@ -67,9 +68,9 @@ export default class RebufferingController
   private _canceller : TaskCanceller;
 
   /**
-   * If set to something else than `null`, this is the DOMHighResTimestamp as
-   * outputed by `performance.now()` when playback begin to seem to not start
-   * despite having decipherable data in the buffer(s).
+   * If set to something else than `null`, this is the monotonically-raising
+   * timestamp when playback begin to seem to not start despite having
+   * decipherable data in the buffer(s).
    *
    * If enough time in that condition is spent, special considerations are
    * taken at which point `_currentFreezeTimestamp` is reset to `null`.
@@ -162,7 +163,7 @@ export default class RebufferingController
         lastSeekingPosition !== null && observation.position < lastSeekingPosition)
       {
         log.debug("Init: the device appeared to have seeked back by itself.");
-        const now = performance.now();
+        const now = getMonotonicTimeStamp();
         ignoredStallTimeStamp = now;
       }
 
@@ -175,7 +176,7 @@ export default class RebufferingController
       }
 
       if (freezing !== null) {
-        const now = performance.now();
+        const now = getMonotonicTimeStamp();
 
         const referenceTimestamp = prevFreezingState === null ?
           freezing.timestamp :
@@ -228,7 +229,7 @@ export default class RebufferingController
         rebuffering.reason;
 
       if (ignoredStallTimeStamp !== null) {
-        const now = performance.now();
+        const now = getMonotonicTimeStamp();
         if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
           playbackRateUpdater.stopRebuffering();
           log.debug("Init: letting the device get out of a stall by itself");
@@ -283,7 +284,7 @@ export default class RebufferingController
       // calculate a stalled state. This is useful for some
       // implementation that might drop an injected segment, or in
       // case of small discontinuity in the content.
-      const nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
+      const nextBufferRangeGap = getNextBufferedTimeRangeGap(buffered, freezePosition);
       if (
         this._speed.getValue() > 0 &&
         nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD
@@ -402,6 +403,8 @@ export default class RebufferingController
   private _checkDecipherabilityFreeze(
     observation : IPlaybackObservation
   ): boolean {
+    // XXX TODO allow this in in-worker configuration
+
     const { readyState,
             rebuffering,
             freezing } = observation;
@@ -418,7 +421,7 @@ export default class RebufferingController
       return false;
     }
 
-    const now = performance.now();
+    const now = getMonotonicTimeStamp();
     if (this._currentFreezeTimestamp === null) {
       this._currentFreezeTimestamp = now;
     }
@@ -429,7 +432,7 @@ export default class RebufferingController
 
     if (
       (rebufferingForTooLong || frozenForTooLong) &&
-      performance.now() - this._currentFreezeTimestamp > 4000
+      getMonotonicTimeStamp() - this._currentFreezeTimestamp > 4000
     ) {
       const statusAudio = this._segmentBuffersStore.getStatus("audio");
       const statusVideo = this._segmentBuffersStore.getStatus("video");

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

@@ -45,21 +45,24 @@ function refreshScheduledEventsList(
         }
       }
 
+      const element = data.value.element;
+      const actualData = { type: data.type,
+                           value: { ...data.value, element } };
       if (end === undefined) {
         const newScheduledEvent = { start,
                                     id,
-                                    data,
+                                    data: actualData,
                                     publicEvent: { start,
-                                                   data } };
+                                                   data: actualData } };
         scheduledEvents.push(newScheduledEvent);
       } else {
         const newScheduledEvent = { start,
                                     end,
                                     id,
-                                    data,
+                                    data: actualData,
                                     publicEvent: { start,
                                                    end,
-                                                   data } };
+                                                   data: actualData } };
         scheduledEvents.push(newScheduledEvent);
       }
 

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

@@ -16,7 +16,8 @@
 
 import config from "../../../../config";
 import Manifest from "../../../../manifest";
-import createSharedReference from "../../../../utils/reference";
+import EventEmitter from "../../../../utils/event_emitter";
+import SharedReference from "../../../../utils/reference";
 import TaskCanceller, { CancellationSignal } from "../../../../utils/task_canceller";
 import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../api";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
@@ -27,79 +28,118 @@ import {
   IStreamEventPayload,
 } from "./types";
 
+interface IStreamEventsEmitterEvent {
+  event: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
+  eventSkip: IPublicStreamEvent | IPublicNonFiniteStreamEvent;
+}
+
 /**
  * Get events from manifest and emit each time an event has to be emitted
- * @param {Object} manifest
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {Function} onEvent
- * @param {Function} onEventSkip
- * @param {Object} cancelSignal
- * @returns {Object}
  */
-export default function streamEventsEmitter(
-  manifest : Manifest,
-  mediaElement : HTMLMediaElement,
-  playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>,
-  onEvent : (evt : IPublicStreamEvent | IPublicNonFiniteStreamEvent) => void,
-  onEventSkip : (evt : IPublicStreamEvent | IPublicNonFiniteStreamEvent) => void,
-  cancelSignal : CancellationSignal
-) : void {
-  const eventsBeingPlayed =
-    new WeakMap<IStreamEventPayload|INonFiniteStreamEventPayload, true>();
-  const scheduledEventsRef = createSharedReference(refreshScheduledEventsList([],
-                                                                              manifest),
-                                                   cancelSignal);
-  manifest.addEventListener("manifestUpdate", () => {
-    const prev = scheduledEventsRef.getValue();
-    scheduledEventsRef.setValue(refreshScheduledEventsList(prev, manifest));
-  }, cancelSignal);
-
-  let isPollingEvents = false;
-  let cancelCurrentPolling = new TaskCanceller();
-  cancelCurrentPolling.linkToSignal(cancelSignal);
-
-  scheduledEventsRef.onUpdate(({ length: scheduledEventsLength }) => {
-    if (scheduledEventsLength === 0) {
-      if (isPollingEvents) {
-        cancelCurrentPolling.cancel();
-        cancelCurrentPolling = new TaskCanceller();
-        cancelCurrentPolling.linkToSignal(cancelSignal);
-        isPollingEvents = false;
-      }
-      return;
-    } else if (isPollingEvents) {
+export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitterEvent> {
+  private _manifest : Manifest;
+  private _mediaElement : HTMLMediaElement;
+  private _playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>;
+  private _scheduledEventsRef : SharedReference<
+    Array<IStreamEventPayload | INonFiniteStreamEventPayload>
+  >;
+  private _eventsBeingPlayed: WeakMap<
+    IStreamEventPayload|INonFiniteStreamEventPayload,
+    true
+  >;
+  private _canceller : TaskCanceller | null;
+
+  /**
+   * @param {Object} manifest
+   * @param {HTMLMediaElement} mediaElement
+   * @param {Object} playbackObserver
+   */
+  constructor(
+    manifest : Manifest,
+    mediaElement : HTMLMediaElement,
+    playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>
+  ) {
+    super();
+    this._manifest = manifest;
+    this._mediaElement = mediaElement;
+    this._playbackObserver = playbackObserver;
+    this._canceller = null;
+    this._scheduledEventsRef = new SharedReference<
+      Array<IStreamEventPayload|INonFiniteStreamEventPayload>
+    >([]);
+    this._eventsBeingPlayed =
+      new WeakMap<IStreamEventPayload|INonFiniteStreamEventPayload, true>();
+  }
+
+  public start(): void {
+    if (this._canceller !== null) {
       return;
     }
-    isPollingEvents = true;
-    let oldObservation = constructObservation();
-
-    const { STREAM_EVENT_EMITTER_POLL_INTERVAL } = config.getCurrent();
-    const intervalId = setInterval(checkStreamEvents,
-                                   STREAM_EVENT_EMITTER_POLL_INTERVAL);
-    playbackObserver.listen(checkStreamEvents,
-                            { includeLastObservation: false,
-                              clearSignal: cancelCurrentPolling.signal });
-
-    cancelCurrentPolling.signal.register(() => {
-      clearInterval(intervalId);
-    });
-
-    function checkStreamEvents() {
-      const newObservation = constructObservation();
-      emitStreamEvents(scheduledEventsRef.getValue(),
-                       oldObservation,
-                       newObservation,
-                       cancelCurrentPolling.signal);
-      oldObservation = newObservation;
-    }
+    this._canceller = new TaskCanceller();
+
+    const cancelSignal = this._canceller.signal;
+    const playbackObserver = this._playbackObserver;
+    const mediaElement = this._mediaElement;
+
+
+    let isPollingEvents = false;
+    let cancelCurrentPolling = new TaskCanceller();
+    cancelCurrentPolling.linkToSignal(cancelSignal);
+
+    this._manifest.addEventListener("manifestUpdate", () => {
+      const prev = this._scheduledEventsRef.getValue();
+      this._scheduledEventsRef.setValue(refreshScheduledEventsList(prev, this._manifest));
+    }, this._canceller.signal);
+    this._scheduledEventsRef.setValue(refreshScheduledEventsList([], this._manifest));
+
+    this._scheduledEventsRef.onUpdate(({ length: scheduledEventsLength }) => {
+      if (scheduledEventsLength === 0) {
+        if (isPollingEvents) {
+          cancelCurrentPolling.cancel();
+          cancelCurrentPolling = new TaskCanceller();
+          cancelCurrentPolling.linkToSignal(cancelSignal);
+          isPollingEvents = false;
+        }
+        return;
+      } else if (isPollingEvents) {
+        return;
+      }
+      isPollingEvents = true;
+      let oldObservation = constructObservation();
+      const checkStreamEvents = () => {
+        const newObservation = constructObservation();
+        this._emitStreamEvents(this._scheduledEventsRef.getValue(),
+                               oldObservation,
+                               newObservation,
+                               cancelCurrentPolling.signal);
+        oldObservation = newObservation;
+      };
+
+      const { STREAM_EVENT_EMITTER_POLL_INTERVAL } = config.getCurrent();
+      const intervalId = setInterval(checkStreamEvents,
+                                     STREAM_EVENT_EMITTER_POLL_INTERVAL);
+      playbackObserver.listen(checkStreamEvents,
+                              { includeLastObservation: false,
+                                clearSignal: cancelCurrentPolling.signal });
+
+      cancelCurrentPolling.signal.register(() => {
+        clearInterval(intervalId);
+      });
+
+      function constructObservation() {
+        const isSeeking = playbackObserver.getReference().getValue().seeking;
+        return { currentTime: mediaElement.currentTime,
+                 isSeeking };
+      }
+    }, { emitCurrentValue: true, clearSignal: cancelSignal });
+  }
 
-    function constructObservation() {
-      const isSeeking = playbackObserver.getReference().getValue().seeking;
-      return { currentTime: mediaElement.currentTime,
-               isSeeking };
+  public stop(): void {
+    if (this._canceller !== null) {
+      this._canceller.cancel();
+      this._canceller = null;
     }
-  }, { emitCurrentValue: true, clearSignal: cancelSignal });
+  }
 
   /**
    * Examine playback situation from playback observations to emit stream events and
@@ -109,7 +149,7 @@ export default function streamEventsEmitter(
    * @param {Object} newObservation
    * @param {Object} stopSignal
    */
-  function emitStreamEvents(
+  private _emitStreamEvents(
     scheduledEvents : Array<IStreamEventPayload|INonFiniteStreamEventPayload>,
     oldObservation : { currentTime: number; isSeeking: boolean },
     newObservation : { currentTime: number; isSeeking: boolean },
@@ -125,7 +165,7 @@ export default function streamEventsEmitter(
       const start = event.start;
       const end = isFiniteStreamEvent(event) ? event.end :
                                                undefined;
-      const isBeingPlayed = eventsBeingPlayed.has(event);
+      const isBeingPlayed = this._eventsBeingPlayed.has(event);
       if (isBeingPlayed) {
         if (start > currentTime ||
             (end !== undefined && currentTime >= end)
@@ -133,14 +173,14 @@ export default function streamEventsEmitter(
           if (isFiniteStreamEvent(event)) {
             eventsToExit.push(event.publicEvent);
           }
-          eventsBeingPlayed.delete(event);
+          this._eventsBeingPlayed.delete(event);
         }
       } else if (start <= currentTime &&
                  end !== undefined &&
                  currentTime < end) {
         eventsToSend.push({ type: "stream-event",
                             value: event.publicEvent });
-        eventsBeingPlayed.set(event, true);
+        this._eventsBeingPlayed.set(event, true);
       } else if (previousTime < start &&
                  currentTime >= (end ?? start)) {
         if (isSeeking) {
@@ -159,9 +199,9 @@ export default function streamEventsEmitter(
     if (eventsToSend.length > 0) {
       for (const event of eventsToSend) {
         if (event.type === "stream-event") {
-          onEvent(event.value);
+          this.trigger("event", event.value);
         } else {
-          onEventSkip(event.value);
+          this.trigger("eventSkip", event.value);
         }
         if (stopSignal.isCancelled()) {
           return;

package/src/core/segment_buffers/garbage_collector.ts

@@ -15,7 +15,7 @@
  */
 
 import log from "../../log";
-import { getInnerAndOuterTimeRanges } from "../../utils/ranges";
+import { getInnerAndOuterRangesFromBufferedTimeRanges } from "../../utils/ranges";
 import { IReadOnlySharedReference } from "../../utils/reference";
 import { CancellationSignal } from "../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../api";
@@ -105,8 +105,8 @@ async function clearBuffer(
   const cleanedupRanges : Array<{ start : number;
                                   end: number; }> = [];
   const { innerRange, outerRanges } =
-    getInnerAndOuterTimeRanges(segmentBuffer.getBufferedRanges(),
-                               position);
+    getInnerAndOuterRangesFromBufferedTimeRanges(segmentBuffer.getBufferedRanges(),
+                                                 position);
 
   const collectBufferBehind = () => {
     if (!isFinite(maxBufferBehind)) {

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

@@ -169,6 +169,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     mediaSource : MediaSource
   ) {
     super();
+    log.info("AVSB: calling `mediaSource.addSourceBuffer`", codec);
     const sourceBuffer = mediaSource.addSourceBuffer(codec);
 
     this._canceller = new TaskCanceller();
@@ -355,6 +356,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
 
     if (this._mediaSource.readyState === "open") {
       try {
+        log.debug("AVSB: Calling `abort` on the SourceBuffer");
         this._sourceBuffer.abort();
       } catch (e) {
         log.warn(`AVSB: Failed to abort a ${this.bufferType} SourceBuffer:`,
@@ -558,20 +560,26 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
 
     if (appendWindow[0] === undefined) {
       if (this._sourceBuffer.appendWindowStart > 0) {
+        log.debug("AVSB: re-setting `appendWindowStart` to `0`");
         this._sourceBuffer.appendWindowStart = 0;
       }
     } else if (appendWindow[0] !== this._sourceBuffer.appendWindowStart) {
       if (appendWindow[0] >= this._sourceBuffer.appendWindowEnd) {
-        this._sourceBuffer.appendWindowEnd = appendWindow[0] + 1;
+        const newTmpEnd = appendWindow[0] + 1;
+        log.debug("AVSB: pre-updating `appendWindowEnd`", newTmpEnd);
+        this._sourceBuffer.appendWindowEnd = newTmpEnd;
       }
+      log.debug("AVSB: setting `appendWindowStart`", appendWindow[0]);
       this._sourceBuffer.appendWindowStart = appendWindow[0];
     }
 
     if (appendWindow[1] === undefined) {
       if (this._sourceBuffer.appendWindowEnd !== Infinity) {
+        log.debug("AVSB: re-setting `appendWindowEnd` to `Infinity`");
         this._sourceBuffer.appendWindowEnd = Infinity;
       }
     } else if (appendWindow[1] !== this._sourceBuffer.appendWindowEnd) {
+      log.debug("AVSB: setting `appendWindowEnd`", appendWindow[1]);
       this._sourceBuffer.appendWindowEnd = appendWindow[1];
     }
 
@@ -618,7 +626,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
 function assertDataIsBufferSource(
   data : unknown
 ) : asserts data is BufferSource {
-  if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.PRODUCTION as number) {
+  if (__ENVIRONMENT__.CURRENT_ENV as number === __ENVIRONMENT__.PRODUCTION as number) {
     return;
   }
   if (