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

package/src/manifest/representation.ts

@@ -22,20 +22,47 @@ import {
   IParsedRepresentation,
 } from "../parsers/manifest";
 import {
+  IAudioRepresentation,
   ITrackType,
   IHDRInformation,
+  IVideoRepresentation,
 } from "../public_types";
 import areArraysOfNumbersEqual from "../utils/are_arrays_of_numbers_equal";
+import idGenerator from "../utils/id_generator";
 import { IRepresentationIndex } from "./representation_index";
 
+const generateRepresentationUniqueId = idGenerator();
+
 /**
  * Normalized Representation structure.
  * @class Representation
  */
 class Representation {
-  /** ID uniquely identifying the Representation in the Adaptation. */
+  /**
+   * ID uniquely identifying the `Representation` in its parent `Adaptation`.
+   *
+   * This identifier might be linked to an identifier present in the original
+   * Manifest file, it is thus the identifier to use to determine if a
+   * `Representation` from a refreshed `Manifest` is actually the same one than
+   * one in the previously loaded Manifest (as long as the `Adaptation` and
+   * `Period` are also the same).
+   *
+   * For a globally unique identifier regardless of the `Adaptation`, `Period`
+   * or even `Manifest`, you can rely on `uniqueId` instead.
+   */
   public readonly id : string;
 
+  /**
+   * Globally unique identifier for this `Representation` object.
+   *
+   * This identifier is guaranteed to be unique for any `Representation`s of all
+   * `Manifest` objects created in the current JS Realm.
+   * As such, it can be used as an identifier for the JS object itself, whereas
+   * `id` is the identifier for the original Manifest's Representation in the
+   * scope of its parent `Adaptation`.
+   */
+  public readonly uniqueId : string;
+
   /**
    * Interface allowing to get information about segments available for this
    * Representation.
@@ -115,6 +142,7 @@ class Representation {
    */
   constructor(args : IParsedRepresentation, opts : { type : ITrackType }) {
     this.id = args.id;
+    this.uniqueId = generateRepresentationUniqueId();
     this.bitrate = args.bitrate;
     this.codec = args.codecs;
 
@@ -145,10 +173,16 @@ class Representation {
     this.cdnMetadata = args.cdnMetadata;
 
     this.index = args.index;
-    this.isSupported = opts.type === "audio" ||
-                       opts.type === "video" ?
-      isCodecSupported(this.getMimeTypeString()) :
-      true; // TODO for other types
+    if (opts.type === "audio" || opts.type === "video") {
+      const mimeTypeStr = this.getMimeTypeString();
+      const isSupported = isCodecSupported(mimeTypeStr);
+      if (!isSupported) {
+        log.info("Unsupported Representation", mimeTypeStr, this.id, this.bitrate);
+      }
+      this.isSupported = isSupported;
+    } else {
+      this.isSupported = true; // TODO for other types
+    }
   }
 
   /**
@@ -329,6 +363,44 @@ class Representation {
     return true;
   }
 
+  /**
+   * Format Representation as an `IAudioRepresentation`.
+   * @returns {Object}
+   */
+  public toAudioRepresentation(): IAudioRepresentation {
+    const { id, bitrate, codec, isSupported, decipherable } = this;
+    return { id,
+             bitrate,
+             codec,
+             isCodecSupported: isSupported,
+             seemsDecipherable: decipherable };
+  }
+
+  /**
+   * Format Representation as an `IVideoRepresentation`.
+   * @returns {Object}
+   */
+  public toVideoRepresentation(): IVideoRepresentation {
+    const { id,
+            bitrate,
+            frameRate,
+            width,
+            height,
+            codec,
+            hdrInfo,
+            isSupported,
+            decipherable } = this;
+    return { id,
+             bitrate,
+             frameRate,
+             width,
+             height,
+             codec,
+             hdrInfo,
+             isCodecSupported: isSupported,
+             seemsDecipherable: decipherable };
+  }
+
   /**
    * Returns `true` if this Representation can be played (that is: not
    * undecipherable and with a supported codec).

package/src/manifest/utils.ts

@@ -37,9 +37,7 @@ export function areSameContent(
   content2: IBufferedChunkInfos
 ): boolean {
   return (content1.segment.id === content2.segment.id &&
-          content1.representation.id === content2.representation.id &&
-          content1.adaptation.id === content2.adaptation.id &&
-          content1.period.id === content2.period.id);
+          content1.representation.uniqueId === content2.representation.uniqueId);
 }
 
 /**

package/src/parsers/manifest/dash/common/parse_adaptation_sets.ts

@@ -270,15 +270,6 @@ export default function parseAdaptationSets(
 
   const parsedAdaptationsIDs : string[] = [];
 
-  /**
-   * Index of the last parsed Video AdaptationSet with a Role set as "main" in
-   * `parsedAdaptations.video`.
-   * `-1` if not yet encountered.
-   * Used as we merge all main video AdaptationSet due to a comprehension of the
-   * DASH-IF IOP.
-   */
-  let lastMainVideoAdapIdx = -1;
-
   for (let adaptationIdx = 0; adaptationIdx < adaptationsIR.length; adaptationIdx++) {
     const adaptation = adaptationsIR[adaptationIdx];
     const adaptationChildren = adaptation.children;
@@ -315,7 +306,6 @@ export default function parseAdaptationSets(
 
     const priority = adaptation.attributes.selectionPriority ?? 1;
     const originalID = adaptation.attributes.id;
-    let newID : string;
     const adaptationSetSwitchingIDs = getAdaptationSetSwitchingIDs(adaptation);
     const parentSegmentTemplates = [];
     if (context.segmentTemplate !== undefined) {
@@ -354,161 +344,136 @@ export default function parseAdaptationSets(
 
     const isTrickModeTrack = trickModeAttachedAdaptationIds !== undefined;
 
-    if (type === "video" &&
-        isMainAdaptation &&
-        lastMainVideoAdapIdx >= 0 &&
-        parsedAdaptations.video.length > lastMainVideoAdapIdx &&
-        !isTrickModeTrack)
+    const { accessibilities } = adaptationChildren;
+
+    let isDub : boolean|undefined;
+    if (roles !== undefined &&
+        roles.some((role) => role.value === "dub"))
     {
-      const videoMainAdaptation = parsedAdaptations.video[lastMainVideoAdapIdx][0];
-      reprCtxt.unsafelyBaseOnPreviousAdaptation = context
-        .unsafelyBaseOnPreviousPeriod?.getAdaptation(videoMainAdaptation.id) ?? null;
-      const representations = parseRepresentations(representationsIR,
-                                                   adaptation,
-                                                   reprCtxt);
-      videoMainAdaptation.representations.push(...representations);
-      newID = videoMainAdaptation.id;
-    } else {
-      const { accessibilities } = adaptationChildren;
+      isDub = true;
+    }
 
-      let isDub : boolean|undefined;
-      if (roles !== undefined &&
-          roles.some((role) => role.value === "dub"))
-      {
-        isDub = true;
-      }
+    let isClosedCaption;
+    if (type !== "text") {
+      isClosedCaption = false;
+    } else {
+      isClosedCaption = isCaptionning(accessibilities, roles);
+    }
 
-      let isClosedCaption;
-      if (type !== "text") {
-        isClosedCaption = false;
-      } else {
-        isClosedCaption = isCaptionning(accessibilities, roles);
-      }
+    let isForcedSubtitle;
+    if (type === "text" &&
+        roles !== undefined &&
+        roles.some((role) => role.value === "forced-subtitle" ||
+                             role.value === "forced_subtitle"))
+    {
+      isForcedSubtitle = true;
+    }
 
-      let isForcedSubtitle;
-      if (type === "text" &&
-          roles !== undefined &&
-          roles.some((role) => role.value === "forced-subtitle" ||
-                               role.value === "forced_subtitle"))
-      {
-        isForcedSubtitle = true;
-      }
+    let isAudioDescription;
+    if (type !== "audio") {
+      isAudioDescription = false;
+    } else if (accessibilities !== undefined) {
+      isAudioDescription = accessibilities.some(isVisuallyImpaired);
+    }
 
-      let isAudioDescription;
-      if (type !== "audio") {
-        isAudioDescription = false;
-      } else if (accessibilities !== undefined) {
-        isAudioDescription = accessibilities.some(isVisuallyImpaired);
-      }
+    let isSignInterpreted;
+    if (type !== "video") {
+      isSignInterpreted = false;
+    } else if (accessibilities !== undefined) {
+      isSignInterpreted = accessibilities.some(hasSignLanguageInterpretation);
+    }
 
-      let isSignInterpreted;
-      if (type !== "video") {
-        isSignInterpreted = false;
-      } else if (accessibilities !== undefined) {
-        isSignInterpreted = accessibilities.some(hasSignLanguageInterpretation);
-      }
+    let adaptationID = getAdaptationID(adaptation,
+                                       { isAudioDescription,
+                                         isForcedSubtitle,
+                                         isClosedCaption,
+                                         isSignInterpreted,
+                                         isTrickModeTrack,
+                                         type });
+
+    // Avoid duplicate IDs
+    while (arrayIncludes(parsedAdaptationsIDs, adaptationID)) {
+      adaptationID += "-dup";
+    }
 
-      let adaptationID = getAdaptationID(adaptation,
-                                         { isAudioDescription,
-                                           isForcedSubtitle,
-                                           isClosedCaption,
-                                           isSignInterpreted,
-                                           isTrickModeTrack,
-                                           type });
-
-      // Avoid duplicate IDs
-      while (arrayIncludes(parsedAdaptationsIDs, adaptationID)) {
-        adaptationID += "-dup";
-      }
+    const newID = adaptationID;
+    parsedAdaptationsIDs.push(adaptationID);
+
+    reprCtxt.unsafelyBaseOnPreviousAdaptation = context
+      .unsafelyBaseOnPreviousPeriod?.getAdaptation(adaptationID) ?? null;
+
+    const representations = parseRepresentations(representationsIR,
+                                                 adaptation,
+                                                 reprCtxt);
+    const parsedAdaptationSet : IParsedAdaptation =
+      { id: adaptationID,
+        representations,
+        type,
+        isTrickModeTrack };
+    if (adaptation.attributes.language != null) {
+      parsedAdaptationSet.language = adaptation.attributes.language;
+    }
+    if (isClosedCaption != null) {
+      parsedAdaptationSet.closedCaption = isClosedCaption;
+    }
+    if (isAudioDescription != null) {
+      parsedAdaptationSet.audioDescription = isAudioDescription;
+    }
+    if (isDub === true) {
+      parsedAdaptationSet.isDub = true;
+    }
+    if (isForcedSubtitle !== undefined) {
+      parsedAdaptationSet.forcedSubtitles = isForcedSubtitle;
+    }
+    if (isSignInterpreted === true) {
+      parsedAdaptationSet.isSignInterpreted = true;
+    }
 
-      newID = adaptationID;
-      parsedAdaptationsIDs.push(adaptationID);
-
-      reprCtxt.unsafelyBaseOnPreviousAdaptation = context
-        .unsafelyBaseOnPreviousPeriod?.getAdaptation(adaptationID) ?? null;
-
-      const representations = parseRepresentations(representationsIR,
-                                                   adaptation,
-                                                   reprCtxt);
-      const parsedAdaptationSet : IParsedAdaptation =
-        { id: adaptationID,
-          representations,
-          type,
-          isTrickModeTrack };
-      if (adaptation.attributes.language != null) {
-        parsedAdaptationSet.language = adaptation.attributes.language;
-      }
-      if (isClosedCaption != null) {
-        parsedAdaptationSet.closedCaption = isClosedCaption;
-      }
-      if (isAudioDescription != null) {
-        parsedAdaptationSet.audioDescription = isAudioDescription;
-      }
-      if (isDub === true) {
-        parsedAdaptationSet.isDub = true;
-      }
-      if (isForcedSubtitle !== undefined) {
-        parsedAdaptationSet.forcedSubtitles = isForcedSubtitle;
-      }
-      if (isSignInterpreted === true) {
-        parsedAdaptationSet.isSignInterpreted = true;
-      }
+    if (label !== undefined) {
+      parsedAdaptationSet.label = label;
+    }
 
-      if (label !== undefined) {
-        parsedAdaptationSet.label = label;
-      }
+    if (trickModeAttachedAdaptationIds !== undefined) {
+      trickModeAdaptations.push({ adaptation: parsedAdaptationSet,
+                                  trickModeAttachedAdaptationIds });
+    } else {
 
-      if (trickModeAttachedAdaptationIds !== undefined) {
-        trickModeAdaptations.push({ adaptation: parsedAdaptationSet,
-                                    trickModeAttachedAdaptationIds });
-      } else {
-
-        // look if we have to merge this into another Adaptation
-        let mergedIntoIdx = -1;
-        for (const id of adaptationSetSwitchingIDs) {
-          const switchingInfos = adaptationSwitchingInfos[id];
-          if (switchingInfos !== undefined &&
-              switchingInfos.newID !== newID &&
-              arrayIncludes(switchingInfos.adaptationSetSwitchingIDs, originalID))
+      // look if we have to merge this into another Adaptation
+      let mergedIntoIdx = -1;
+      for (const id of adaptationSetSwitchingIDs) {
+        const switchingInfos = adaptationSwitchingInfos[id];
+        if (switchingInfos !== undefined &&
+            switchingInfos.newID !== newID &&
+            arrayIncludes(switchingInfos.adaptationSetSwitchingIDs, originalID))
+        {
+          mergedIntoIdx = arrayFindIndex(parsedAdaptations[type],
+                                         (a) => a[0].id === id);
+          const mergedInto = parsedAdaptations[type][mergedIntoIdx];
+          if (mergedInto !== undefined &&
+              mergedInto[0].audioDescription ===
+                parsedAdaptationSet.audioDescription &&
+              mergedInto[0].closedCaption ===
+                parsedAdaptationSet.closedCaption &&
+              mergedInto[0].language === parsedAdaptationSet.language)
           {
-            mergedIntoIdx = arrayFindIndex(parsedAdaptations[type],
-                                           (a) => a[0].id === id);
-            const mergedInto = parsedAdaptations[type][mergedIntoIdx];
-            if (mergedInto !== undefined &&
-                mergedInto[0].audioDescription ===
-                  parsedAdaptationSet.audioDescription &&
-                mergedInto[0].closedCaption ===
-                  parsedAdaptationSet.closedCaption &&
-                mergedInto[0].language === parsedAdaptationSet.language)
-            {
-              log.info("DASH Parser: merging \"switchable\" AdaptationSets",
-                       originalID, id);
-              mergedInto[0].representations.push(...parsedAdaptationSet.representations);
-              if (type === "video" &&
-                  isMainAdaptation &&
-                  !mergedInto[1].isMainAdaptation)
-              {
-                lastMainVideoAdapIdx = Math.max(lastMainVideoAdapIdx, mergedIntoIdx);
-              }
-              mergedInto[1] = {
-                priority: Math.max(priority, mergedInto[1].priority),
-                isMainAdaptation: isMainAdaptation ||
-                                  mergedInto[1].isMainAdaptation,
-                indexInMpd: Math.min(adaptationIdx, mergedInto[1].indexInMpd),
-              };
-            }
+            log.info("DASH Parser: merging \"switchable\" AdaptationSets",
+                     originalID, id);
+            mergedInto[0].representations.push(...parsedAdaptationSet.representations);
+            mergedInto[1] = {
+              priority: Math.max(priority, mergedInto[1].priority),
+              isMainAdaptation: isMainAdaptation ||
+                                mergedInto[1].isMainAdaptation,
+              indexInMpd: Math.min(adaptationIdx, mergedInto[1].indexInMpd),
+            };
           }
         }
+      }
 
-        if (mergedIntoIdx < 0) {
-          parsedAdaptations[type].push([ parsedAdaptationSet,
-                                         { priority,
-                                           isMainAdaptation,
-                                           indexInMpd: adaptationIdx }]);
-          if (type === "video" && isMainAdaptation) {
-            lastMainVideoAdapIdx = parsedAdaptations.video.length - 1;
-          }
-        }
+      if (mergedIntoIdx < 0) {
+        parsedAdaptations[type].push([ parsedAdaptationSet,
+                                       { priority,
+                                         isMainAdaptation,
+                                         indexInMpd: adaptationIdx }]);
       }
     }
 

package/src/parsers/manifest/dash/common/parse_representations.ts

@@ -66,16 +66,17 @@ function combineInbandEventStreams(
  */
 function getHDRInformation(
   { adaptationProfiles,
+    essentialProperties,
+    supplementalProperties,
     manifestProfiles,
     codecs,
   }: { adaptationProfiles?: string | undefined;
+       essentialProperties? : IScheme[] | undefined;
+       supplementalProperties? : IScheme[] | undefined;
        manifestProfiles?: string | undefined;
        codecs?: string | undefined; }
 ): undefined | IHDRInformation {
   const profiles = (adaptationProfiles ?? "") + (manifestProfiles ?? "");
-  if (codecs === undefined) {
-    return undefined;
-  }
   if (
     profiles.indexOf(
       "http://dashif.org/guidelines/dash-if-uhd#hevc-hdr-pq10") !== -1
@@ -87,7 +88,20 @@ function getHDRInformation(
                colorSpace: "rec2020" };
     }
   }
-  if (/^vp(08|09|10)/.exec(codecs)) {
+  const transferCharacteristicScheme = arrayFind(
+    [...(essentialProperties ?? []), ...(supplementalProperties ?? [])],
+    (p) => p.schemeIdUri === "urn:mpeg:mpegB:cicp:TransferCharacteristics");
+  if (transferCharacteristicScheme !== undefined) {
+    switch (transferCharacteristicScheme.value) {
+      case "15":
+        return undefined; // SDR
+      case "16":
+        return { eotf: "pq" };
+      case "18":
+        return { eotf: "hlg" };
+    }
+  }
+  if (codecs !== undefined && /^vp(08|09|10)/.exec(codecs)) {
     return getWEBMHDRInformation(codecs);
   }
 }
@@ -273,6 +287,9 @@ export default function parseRepresentations(
 
     parsedRepresentation.hdrInfo =
       getHDRInformation({ adaptationProfiles: adaptation.attributes.profiles,
+                          supplementalProperties: adaptation.children
+                            .supplementalProperties,
+                          essentialProperties: adaptation.children.essentialProperties,
                           manifestProfiles: context.manifestProfiles,
                           codecs });
 

package/src/parsers/manifest/dash/js-parser/parse_from_document.ts

@@ -32,7 +32,7 @@ import {
 
 /**
  * Parse MPD through the JS parser, on a `Document` instance.
- * @param {Document} manifest - Original manifest as returned by the server
+ * @param {Document} document - Original manifest as returned by the server
  * @param {Object} args - Various parsing options and information.
  * @returns {Object} - Response returned by the DASH-JS parser.
  */

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -199,6 +199,7 @@ export default class DashWasmParser {
                                                "Unknown error";
         log.warn("DW: Could not create DASH-WASM parser:", message);
         this.status = "failure";
+        throw err;
       });
 
     return this._initProm;

package/src/parsers/texttracks/ttml/parse_ttml.ts

@@ -95,7 +95,7 @@ export default function parseTTMLString(
 
   if (xml !== null && xml !== undefined) {
     const tts = xml.getElementsByTagName("tt");
-    let tt = tts[0];
+    let tt: Element = tts[0];
     if (tt === undefined) {
       // EBU-TT sometimes namespaces tt, by "tt:"
       // Just catch all namespaces to play it safe

package/src/public_types.ts

@@ -22,6 +22,7 @@ import {
   IPersistentSessionInfoV4,
 } from "./core/decrypt";
 import {
+  IMediaErrorTrackContext,
   EncryptedMediaError,
   MediaError,
   NetworkError,
@@ -31,6 +32,8 @@ import Manifest from "./manifest";
 import { ILocalManifest } from "./parsers/manifest/local";
 import { IMetaPlaylist } from "./parsers/manifest/metaplaylist/metaplaylist_parser";
 
+export { IMediaErrorTrackContext };
+
 /**
  * This file defines and exports types we want to expose to library users.
  * Those types are considered as part of the API.
@@ -693,6 +696,8 @@ export interface IAudioRepresentation {
   id : string|number;
   bitrate? : number | undefined;
   codec? : string | undefined;
+  isCodecSupported? : boolean | undefined;
+  seemsDecipherable? : boolean | undefined;
 }
 
 /** Audio track returned by the RxPlayer. */
@@ -720,7 +725,7 @@ export interface ITextTrack {
    * Kept equal to `language` if the attempt failed.
    */
   normalized : string;
-  forced? : boolean | undefined;
+  forced : boolean | undefined;
   closedCaption : boolean;
   label? : string | undefined;
   id : number|string;
@@ -738,6 +743,8 @@ export interface IVideoRepresentation {
   codec? : string | undefined;
   frameRate? : number | undefined;
   hdrInfo?: IHDRInformation | undefined;
+  isCodecSupported? : boolean | undefined;
+  seemsDecipherable? : boolean | undefined;
 }
 
 /** Video track returned by the RxPlayer. */
@@ -916,6 +923,14 @@ export interface ITrackUpdateEventPayload {
            "manual" | // Manually and explicitely updated
            "trickmode-enabled" | // Video trickmode tracks being enabled
            "trickmode-disabled" | // Video trickmode tracks being disabled
+           "no-playable-representation" | // Previous track had no playable Representation
+           string;
+}
+
+export interface IRepresentationListUpdateContext {
+  period : IPeriod;
+  trackType : ITrackType;
+  reason : "decipherability-update" |
            string;
 }
 

package/src/tools/TextTrackRenderer/text_track_renderer.ts

@@ -79,7 +79,7 @@ export default class TextTrackRenderer {
       args.timeOffset :
       0;
     this._segmentBuffer.pushChunkSync({ inventoryInfos: null,
-                                        data: { initSegment: null,
+                                        data: { initSegmentUniqueId: null,
                                                 codec: args.type,
                                                 timestampOffset,
                                                 appendWindow: [0, Infinity],

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -31,11 +31,9 @@ export default function addSegmentIntegrityChecks<T>(
 ) : ISegmentLoader<T> {
   return (url, context, loaderOptions, initialCancelSignal, callbacks) => {
     return new Promise((resolve, reject) => {
-      const requestCanceller = new TaskCanceller({ cancelOn: initialCancelSignal });
-
-      // Reject the `CancellationError` when `requestCanceller`'s signal emits
-      // `stopRejectingOnCancel` here is a function allowing to stop this mechanism
-      const stopRejectingOnCancel = requestCanceller.signal.register(reject);
+      const requestCanceller = new TaskCanceller();
+      const unlinkCanceller = requestCanceller.linkToSignal(initialCancelSignal);
+      requestCanceller.signal.register(reject);
 
       segmentLoader(url, context, loaderOptions, requestCanceller.signal, {
         ...callbacks,
@@ -45,31 +43,42 @@ export default function addSegmentIntegrityChecks<T>(
             callbacks.onNewChunk(data);
           } catch (err) {
             // Do not reject with a `CancellationError` after cancelling the request
-            stopRejectingOnCancel();
+            cleanUpCancellers();
+
             // Cancel the request
             requestCanceller.cancel();
+
             // Reject with thrown error
             reject(err);
           }
         },
-      }).then((info) => {
-        if (requestCanceller.isUsed) {
-          return;
-        }
-        stopRejectingOnCancel();
-        if (info.resultType === "segment-loaded") {
-          try {
-            trowOnIntegrityError(info.resultData.responseData);
-          } catch (err) {
+      })
+        .then(
+          (info) => {
+            cleanUpCancellers();
+            if (requestCanceller.isUsed()) {
+              return;
+            }
+            if (info.resultType === "segment-loaded") {
+              try {
+                trowOnIntegrityError(info.resultData.responseData);
+              } catch (err) {
+                reject(err);
+                return;
+              }
+            }
+            resolve(info);
+          },
+          (err : unknown) => {
+            cleanUpCancellers();
             reject(err);
-            return;
           }
-        }
-        resolve(info);
-      }, (error : unknown) => {
-        stopRejectingOnCancel();
-        reject(error);
-      });
+        );
+
+      function cleanUpCancellers() {
+        requestCanceller.signal.deregister(reject);
+        unlinkCanceller();
+      }
     });
 
     /**