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

package/src/core/stream/utils/create_reload_request.ts

@@ -32,7 +32,7 @@ export default function createReloadRequest (
   timeBounds : { start : number | undefined; end : number | undefined },
   cancelSignal : CancellationSignal
 ) : void {
-  if (cancelSignal.isCancelled) {
+  if (cancelSignal.isCancelled()) {
     return;
   }
 

package/src/default_config.ts

@@ -374,6 +374,33 @@ const DEFAULT_CONFIG = {
      */
   SAMPLING_INTERVAL_NO_MEDIASOURCE: 500,
 
+  /**
+   * Amount of buffer to have ahead of the current position before we may
+   * consider buffer-based adaptive estimates, in seconds.
+   *
+   * For example setting it to `10` means that we need to have ten seconds of
+   * buffer ahead of the current position before relying on buffer-based
+   * adaptive estimates.
+   *
+   * To avoid getting in-and-out of the buffer-based logic all the time, it
+   * should be set higher than `ABR_EXIT_BUFFER_BASED_ALGO`.
+   */
+  ABR_ENTER_BUFFER_BASED_ALGO: 10,
+
+  /**
+   * Below this amount of buffer ahead of the current position, in seconds, we
+   * will stop using buffer-based estimate in our adaptive logic to select a
+   * quality.
+   *
+   * For example setting it to `5` means that if we have less than 5 seconds of
+   * buffer ahead of the current position, we should stop relying on
+   * buffer-based estimates to choose a quality.
+   *
+   * To avoid getting in-and-out of the buffer-based logic all the time, it
+   * should be set lower than `ABR_ENTER_BUFFER_BASED_ALGO`.
+   */
+  ABR_EXIT_BUFFER_BASED_ALGO: 5,
+
     /**
      * Minimum number of bytes sampled before we trust the estimate.
      * If we have not sampled much data, our estimate may not be accurate
@@ -412,8 +439,8 @@ const DEFAULT_CONFIG = {
      * @type {Object}
      */
   ABR_REGULAR_FACTOR: {
-    DEFAULT: 0.8,
-    LOW_LATENCY: 0.8,
+    DEFAULT: 0.72,
+    LOW_LATENCY: 0.72,
   },
 
     /**
@@ -810,15 +837,36 @@ const DEFAULT_CONFIG = {
      */
   MIN_CANCELABLE_PRIORITY: 3, // priority number 3 onward can be cancelled
 
-    /**
-     * Robustnesses used in the {audio,video}Capabilities of the
-     * MediaKeySystemConfiguration (DRM).
-     *
-     * Only used for widevine keysystems.
-     *
-     * Defined in order of importance (first will be tested first etc.)
-     * @type {Array.<string>}
-     */
+  /**
+   * Codecs used in the videoCapabilities of the MediaKeySystemConfiguration
+   * (DRM).
+   *
+   * Defined in order of importance (first will be tested first etc.)
+   * @type {Array.<string>}
+   */
+  EME_DEFAULT_VIDEO_CODECS: [ "video/mp4;codecs=\"avc1.4d401e\"",
+                              "video/mp4;codecs=\"avc1.42e01e\"",
+                              "video/webm;codecs=\"vp8\"" ],
+
+  /**
+   * Codecs used in the audioCapabilities of the MediaKeySystemConfiguration
+   * (DRM).
+   *
+   * Defined in order of importance (first will be tested first etc.)
+   * @type {Array.<string>}
+   */
+  EME_DEFAULT_AUDIO_CODECS: [ "audio/mp4;codecs=\"mp4a.40.2\"",
+                              "audio/webm;codecs=opus" ],
+
+  /**
+   * Robustnesses used in the {audio,video}Capabilities of the
+   * MediaKeySystemConfiguration (DRM).
+   *
+   * Only used for widevine keysystems.
+   *
+   * Defined in order of importance (first will be tested first etc.)
+   * @type {Array.<string>}
+   */
   EME_DEFAULT_WIDEVINE_ROBUSTNESSES: [ "HW_SECURE_ALL",
                                        "HW_SECURE_DECODE",
                                        "HW_SECURE_CRYPTO",

package/src/errors/__tests__/media_error.test.ts

@@ -19,25 +19,25 @@ import MediaError from "../media_error";
 describe("errors - MediaError", () => {
   it("should format a MediaError", () => {
     const reason = "test";
-    const mediaError = new MediaError("BUFFER_FULL_ERROR", reason);
+    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", reason);
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
     expect(mediaError.type).toBe("MEDIA_ERROR");
-    expect(mediaError.code).toBe("BUFFER_FULL_ERROR");
+    expect(mediaError.code).toBe("MEDIA_TIME_BEFORE_MANIFEST");
     expect(mediaError.fatal).toBe(false);
-    expect(mediaError.message).toBe("MediaError (BUFFER_FULL_ERROR) test");
+    expect(mediaError.message).toBe("MediaError (MEDIA_TIME_BEFORE_MANIFEST) test");
   });
 
   it("should be able to set it as fatal", () => {
     const reason = "test";
-    const mediaError = new MediaError("BUFFER_APPEND_ERROR", reason);
+    const mediaError = new MediaError("MEDIA_TIME_AFTER_MANIFEST", reason);
     mediaError.fatal = true;
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
     expect(mediaError.type).toBe("MEDIA_ERROR");
-    expect(mediaError.code).toBe("BUFFER_APPEND_ERROR");
+    expect(mediaError.code).toBe("MEDIA_TIME_AFTER_MANIFEST");
     expect(mediaError.fatal).toBe(true);
-    expect(mediaError.message).toBe("MediaError (BUFFER_APPEND_ERROR) test");
+    expect(mediaError.message).toBe("MediaError (MEDIA_TIME_AFTER_MANIFEST) test");
   });
 
   it("should filter in a valid error code", () => {

package/src/errors/index.ts

@@ -26,7 +26,9 @@ import {
 } from "./error_codes";
 import formatError from "./format_error";
 import isKnownError from "./is_known_error";
-import MediaError from "./media_error";
+import MediaError, {
+  IMediaErrorTrackContext,
+} from "./media_error";
 import NetworkError from "./network_error";
 import OtherError from "./other_error";
 import RequestError from "./request_error";
@@ -39,6 +41,7 @@ export {
   ErrorTypes,
   IErrorCode,
   IErrorType,
+  IMediaErrorTrackContext,
   formatError,
   MediaError as MediaError,
   NetworkError,

package/src/errors/media_error.ts

@@ -14,12 +14,42 @@
  * limitations under the License.
  */
 
+import { Adaptation } from "../manifest";
+import {
+  IAudioTrack,
+  ITextTrack,
+  IVideoTrack,
+} from "../public_types";
 import {
   ErrorTypes,
   IMediaErrorCode,
 } from "./error_codes";
 import errorMessage from "./error_message";
 
+interface IAudioTrackMediaErrorContext {
+  type : "audio";
+  track : IAudioTrack;
+}
+
+interface IVideoTrackMediaErrorContext {
+  type : "video";
+  track : IVideoTrack;
+}
+
+interface ITextTrackMediaErrorContext {
+  type : "text";
+  track : ITextTrack;
+}
+
+export type IMediaErrorTrackContext = IAudioTrackMediaErrorContext |
+                                      IVideoTrackMediaErrorContext |
+                                      ITextTrackMediaErrorContext;
+
+type ICodeWithAdaptationType = "BUFFER_APPEND_ERROR" |
+                               "BUFFER_FULL_ERROR" |
+                               "NO_PLAYABLE_REPRESENTATION" |
+                               "MANIFEST_INCOMPATIBLE_CODECS_ERROR";
+
 /**
  * Error linked to the media Playback.
  *
@@ -31,13 +61,32 @@ export default class MediaError extends Error {
   public readonly type : "MEDIA_ERROR";
   public readonly message : string;
   public readonly code : IMediaErrorCode;
+  public readonly trackInfo : IMediaErrorTrackContext | undefined;
   public fatal : boolean;
 
   /**
    * @param {string} code
    * @param {string} reason
+   * @param {Object|undefined} [context]
    */
-  constructor(code : IMediaErrorCode, reason : string) {
+  constructor(
+    code : ICodeWithAdaptationType,
+    reason : string,
+    context: {
+      adaptation : Adaptation | undefined;
+    }
+  );
+  constructor(
+    code : Exclude<IMediaErrorCode, ICodeWithAdaptationType>,
+    reason : string,
+  );
+  constructor(
+    code : IMediaErrorCode,
+    reason : string,
+    context? : {
+      adaptation? : Adaptation | undefined;
+    } | undefined
+  ) {
     super();
     // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
     Object.setPrototypeOf(this, MediaError.prototype);
@@ -48,5 +97,22 @@ export default class MediaError extends Error {
     this.code = code;
     this.message = errorMessage(this.name, this.code, reason);
     this.fatal = false;
+    const adaptation = context?.adaptation;
+    if (adaptation !== undefined) {
+      switch (adaptation.type) {
+        case "audio":
+          this.trackInfo = { type: "audio",
+                             track: adaptation.toAudioTrack(false) };
+          break;
+        case "video":
+          this.trackInfo = { type: "video",
+                             track: adaptation.toVideoTrack(false) };
+          break;
+        case "text":
+          this.trackInfo = { type: "text",
+                             track: adaptation.toTextTrack() };
+          break;
+      }
+    }
   }
 }

package/src/experimental/features/__tests__/debug_element.test.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+
+describe("Features list - DEBUG_ELEMENT", () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  it("should add DEBUG_ELEMENT in the current features", () => {
+    const feat = {};
+    jest.mock("../../../core/api/debug", () => ({ __esModule: true as const,
+                                                  default: feat }));
+    const addFeature = jest.requireActual("../debug_element").default;
+
+    const featureObject : {
+      createDebugElement? : unknown;
+    } = {};
+    addFeature(featureObject);
+    expect(featureObject).toEqual({ createDebugElement: {} });
+    expect(featureObject.createDebugElement).toBe(feat);
+  });
+});

package/src/experimental/features/debug_element.ts

@@ -0,0 +1,13 @@
+import createDebugElement from "../../core/api/debug";
+import { IFeaturesObject } from "../../features/types";
+
+/**
+ * Add ability to parse SAMI text tracks in an HTML textrack mode.
+ * @param {Object} features
+ */
+function addDebugElementFeature(features : IFeaturesObject) : void {
+  features.createDebugElement = createDebugElement;
+}
+
+export { addDebugElementFeature as DEBUG_ELEMENT };
+export default addDebugElementFeature;

package/src/experimental/features/index.ts

@@ -15,5 +15,6 @@
  */
 
 export { DASH_WASM } from "./dash_wasm";
+export { DEBUG_ELEMENT } from "./debug_element";
 export { LOCAL_MANIFEST } from "./local";
 export { METAPLAYLIST } from "./metaplaylist";

package/src/experimental/tools/VideoThumbnailLoader/load_and_push_segment.ts

@@ -33,30 +33,33 @@ export default function loadAndPushSegment(
   segmentInfo : ISegmentLoaderContent,
   segmentBuffer: AudioVideoSegmentBuffer,
   segmentFetcher: ISegmentFetcher<ArrayBuffer | Uint8Array>,
+  initSegmentUniqueId : string | null,
   cancelSignal: CancellationSignal
 ): Promise<unknown> {
   const pushOperations : Array<Promise<unknown>> = [];
   return segmentFetcher(segmentInfo, {
     onChunk(parseChunk) {
       const parsed = parseChunk(undefined);
-      let isIsInitSegment : boolean;
+      let isInitSegment : boolean;
       let data : BufferSource | null;
       let timestampOffset : number;
       const codec = segmentInfo.representation.getMimeTypeString();
       if (parsed.segmentType === "init") {
-        isIsInitSegment = true;
+        isInitSegment = true;
         data = parsed.initializationData;
         timestampOffset = 0;
+        if (initSegmentUniqueId !== null) {
+          segmentBuffer.declareInitSegment(initSegmentUniqueId, data);
+        }
       } else {
-        isIsInitSegment = false;
+        isInitSegment = false;
         data = parsed.chunkData;
         timestampOffset = parsed.chunkOffset;
       }
       const pushOperation = segmentBuffer.pushChunk({
-        data: { initSegment: isIsInitSegment ? data :
-                                               null,
-                chunk: isIsInitSegment ? null :
-                                         data,
+        data: { initSegmentUniqueId,
+                chunk: isInitSegment ? null :
+                                       data,
                 appendWindow: [segmentInfo.period.start, segmentInfo.period.end],
                 timestampOffset,
                 codec },

package/src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts

@@ -18,6 +18,7 @@ import { MediaSource_ } from "../../../compat";
 import { resetMediaSource } from "../../../core/init/utils/create_media_source";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 import log from "../../../log";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import { CancellationSignal } from "../../../utils/task_canceller";
 
@@ -33,7 +34,7 @@ export default function prepareSourceBuffer(
   codec: string,
   cleanUpSignal: CancellationSignal
 ): Promise<AudioVideoSegmentBuffer> {
-  return new Promise((resolve, reject) => {
+  return createCancellablePromise(cleanUpSignal, (resolve, reject) => {
     if (MediaSource_ == null) {
       throw new Error("No MediaSource Object was found in the current browser.");
     }
@@ -49,15 +50,17 @@ export default function prepareSourceBuffer(
 
     log.info("Init: Attaching MediaSource URL to the media element", objectURL);
     videoElement.src = objectURL;
+    cleanUpSignal.register(() => {
+      resetMediaSource(videoElement, mediaSource, objectURL);
+    });
 
     mediaSource.addEventListener("sourceopen", onSourceOpen);
     mediaSource.addEventListener("webkitsourceopen", onSourceOpen);
 
-    cleanUpSignal.register(() => {
+    return () => {
       mediaSource.removeEventListener("sourceopen", onSourceOpen);
       mediaSource.removeEventListener("webkitsourceopen", onSourceOpen);
-      resetMediaSource(videoElement, mediaSource, objectURL);
-    });
+    };
 
     function onSourceOpen() {
       try {

package/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -167,7 +167,7 @@ export default class VideoThumbnailLoader {
 
     let lastRepInfo : IVideoThumbnailLoaderRepresentationInfo;
     if (this._lastRepresentationInfo === null) {
-      const cleaner = new TaskCanceller();
+      const lastRepInfoCleaner = new TaskCanceller();
       const segmentFetcher = createSegmentFetcher(
         "video",
         loader.video,
@@ -179,13 +179,17 @@ export default class VideoThumbnailLoader {
           maxRetry: 0,
           requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT }
       ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
+      const initSegment = content.representation.index.getInitSegment();
+      const initSegmentUniqueId = initSegment !== null ?
+        content.representation.uniqueId :
+        null;
       const segmentBufferProm = prepareSourceBuffer(
         this._videoElement,
         content.representation.getMimeTypeString(),
-        cleaner.signal
+        lastRepInfoCleaner.signal
       ).then(async (segmentBuffer) => {
-        const initSegment = content.representation.index.getInitSegment();
-        if (initSegment === null) {
+        if (initSegment === null || initSegmentUniqueId === null) {
+          lastRepInfo.initSegmentUniqueId = null;
           return segmentBuffer;
         }
         const segmentInfo = objectAssign({ segment: initSegment },
@@ -193,13 +197,18 @@ export default class VideoThumbnailLoader {
         await loadAndPushSegment(segmentInfo,
                                  segmentBuffer,
                                  lastRepInfo.segmentFetcher,
-                                 cleaner.signal);
+                                 initSegmentUniqueId,
+                                 lastRepInfoCleaner.signal);
+        lastRepInfoCleaner.signal.register(() => {
+          segmentBuffer.freeInitSegment(initSegmentUniqueId);
+        });
         return segmentBuffer;
       });
       lastRepInfo = {
-        cleaner,
+        cleaner: lastRepInfoCleaner,
         segmentBuffer: segmentBufferProm,
         content,
+        initSegmentUniqueId,
         segmentFetcher,
         pendingRequests: [],
       };
@@ -243,15 +252,20 @@ export default class VideoThumbnailLoader {
           if (pending !== undefined) {
             promises.push(pending.promise);
           } else {
-            const requestCanceller = new TaskCanceller({
-              cancelOn: lastRepInfo.cleaner.signal,
-            });
+            const requestCanceller = new TaskCanceller();
+            const unlinkSignal = requestCanceller
+              .linkToSignal(lastRepInfo.cleaner.signal);
             const segmentInfo = objectAssign({ segment },
                                              content);
             const prom = loadAndPushSegment(segmentInfo,
                                             segmentBuffer,
                                             lastRepInfo.segmentFetcher,
-                                            requestCanceller.signal);
+                                            lastRepInfo.initSegmentUniqueId,
+                                            requestCanceller.signal)
+              .then(unlinkSignal, (err) => {
+                unlinkSignal();
+                throw err;
+              });
             const newReq = {
               segmentId: segment.id,
               canceller: requestCanceller,
@@ -386,6 +400,7 @@ interface IVideoThumbnailLoaderRepresentationInfo {
    * `pendingRequests`.
    */
   pendingRequests : IPendingRequestInfo[];
+  initSegmentUniqueId : string |  null;
 }
 
 interface IPendingRequestInfo {

package/src/experimental/tools/mediaCapabilitiesProber/index.ts

@@ -15,8 +15,4 @@
  */
 
 import MediaCapabilitiesProber from "./api";
-import log from "./log";
-
-log.setLevel("WARNING");
-
 export default MediaCapabilitiesProber;

package/src/features/__tests__/initialize_features.test.ts

@@ -47,6 +47,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -76,6 +77,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 1,
       LOCAL_MANIFEST: 1,
       METAPLAYLIST: 1,
+      DEBUG_ELEMENT: 1,
       NATIVE_SAMI: 1,
       NATIVE_SRT: 1,
       NATIVE_TTML: 1,
@@ -110,6 +112,7 @@ describe("Features - initializeFeaturesObject", () => {
         wasm: null,
       },
       ContentDecryptor: jest.requireActual("../../core/decrypt/index").default,
+      createDebugElement: jest.requireActual("../../core/api/debug").default,
       directfile: {
         initDirectFile: jest.requireActual("../../core/init/directfile_content_initializer").default,
         mediaElementTracksStore:
@@ -150,6 +153,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 1,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -191,6 +195,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -232,6 +237,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -273,6 +279,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -314,6 +321,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -355,6 +363,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 1,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -396,6 +405,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 1,
@@ -437,6 +447,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 1,
       NATIVE_TTML: 0,

package/src/features/features_object.ts

@@ -22,6 +22,7 @@ import { IFeaturesObject } from "./types";
  */
 const features : IFeaturesObject = { dashParsers: { wasm: null,
                                                     js: null },
+                                     createDebugElement: null,
                                      directfile: null,
                                      ContentDecryptor: null,
                                      htmlTextTracksBuffer: null,

package/src/features/initialize_features.ts

@@ -29,10 +29,11 @@ export default function initializeFeaturesObject() : void {
   }
 
   // Feature switching the Native TextTrack implementation
-  const HAS_NATIVE_MODE = __FEATURES__.NATIVE_VTT ||
-                          __FEATURES__.NATIVE_SAMI ||
-                          __FEATURES__.NATIVE_TTML ||
-                          __FEATURES__.NATIVE_SRT;
+  const HAS_NATIVE_MODE =
+    __FEATURES__.NATIVE_VTT === __FEATURES__.IS_ENABLED as number ||
+    __FEATURES__.NATIVE_SAMI === __FEATURES__.IS_ENABLED as number ||
+    __FEATURES__.NATIVE_TTML === __FEATURES__.IS_ENABLED as number ||
+    __FEATURES__.NATIVE_SRT === __FEATURES__.IS_ENABLED as number;
 
   if (__FEATURES__.SMOOTH === __FEATURES__.IS_ENABLED as number) {
     features.transports.smooth = require("../transports/smooth/index.ts").default;
@@ -49,8 +50,11 @@ export default function initializeFeaturesObject() : void {
     features.transports.metaplaylist =
       require("../transports/metaplaylist/index.ts").default;
   }
+  if (__FEATURES__.DEBUG_ELEMENT === __FEATURES__.IS_ENABLED as number) {
+    features.createDebugElement = require("../core/api/debug/index.ts").default;
+  }
 
-  if (HAS_NATIVE_MODE === __FEATURES__.IS_ENABLED as number) {
+  if (HAS_NATIVE_MODE) {
     features.nativeTextTracksBuffer =
       require("../core/segment_buffers/implementations/text/native/index.ts").default;
     if (__FEATURES__.NATIVE_VTT === __FEATURES__.IS_ENABLED as number) {
@@ -75,12 +79,13 @@ export default function initializeFeaturesObject() : void {
   }
 
   // Feature switching the HTML TextTrack implementation
-  const HAS_HTML_MODE = __FEATURES__.HTML_VTT ||
-                        __FEATURES__.HTML_SAMI ||
-                        __FEATURES__.HTML_TTML ||
-                        __FEATURES__.HTML_SRT;
+  const HAS_HTML_MODE =
+    __FEATURES__.HTML_VTT === __FEATURES__.IS_ENABLED as number ||
+    __FEATURES__.HTML_SAMI === __FEATURES__.IS_ENABLED as number ||
+    __FEATURES__.HTML_TTML === __FEATURES__.IS_ENABLED as number ||
+    __FEATURES__.HTML_SRT === __FEATURES__.IS_ENABLED as number;
 
-  if (HAS_HTML_MODE === __FEATURES__.IS_ENABLED as number) {
+  if (HAS_HTML_MODE) {
     features.htmlTextTracksBuffer =
       require("../core/segment_buffers/implementations/text/html/index.ts").default;
     if (__FEATURES__.HTML_SAMI === __FEATURES__.IS_ENABLED as number) {

package/src/features/types.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import RxPlayer from "../core/api";
 // eslint-disable-next-line max-len
 import MediaElementTracksStore from "../core/api/track_management/media_element_tracks_store";
 import type ContentDecryptor from "../core/decrypt";
@@ -29,6 +30,7 @@ import {
   INativeTextTracksParserFn,
 } from "../parsers/texttracks";
 import { ITransportFunction } from "../transports";
+import { CancellationSignal } from "../utils/task_canceller";
 
 export type IDirectFileInit = typeof DirectFileContentInitializer;
 
@@ -55,6 +57,13 @@ export interface IFeaturesObject {
                  mediaElementTracksStore : IMediaElementTracksStore; } |
                null;
   ContentDecryptor : IContentDecryptorClass|null;
+  createDebugElement : (
+    (
+      parentElt : HTMLElement,
+      instance : RxPlayer,
+      cancelSignal : CancellationSignal
+    ) => void
+  ) | null;
   htmlTextTracksBuffer : IHTMLTextTracksBuffer|null;
   htmlTextTracksParsers : Partial<Record<string, IHTMLTextTracksParserFn>>;
   transports : Partial<Record<string, ITransportFunction>>;