rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023030200

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

@@ -271,15 +271,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;
@@ -316,7 +307,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) {
@@ -356,161 +346,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/public_types.ts

@@ -244,6 +244,7 @@ export interface IAdaptation {
   normalizedLanguage? : string | undefined;
   isAudioDescription? : boolean | undefined;
   isClosedCaption? : boolean | undefined;
+  isSignInterpreted? : boolean | undefined;
   isTrickModeTrack? : boolean | undefined;
   representations : IRepresentation[];
 

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -31,11 +31,9 @@ export default function addSegmentIntegrityChecks<T>(
 ) : ISegmentLoader<T> {
   return (url, content, 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, content, 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();
+      }
     });
 
     /**

package/src/transports/dash/low_latency_segment_loader.ts

@@ -65,14 +65,14 @@ export default function lowLatencySegmentLoader(
     partialChunk = res[1];
     for (let i = 0; i < completeChunks.length; i++) {
       callbacks.onNewChunk(completeChunks[i]);
-      if (cancelSignal.isCancelled) {
+      if (cancelSignal.isCancelled()) {
         return;
       }
     }
     callbacks.onProgress({ duration: info.duration,
                            size: info.size,
                            totalSize: info.totalSize });
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
   }

package/src/transports/dash/manifest_parser.ts

@@ -139,7 +139,7 @@ export default function generateManifestParser(
         if (parserResponse.value.warnings.length > 0) {
           onWarnings(parserResponse.value.warnings);
         }
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return Promise.reject(cancelSignal.cancellationError);
         }
         const manifest = new Manifest(parserResponse.value.parsed, options);

package/src/transports/dash/segment_loader.ts

@@ -156,7 +156,7 @@ export default function generateSegmentLoader(
                   size? : number | undefined;
                   duration? : number | undefined; }
       ) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -172,7 +172,7 @@ export default function generateSegmentLoader(
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) : void => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -198,7 +198,7 @@ export default function generateSegmentLoader(
                   size : number;
                   totalSize? : number | undefined; }
       ) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         callbacks.onProgress({ duration: _args.duration,
@@ -211,7 +211,7 @@ export default function generateSegmentLoader(
        * the "regular" implementation
        */
       const fallback = () => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;

package/src/transports/local/segment_loader.ts

@@ -20,11 +20,9 @@ import {
   ILocalManifestInitSegmentLoader,
   ILocalManifestSegmentLoader,
 } from "../../parsers/manifest/local";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import {
-  CancellationError,
-  CancellationSignal,
-} from "../../utils/task_canceller";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   ISegmentContext,
   ISegmentLoaderCallbacks,
@@ -41,7 +39,7 @@ function loadInitSegment(
   customSegmentLoader : ILocalManifestInitSegmentLoader,
   cancelSignal : CancellationSignal
 ) : Promise<ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
-  return new Promise((res, rej) => {
+  return createCancellablePromise(cancelSignal, (res, rej) => {
     /** `true` when the custom segmentLoader should not be active anymore. */
     let hasFinished = false;
 
@@ -54,11 +52,10 @@ function loadInitSegment(
       size? : number;
       duration? : number;
     }) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
       res({ resultType: "segment-loaded",
             resultData: { responseData: _args.data,
                           size: _args.size,
@@ -70,22 +67,17 @@ function loadInitSegment(
      * @param {*} err - The corresponding error encountered
      */
     const reject = (err? : Error) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
       rej(err);
     };
 
     const abort = customSegmentLoader({ resolve, reject });
 
-    cancelSignal.register(abortLoader);
-    /**
-     * The logic to run when this loader is cancelled while pending.
-     * @param {Error} err
-     */
-    function abortLoader(err : CancellationError) {
+    /** The logic to run when this loader is cancelled while pending. */
+    return () => {
       if (hasFinished) {
         return;
       }
@@ -93,8 +85,7 @@ function loadInitSegment(
       if (typeof abort === "function") {
         abort();
       }
-      rej(err);
-    }
+    };
   });
 }
 
@@ -109,7 +100,7 @@ function loadSegment(
   customSegmentLoader : ILocalManifestSegmentLoader,
   cancelSignal : CancellationSignal
 ) : Promise< ISegmentLoaderResultSegmentLoaded<ArrayBuffer | null>> {
-  return new Promise((res, rej) => {
+  return createCancellablePromise(cancelSignal, (res, rej) => {
     /** `true` when the custom segmentLoader should not be active anymore. */
     let hasFinished = false;
 
@@ -122,11 +113,10 @@ function loadSegment(
       size? : number;
       duration? : number;
     }) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
       res({ resultType: "segment-loaded",
             resultData: { responseData: _args.data,
                           size: _args.size,
@@ -138,11 +128,10 @@ function loadSegment(
      * @param {*} err - The corresponding error encountered
      */
     const reject = (err? : Error) => {
-      if (hasFinished || cancelSignal.isCancelled) {
+      if (hasFinished || cancelSignal.isCancelled()) {
         return;
       }
       hasFinished = true;
-      cancelSignal.deregister(abortLoader);
 
       // Format error and send it
       const castedErr = err as (null | undefined | { message? : string;
@@ -161,12 +150,8 @@ function loadSegment(
 
     const abort = customSegmentLoader(segment, { resolve, reject });
 
-    cancelSignal.register(abortLoader);
-    /**
-     * The logic to run when this loader is cancelled while pending.
-     * @param {Error} err
-     */
-    function abortLoader(err : CancellationError) {
+    /** The logic to run when this loader is cancelled while pending. */
+    return () => {
       if (hasFinished) {
         return;
       }
@@ -174,8 +159,7 @@ function loadSegment(
       if (typeof abort === "function") {
         abort();
       }
-      rej(err);
-    }
+    };
   });
 }
 

package/src/transports/smooth/segment_loader.ts

@@ -185,7 +185,7 @@ const generateSegmentLoader = ({
         size? : number | undefined;
         duration? : number | undefined;
       }) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -213,7 +213,7 @@ const generateSegmentLoader = ({
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -239,7 +239,7 @@ const generateSegmentLoader = ({
                   size : number;
                   totalSize? : number | undefined; }
       ) => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         callbacks.onProgress({ duration: _args.duration,
@@ -248,7 +248,7 @@ const generateSegmentLoader = ({
       };
 
       const fallback = () => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;