rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

package/src/core/init/initialize_media_source.ts

@@ -16,15 +16,12 @@
 
 import {
   combineLatest as observableCombineLatest,
-  EMPTY,
-  exhaustMap,
   filter,
   finalize,
   ignoreElements,
   map,
   merge as observableMerge,
   mergeMap,
-  mergeScan,
   Observable,
   of as observableOf,
   share,
@@ -34,7 +31,6 @@ import {
   switchMap,
   take,
   takeUntil,
-  tap,
 } from "rxjs";
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
@@ -51,9 +47,8 @@ import { PlaybackObserver } from "../api";
 import {
   getCurrentKeySystem,
   IContentProtection,
-  IEMEManagerEvent,
   IKeySystemOption,
-} from "../eme";
+} from "../decrypt";
 import {
   IManifestFetcherParsedResult,
   IManifestFetcherWarningEvent,
@@ -61,14 +56,16 @@ import {
   SegmentFetcherCreator,
 } from "../fetchers";
 import { ITextTrackSegmentBufferOptions } from "../segment_buffers";
-import createEMEManager, {
-  IEMEDisabledEvent,
-} from "./create_eme_manager";
+import { IAudioTrackSwitchingMode } from "../stream";
 import openMediaSource from "./create_media_source";
 import EVENTS from "./events_generators";
 import getInitialTime, {
   IInitialTimeOptions,
 } from "./get_initial_time";
+import linkDrmAndContent, {
+  IDecryptionDisabledEvent,
+  IDecryptionReadyEvent,
+} from "./link_drm_and_content";
 import createMediaSourceLoader from "./load_on_media_source";
 import manifestUpdateScheduler, {
   IManifestRefreshSchedulerEvent,
@@ -79,7 +76,11 @@ import {
   IMediaSourceLoaderEvent,
 } from "./types";
 
-const { OUT_OF_SYNC_MANIFEST_REFRESH_DELAY } = config;
+// 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 @typescript-eslint/no-unsafe-argument */
 
 /** Arguments to give to the `InitializeOnMediaSource` function. */
 export interface IInitializeArguments {
@@ -91,6 +92,8 @@ export interface IInitializeArguments {
   bufferOptions : {
     /** Buffer "goal" at which we stop downloading new segments. */
     wantedBufferAhead : IReadOnlySharedReference<number>;
+    /** Buffer maximum size in kiloBytes at which we stop downloading */
+    maxVideoBufferSize :  IReadOnlySharedReference<number>;
     /** Max buffer size after the current position, in seconds (we GC further up). */
     maxBufferAhead : IReadOnlySharedReference<number>;
     /** Max buffer size before the current position, in seconds (we GC further down). */
@@ -103,7 +106,7 @@ export interface IInitializeArguments {
      */
     enableFastSwitching : boolean;
     /** Strategy when switching of audio track. */
-    audioTrackSwitchingMode : "seamless" | "direct";
+    audioTrackSwitchingMode : IAudioTrackSwitchingMode;
     /** Behavior when a new video and/or audio codec is encountered. */
     onCodecSwitch : "continue" | "reload";
   };
@@ -144,7 +147,7 @@ export interface IInitializeArguments {
  *
  *   - download the content's Manifest and handle its refresh logic
  *
- *   - Perform EME management if needed
+ *   - Perform decryption if needed
  *
  *   - ask for the choice of the wanted Adaptation through events (e.g. to
  *     choose a language)
@@ -193,26 +196,28 @@ export default function InitializeOnMediaSource(
     shareReplay({ refCount: true })
   );
 
-  /** Send content protection data to the `EMEManager`. */
+  /** Send content protection initialization data. */
   const protectedSegments$ = new Subject<IContentProtection>();
 
-  /** Create `EMEManager`, an observable which will handle content DRM. */
-  const emeManager$ = createEMEManager(mediaElement,
+  /** Initialize decryption capabilities and MediaSource. */
+  const drmEvents$ = linkDrmAndContent(mediaElement,
                                        keySystems,
-                                       protectedSegments$).pipe(
-    // Because multiple Observables here depend on this Observable as a source,
-    // we prefer deferring Subscription until those Observables are themselves
-    // all subscribed to.
-    // This is needed because `emeManager$` might send events synchronously
-    // on subscription. In that case, it might communicate those events directly
-    // after the first Subscription is done, making the next subscription miss
-    // out on those events, even if that second subscription is done
-    // synchronously after the first one.
-    // By calling `deferSubscriptions`, we ensure that subscription to
-    // `emeManager$` effectively starts after a very short delay, thus
-    // ensuring that no such race condition can occur.
-    deferSubscriptions(),
-    share());
+                                       protectedSegments$,
+                                       openMediaSource$)
+    .pipe(
+      // Because multiple Observables here depend on this Observable as a source,
+      // we prefer deferring Subscription until those Observables are themselves
+      // all subscribed to.
+      // This is needed because `drmEvents$` might send events synchronously
+      // on subscription. In that case, it might communicate those events directly
+      // after the first Subscription is done, making the next subscription miss
+      // out on those events, even if that second subscription is done
+      // synchronously after the first one.
+      // By calling `deferSubscriptions`, we ensure that subscription to
+      // `drmEvents$` effectively starts after a very short delay, thus
+      // ensuring that no such race condition can occur.
+      deferSubscriptions(),
+      share());
 
   /**
    * Translate errors coming from the media element into RxPlayer errors
@@ -220,71 +225,20 @@ export default function InitializeOnMediaSource(
    */
   const mediaError$ = throwOnMediaError(mediaElement);
 
-  /**
-   * Wait for the MediaKeys to have been created before opening the MediaSource,
-   * after that second step is done, ask the EMEManager to attach the MediaKeys.
-   * Steps are done in that specific order to avoid compatibility issues.
-   *
-   * This Observable will emit when ready both the MediaSource and useful
-   * DRM-specific information.
-   */
-  const prepareMediaSource$ = emeManager$.pipe(
-    mergeScan((
-      acc : {
-        /** set to true once EME APIs have been initialized. */
-        isEmeReady : boolean;
-        /**
-         * ID identifying the current MediaKeys' system ID. Can be used to only
-         * send initialization data linked to that ID as an optimization measure.
-         */
-        drmSystemId? : string | undefined;
-      },
-      evt : IEMEManagerEvent | IEMEDisabledEvent
-    ) => {
-      switch (evt.type) {
-        case "eme-disabled":
-        case "attached-media-keys":
-          return observableOf({ isEmeReady: true,
-                                drmSystemId: acc.drmSystemId });
-        case "created-media-keys":
-          const drmSystemId = evt.value.initializationDataSystemId;
-          return openMediaSource$.pipe(
-            mergeMap(() => {
-              // Now that the MediaSource has been opened and linked to the media
-              // element we can attach the MediaKeys instance to the latter.
-              evt.value.canAttachMediaKeys.setValue(true);
-
-              // If the `disableMediaKeysAttachmentLock` option has been set to
-              // `true`, we should not wait until the MediaKeys instance has been
-              // attached to start loading the content.
-              // TODO we may want to keep keySystems option knowledge in the EME
-              // code
-              const shouldDisableLock = evt.value.options
-                .disableMediaKeysAttachmentLock === true;
-              return shouldDisableLock ? observableOf({ isEmeReady: true,
-                                                        drmSystemId }) :
-                                         EMPTY;
-            }),
-            startWith({ isEmeReady: false, drmSystemId }));
-        default:
-          return EMPTY;
-      }
-    }, { isEmeReady: false, drmSystemId: undefined }),
-    filter((emitted) => emitted.isEmeReady),
-    take(1),
-    exhaustMap(({ drmSystemId }) =>
-      openMediaSource$
-        .pipe(map((mediaSource) => ({ mediaSource, drmSystemId })))));
+  const mediaSourceReady$ = drmEvents$.pipe(
+    filter((evt) : evt is IDecryptionReadyEvent<MediaSource> |
+                          IDecryptionDisabledEvent<MediaSource> =>
+      evt.type === "decryption-ready" || evt.type === "decryption-disabled"),
+    map(e => e.value),
+    take(1));
 
   /** Load and play the content asked. */
-  const loadContent$ = observableCombineLatest([manifest$,
-                                                prepareMediaSource$]).pipe(
-    mergeMap(([manifestEvt, mediaSourceInfo]) => {
+  const loadContent$ = observableCombineLatest([manifest$, mediaSourceReady$]).pipe(
+    mergeMap(([manifestEvt, { drmSystemId, mediaSource: initialMediaSource } ]) => {
       if (manifestEvt.type === "warning") {
         return observableOf(manifestEvt);
       }
       const { manifest } = manifestEvt;
-      const { mediaSource: initialMediaSource, drmSystemId } = mediaSourceInfo;
 
       log.debug("Init: Calculating initial time");
       const initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
@@ -320,25 +274,8 @@ export default function InitializeOnMediaSource(
         fromEvent(manifest, "decipherabilityUpdate")
           .pipe(map(EVENTS.decipherabilityUpdate)));
 
-      const setUndecipherableRepresentations$ = emeManager$.pipe(
-        tap((evt) => {
-          if (evt.type === "keys-update") {
-            manifest.updateDeciperabilitiesBasedOnKeyIds(evt.value);
-          } else if (evt.type === "blacklist-protection-data") {
-            log.info("Init: blacklisting Representations based on protection data.");
-            manifest.addUndecipherableProtectionData(evt.value);
-          }
-        }),
-        // 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 observableMerge(manifestEvents$,
                              manifestUpdate$,
-                             setUndecipherableRepresentations$,
                              recursiveLoad$)
         .pipe(startWith(EVENTS.manifestReady(manifest)),
               finalize(() => { scheduleRefresh$.complete(); }));
@@ -368,6 +305,7 @@ export default function InitializeOnMediaSource(
                                         canUseUnsafeMode: true });
                 return null;
               case "manifest-might-be-out-of-sync":
+                const { OUT_OF_SYNC_MANIFEST_REFRESH_DELAY } = config.getCurrent();
                 scheduleRefresh$.next({
                   completeRefresh: true,
                   canUseUnsafeMode: false,
@@ -420,5 +358,5 @@ export default function InitializeOnMediaSource(
       }
     }));
 
-  return observableMerge(loadContent$, mediaError$, emeManager$);
+  return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()));
 }

package/src/core/init/link_drm_and_content.ts

@@ -0,0 +1,176 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  map,
+  merge as observableMerge,
+  Observable,
+  Subscription,
+} from "rxjs";
+import {
+  events,
+  hasEMEAPIs,
+} from "../../compat/";
+import { EncryptedMediaError } from "../../errors";
+import features from "../../features";
+import log from "../../log";
+import {
+  IContentProtection,
+  IKeySystemOption,
+  ContentDecryptorState,
+} from "../decrypt";
+import { IWarningEvent } from "./types";
+
+const { onEncrypted$ } = events;
+
+/**
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Array.<Object>} keySystems
+ * @param {Observable<Object>} contentProtections$
+ * @param {Promise} linkingMedia$
+ * @returns {Observable}
+ */
+export default function linkDrmAndContent<T>(
+  mediaElement : HTMLMediaElement,
+  keySystems : IKeySystemOption[],
+  contentProtections$ : Observable<IContentProtection>,
+  linkingMedia$ : Observable<T>
+) : Observable<IContentDecryptorInitEvent<T>> {
+  const encryptedEvents$ = observableMerge(onEncrypted$(mediaElement),
+                                           contentProtections$);
+  if (features.ContentDecryptor == null) {
+    return observableMerge(
+      encryptedEvents$.pipe(map(() => {
+        log.error("Init: Encrypted event but EME feature not activated");
+        throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
+                                      "EME feature not activated.");
+      })),
+      linkingMedia$.pipe(map(mediaSource => ({
+        type: "decryption-disabled" as const,
+        value: { drmSystemId: undefined, mediaSource },
+      }))));
+  }
+
+  if (keySystems.length === 0) {
+    return observableMerge(
+      encryptedEvents$.pipe(map(() => {
+        log.error("Init: Ciphered media and no keySystem passed");
+        throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
+                                      "Media is encrypted and no `keySystems` given");
+      })),
+      linkingMedia$.pipe(map(mediaSource => ({
+        type: "decryption-disabled" as const,
+        value: { drmSystemId: undefined, mediaSource },
+      }))));
+  }
+
+  if (!hasEMEAPIs()) {
+    return observableMerge(
+      encryptedEvents$.pipe(map(() => {
+        log.error("Init: Encrypted event but no EME API available");
+        throw new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR",
+                                      "Encryption APIs not found.");
+      })),
+      linkingMedia$.pipe(map(mediaSource => ({
+        type: "decryption-disabled" as const,
+        value: { drmSystemId: undefined, mediaSource },
+      }))));
+  }
+
+  log.debug("Init: Creating ContentDecryptor");
+  const ContentDecryptor = features.ContentDecryptor;
+  return new Observable((obs) => {
+    const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
+
+    let mediaSub : Subscription | undefined;
+    contentDecryptor.addEventListener("stateChange", (state) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+
+        mediaSub = linkingMedia$.subscribe(mediaSource => {
+          contentDecryptor.addEventListener("stateChange", (newState) => {
+            if (newState === ContentDecryptorState.ReadyForContent) {
+              obs.next({ type: "decryption-ready",
+                         value: { drmSystemId: contentDecryptor.systemId,
+                                  mediaSource } });
+              contentDecryptor.removeEventListener("stateChange");
+            }
+          });
+
+          contentDecryptor.attach();
+        });
+      }
+    });
+
+    contentDecryptor.addEventListener("error", (e) => {
+      obs.error(e);
+    });
+
+    contentDecryptor.addEventListener("warning", (w) => {
+      obs.next({ type: "warning", value: w });
+    });
+
+    const protectionDataSub = contentProtections$.subscribe(data => {
+      contentDecryptor.onInitializationData(data);
+    });
+
+    return () => {
+      protectionDataSub.unsubscribe();
+      mediaSub?.unsubscribe();
+      contentDecryptor.dispose();
+    };
+  });
+}
+
+export type IContentDecryptorInitEvent<T> = IDecryptionDisabledEvent<T> |
+                                            IDecryptionReadyEvent<T> |
+                                            IWarningEvent;
+
+/**
+ * Event emitted after deciding that no decryption logic will be launched for
+ * the current content.
+ */
+export interface IDecryptionDisabledEvent<T> {
+  type: "decryption-disabled";
+  value: {
+    /**
+     * Identify the current DRM's system ID.
+     * Here `undefined` as no decryption capability has been added.
+     */
+    drmSystemId: undefined;
+    /** The value outputed by the `linkingMedia$` Observable. */
+    mediaSource: T;
+  };
+}
+
+/**
+ * Event emitted when decryption capabilities have started and content can
+ * begin to be pushed on the HTMLMediaElement.
+ */
+export interface IDecryptionReadyEvent<T> {
+  type: "decryption-ready";
+  value: {
+    /**
+     * Identify the current DRM's systemId as an hexadecimal string, so the
+     * RxPlayer may be able to (optionally) only send the corresponding
+     * encryption initialization data.
+     * `undefined` if unknown.
+     */
+    drmSystemId: string | undefined;
+    /** The value outputed by the `linkingMedia$` Observable. */
+    mediaSource: T;
+  };
+}

package/src/core/init/manifest_update_scheduler.ts

@@ -38,9 +38,6 @@ import {
 } from "../fetchers";
 import { IWarningEvent } from "./types";
 
-const { FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY,
-        MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE,
-        MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE } = config;
 
 /** Arguments to give to the `manifestUpdateScheduler` */
 export interface IManifestUpdateSchedulerArguments {
@@ -139,6 +136,9 @@ export default function manifestUpdateScheduler({
       parsingTime + (updatingTime ?? 0) :
       undefined;
 
+    const { MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE,
+            MIN_MANIFEST_PARSING_TIME_TO_ENTER_UNSAFE_MODE } = config.getCurrent();
+
     /**
      * "unsafeMode" is a mode where we unlock advanced Manifest parsing
      * optimizations with the added risk to lose some information.
@@ -147,6 +147,7 @@ export default function manifestUpdateScheduler({
      * Only perform parsing in `unsafeMode` when the last full parsing took a
      * lot of time and do not go higher than the maximum consecutive time.
      */
+
     const unsafeModeEnabled = consecutiveUnsafeMode > 0 ?
       consecutiveUnsafeMode < MAX_CONSECUTIVE_MANIFEST_PARSING_IN_UNSAFE_MODE :
       totalUpdateTime !== undefined ?
@@ -309,6 +310,7 @@ export default function manifestUpdateScheduler({
                                                  "unknown error";
             log.warn(`MUS: Attempt to update Manifest failed: ${message}`,
                      "Re-downloading the Manifest fully");
+            const { FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY } = config.getCurrent();
             return startManualRefreshTimer(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY,
                                            minimumManifestUpdateInterval,
                                            newSendingTime)

package/src/core/init/stall_avoider.ts

@@ -44,11 +44,6 @@ import {
   IWarningEvent,
 } from "./types";
 
-const { BUFFER_DISCONTINUITY_THRESHOLD,
-        FORCE_DISCONTINUITY_SEEK_DELAY,
-        FREEZING_STALLED_DELAY,
-        UNFREEZING_SEEK_DELAY,
-        UNFREEZING_DELTA_POSITION } = config;
 
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
@@ -225,6 +220,12 @@ export default function StallAvoider(
               rebuffering,
               freezing } = observation;
 
+      const { BUFFER_DISCONTINUITY_THRESHOLD,
+              FORCE_DISCONTINUITY_SEEK_DELAY,
+              FREEZING_STALLED_DELAY,
+              UNFREEZING_SEEK_DELAY,
+              UNFREEZING_DELTA_POSITION } = config.getCurrent();
+
       if (freezing !== null) {
         const now = performance.now();
 

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

@@ -43,7 +43,6 @@ import {
   IStreamEventPayload,
 } from "./types";
 
-const { STREAM_EVENT_EMITTER_POLL_INTERVAL } = config;
 
 /**
  * Tells if a stream event has a duration
@@ -161,6 +160,8 @@ function streamEventsEmitter(manifest: Manifest,
       if (!hasEvents) {
         return EMPTY;
       }
+
+      const { STREAM_EVENT_EMITTER_POLL_INTERVAL } = config.getCurrent();
       return observableCombineLatest([
         interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
         observation$,

package/src/core/init/types.ts

@@ -20,17 +20,6 @@ import Manifest, {
   Period,
   Representation,
 } from "../../manifest";
-import {
-  IAttachedMediaKeysEvent,
-  IBlacklistProtectionDataEvent,
-  ICreatedMediaKeysEvent,
-  IEncryptedEvent,
-  IInitDataIgnoredEvent,
-  IKeysUpdateEvent,
-  INoUpdateEvent,
-  ISessionMessageEvent,
-  ISessionUpdatedEvent,
-} from "../eme";
 import SegmentBuffersStore from "../segment_buffers";
 import {
   IActivePeriodChangedEvent,
@@ -49,7 +38,6 @@ import {
   IStreamManifestMightBeOutOfSync,
   IStreamNeedsManifestRefresh,
 } from "../stream";
-import { IEMEDisabledEvent } from "./create_eme_manager";
 import {
   IStreamEventEvent,
   IStreamEventSkipEvent,
@@ -154,19 +142,6 @@ export type IInitEvent = IManifestReadyEvent |
                          IReloadingMediaSourceEvent |
                          IDecipherabilityUpdateEvent |
                          IWarningEvent |
-                         IEMEDisabledEvent |
-
-                         // Coming from the `EMEManager`
-
-                         IEncryptedEvent |
-                         ICreatedMediaKeysEvent |
-                         IAttachedMediaKeysEvent |
-                         IInitDataIgnoredEvent |
-                         ISessionMessageEvent |
-                         IKeysUpdateEvent |
-                         INoUpdateEvent |
-                         ISessionUpdatedEvent |
-                         IBlacklistProtectionDataEvent |
 
                          // Coming from the `MediaSourceLoader`
 
@@ -192,17 +167,4 @@ export type IInitEvent = IManifestReadyEvent |
 export type IDirectfileEvent = IStalledEvent |
                                IUnstalledEvent |
                                ILoadedEvent |
-                               IWarningEvent |
-                               IEMEDisabledEvent |
-
-                               // Coming from the `EMEManager`
-
-                               IEncryptedEvent |
-                               ICreatedMediaKeysEvent |
-                               IAttachedMediaKeysEvent |
-                               IInitDataIgnoredEvent |
-                               ISessionMessageEvent |
-                               IKeysUpdateEvent |
-                               INoUpdateEvent |
-                               ISessionUpdatedEvent |
-                               IBlacklistProtectionDataEvent;
+                               IWarningEvent;

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

@@ -48,7 +48,6 @@ import {
   SegmentBufferOperation,
 } from "../types";
 
-const { SOURCE_BUFFER_FLUSHING_INTERVAL } = config;
 
 /**
  * Item added to the AudioVideoSegmentBuffer's queue before being processed into
@@ -172,6 +171,8 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     this._lastInitSegment = null;
     this.codec = codec;
 
+    const { SOURCE_BUFFER_FLUSHING_INTERVAL } = config.getCurrent();
+
     // Some browsers (happened with firefox 66) sometimes "forget" to send us
     // `update` or `updateend` events.
     // In that case, we're completely unable to continue the queue here and

package/src/core/segment_buffers/implementations/text/html/html_text_segment_buffer.ts

@@ -48,8 +48,6 @@ const { onEnded$,
         onSeeked$,
         onSeeking$ } = events;
 
-const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL,
-        TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config;
 
 /**
  * Generate the interval at which TextTrack HTML Cues should be refreshed.
@@ -60,7 +58,7 @@ function generateRefreshInterval(videoElement : HTMLMediaElement) : Observable<b
   const seeking$ = onSeeking$(videoElement);
   const seeked$ = onSeeked$(videoElement);
   const ended$ = onEnded$(videoElement);
-
+  const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
   const manualRefresh$ = observableMerge(seeked$, ended$);
   const autoRefresh$ = observableInterval(MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL)
     .pipe(startWith(null));
@@ -182,7 +180,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
           this._disableCurrentCues();
           return;
         }
-
+        const { MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL } = config.getCurrent();
         // to spread the time error, we divide the regular chosen interval.
         const time = Math.max(this._videoElement.currentTime +
                               (MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL / 1000) / 2,
@@ -420,6 +418,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
                                element : HTMLElement; } => cue.resolution !== null);
 
     if (proportionalCues.length > 0) {
+      const { TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config.getCurrent();
       // update propertionally-sized elements periodically
       onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL)
         .pipe(takeUntil(this._clearSizeUpdates$),