rx-player 3.27.1-dev.2022041500 → 3.27.1-dev.2022051100

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.27.1-dev.2022041500",
+  "version": "3.27.1-dev.2022051100",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.27.1-dev.2022041500
+sonar.projectVersion=3.27.1-dev.2022051100
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/core/api/public_api.ts

@@ -428,7 +428,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.27.1-dev.2022041500";
+    this.version = /* PLAYER_VERSION */"3.27.1-dev.2022051100";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -2940,7 +2940,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.27.1-dev.2022041500";
+Player.version = /* PLAYER_VERSION */"3.27.1-dev.2022051100";
 
 /** Payload emitted with a `positionUpdate` event. */
 export interface IPositionUpdateItem {

package/src/core/decrypt/content_decryptor.ts

@@ -780,16 +780,18 @@ function updateDecipherability(
       return representation.decipherable;
     }
     const contentKIDs = representation.contentProtections.keyIds;
-    for (let i = 0; i < contentKIDs.length; i++) {
-      const elt = contentKIDs[i];
-      for (let j = 0; j < blacklistedKeyIDs.length; j++) {
-        if (areKeyIdsEqual(blacklistedKeyIDs[j], elt.keyId)) {
-          return false;
+    if (contentKIDs !== undefined) {
+      for (let i = 0; i < contentKIDs.length; i++) {
+        const elt = contentKIDs[i];
+        for (let j = 0; j < blacklistedKeyIDs.length; j++) {
+          if (areKeyIdsEqual(blacklistedKeyIDs[j], elt.keyId)) {
+            return false;
+          }
         }
-      }
-      for (let j = 0; j < whitelistedKeyIds.length; j++) {
-        if (areKeyIdsEqual(whitelistedKeyIds[j], elt.keyId)) {
-          return true;
+        for (let j = 0; j < whitelistedKeyIds.length; j++) {
+          if (areKeyIdsEqual(whitelistedKeyIds[j], elt.keyId)) {
+            return true;
+          }
         }
       }
     }
@@ -1157,7 +1159,7 @@ function addKeyIdsFromPeriod(
   for (const adaptation of period.getAdaptations()) {
     for (const representation of adaptation.representations) {
       if (representation.contentProtections !== undefined &&
-          representation.contentProtections.keyIds.length >= - 1)
+          representation.contentProtections.keyIds !== undefined)
       {
         for (const kidInf of representation.contentProtections.keyIds) {
           set.add(kidInf.keyId);

package/src/core/decrypt/utils/key_session_record.ts

@@ -144,7 +144,7 @@ export default class KeySessionRecord {
     initializationData : IProcessedProtectionData
   ) : boolean {
     const { keyIds } = initializationData;
-    if (keyIds !== undefined) {
+    if (keyIds !== undefined && keyIds.length > 0) {
       if (this._keyIds !== null && areAllKeyIdsContainedIn(keyIds, this._keyIds)) {
         return true;
       }
@@ -159,6 +159,7 @@ export default class KeySessionRecord {
     initializationData : IProcessedProtectionData
   ) : boolean {
     if (initializationData.keyIds !== undefined &&
+        initializationData.keyIds.length > 0 &&
         this._initializationData.keyIds !== undefined)
     {
       return areAllKeyIdsContainedIn(initializationData.keyIds,

package/src/core/init/throw_on_media_error.ts

@@ -20,6 +20,7 @@ import {
   Observable,
 } from "rxjs";
 import { MediaError } from "../../errors";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 
 /**
  * Returns an observable which throws the right MediaError as soon an "error"
@@ -32,27 +33,36 @@ export default function throwOnMediaError(
 ) : Observable<never> {
   return observableFromEvent(mediaElement, "error")
     .pipe(mergeMap(() => {
-      const errorCode = mediaElement.error == null ? 0 :
-                                                    mediaElement.error.code;
+      const mediaError = mediaElement.error;
+      let errorCode : number | undefined;
+      let errorMessage : string | undefined;
+      if (!isNullOrUndefined(mediaError)) {
+        errorCode = mediaError.code;
+        errorMessage = mediaError.message;
+      }
+
       switch (errorCode) {
         case 1:
-          throw new MediaError("MEDIA_ERR_ABORTED",
-                               "The fetching of the associated resource was aborted " +
-                               "by the user's request.");
+          errorMessage = errorMessage ??
+            "The fetching of the associated resource was aborted by the user's request.";
+          throw new MediaError("MEDIA_ERR_ABORTED", errorMessage);
         case 2:
-          throw new MediaError("MEDIA_ERR_NETWORK",
-                               "A network error occurred which prevented the media " +
-                               "from being successfully fetched");
+          errorMessage = errorMessage ??
+            "A network error occurred which prevented the media from being " +
+            "successfully fetched";
+          throw new MediaError("MEDIA_ERR_NETWORK", errorMessage);
         case 3:
-          throw new MediaError("MEDIA_ERR_DECODE",
-                               "An error occurred while trying to decode the media " +
-                               "resource");
+          errorMessage = errorMessage ??
+            "An error occurred while trying to decode the media resource";
+          throw new MediaError("MEDIA_ERR_DECODE", errorMessage);
         case 4:
-          throw new MediaError("MEDIA_ERR_SRC_NOT_SUPPORTED",
-                               "The media resource has been found to be unsuitable.");
+          errorMessage = errorMessage ??
+            "The media resource has been found to be unsuitable.";
+          throw new MediaError("MEDIA_ERR_SRC_NOT_SUPPORTED", errorMessage);
         default:
-          throw new MediaError("MEDIA_ERR_UNKNOWN",
-                               "The HTMLMediaElement errored due to an unknown reason.");
+          errorMessage = errorMessage ??
+            "The HTMLMediaElement errored due to an unknown reason.";
+          throw new MediaError("MEDIA_ERR_UNKNOWN", errorMessage);
       }
     }));
 }

package/src/manifest/representation.ts

@@ -174,7 +174,7 @@ class Representation {
       for (let j = 0; j < initData.values.length; j++) {
         if (initData.values[j].systemId.toLowerCase() === drmSystemId.toLowerCase()) {
           if (!createdObjForType) {
-            const keyIds = this.contentProtections?.keyIds.map(val => val.keyId);
+            const keyIds = this.contentProtections?.keyIds?.map(val => val.keyId);
             filtered.push({ type: initData.type,
                             keyIds,
                             values: [initData.values[j]] });
@@ -221,7 +221,7 @@ class Representation {
     {
       return [];
     }
-    const keyIds = this.contentProtections?.keyIds.map(val => val.keyId);
+    const keyIds = this.contentProtections?.keyIds?.map(val => val.keyId);
     return this.contentProtections.initData.map((x) => {
       return { type: x.type,
                keyIds,

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

@@ -62,7 +62,16 @@ export default function flattenOverlappingPeriods(
                parsedPeriod.start);
       lastFlattenedPeriod.duration = parsedPeriod.start - lastFlattenedPeriod.start;
       lastFlattenedPeriod.end = parsedPeriod.start;
-      if (lastFlattenedPeriod.duration <= 0) {
+      if (lastFlattenedPeriod.duration > 0) {
+        // Note: Calling `break` to quit the while loop should theoritically be
+        // unnecessary as the previous operations should ensure we do not re-enter
+        // the loop's condition.
+        // Yet we dit encounter infinite loops without it because of float-related
+        // rounding errors.
+        break;
+      } else {
+        // `lastFlattenedPeriod` has now a negative or `0` duration.
+        // Remove it, consider the next Period in its place, and re-start the loop.
         flattenedPeriods.pop();
         lastFlattenedPeriod = flattenedPeriods[flattenedPeriods.length - 1];
       }

package/src/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.ts

@@ -201,6 +201,9 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
   /** Absolute start of the period, timescaled and converted to index time. */
   private _scaledPeriodStart : number;
 
+  /** Actual un-scaled start of the Period as indicated in the MPD. */
+  private _periodStart : number;
+
   /** Absolute end of the period, timescaled and converted to index time. */
   private _scaledPeriodEnd : number | undefined;
 
@@ -305,6 +308,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
                     startNumber: index.startNumber,
                     timeline: index.timeline ?? null,
                     timescale };
+    this._periodStart = periodStart;
     this._scaledPeriodStart = toIndexTime(periodStart, this._index);
     this._scaledPeriodEnd = periodEnd === undefined ? undefined :
                                                       toIndexTime(periodEnd, this._index);
@@ -461,6 +465,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     this._index = newIndex._index;
     this._isDynamic = newIndex._isDynamic;
     this._scaledPeriodStart = newIndex._scaledPeriodStart;
+    this._periodStart = newIndex._periodStart;
     this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
     this._lastUpdate = newIndex._lastUpdate;
     this._manifestBoundsCalculator = newIndex._manifestBoundsCalculator;
@@ -486,6 +491,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     }
     this._isDynamic = newIndex._isDynamic;
     this._scaledPeriodStart = newIndex._scaledPeriodStart;
+    this._periodStart = newIndex._periodStart;
     this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
     this._lastUpdate = newIndex._lastUpdate;
     this._isLastPeriod = newIndex._isLastPeriod;
@@ -548,6 +554,9 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     if (this._index.timeline === null) {
       this._index.timeline = this._getTimeline();
     }
+    if (!this._isDynamic) {
+      return;
+    }
     const firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
     if (firstPosition == null) {
       return; // we don't know yet
@@ -605,12 +614,13 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
     const newElements = this._parseTimeline();
     this._parseTimeline = null; // Free memory
 
+    const actualPeriodStart = this._periodStart * this._index.timescale;
     const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config.getCurrent();
     if (this._unsafelyBaseOnPreviousIndex === null ||
         newElements.length < MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY)
     {
       // Just completely parse the current timeline
-      return constructTimelineFromElements(newElements, this._scaledPeriodStart);
+      return constructTimelineFromElements(newElements, actualPeriodStart);
     }
 
     // Construct previously parsed timeline if not already done
@@ -625,7 +635,7 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
 
     return constructTimelineFromPreviousTimeline(newElements,
                                                  prevTimeline,
-                                                 this._scaledPeriodStart);
+                                                 actualPeriodStart);
 
   }
 }

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

@@ -225,7 +225,12 @@ export default function parseRepresentations(
               .toLowerCase();
           }
           if (cp.attributes.keyId !== undefined && cp.attributes.keyId.length > 0) {
-            acc.keyIds.push({ keyId: cp.attributes.keyId, systemId });
+            const kidObj = { keyId: cp.attributes.keyId, systemId };
+            if (acc.keyIds === undefined) {
+              acc.keyIds = [kidObj];
+            } else {
+              acc.keyIds.push(kidObj);
+            }
           }
           if (systemId !== undefined) {
             const { cencPssh } = cp.children;
@@ -244,9 +249,10 @@ export default function parseRepresentations(
             }
           }
           return acc;
-        }, { keyIds: [], initData: [] });
+        }, { keyIds: undefined, initData: [] });
       if (Object.keys(contentProtections.initData).length > 0 ||
-          contentProtections.keyIds.length > 0)
+          (contentProtections.keyIds !== undefined &&
+            contentProtections.keyIds.length > 0))
       {
         parsedRepresentation.contentProtections = contentProtections;
       }

package/src/parsers/manifest/types.ts

@@ -69,8 +69,13 @@ export interface IContentProtectionInitData {
  */
 /** Describes every encryption protection parsed for a given media. */
 export interface IContentProtections {
-  /** The different encryption key IDs associated with that content. */
-  keyIds : IContentProtectionKID[];
+  /**
+   * The different encryption key IDs associated with that content.
+   *
+   * `undefined` if the key id(s) associated with that content may exist but are
+   * not known.
+   */
+  keyIds : IContentProtectionKID[] | undefined;
   /** The different encryption initialization data associated with that content. */
   initData : IContentProtectionInitData[];
 }

package/src/parsers/texttracks/ttml/html/generate_css_test_outline.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import isNonEmptyString from "../../../../utils/is_non_empty_string";
+
 /**
  * Try to replicate the textOutline TTML style property into CSS.
  *
@@ -28,8 +30,17 @@ export default function generateCSSTextOutline(
   color : string,
   thickness : string|number
 ) : string {
-  return `-1px -1px ${thickness} ${color},` +
-         `1px -1px ${thickness} ${color},` +
-         `-1px 1px ${thickness} ${color},` +
-         `1px 1px ${thickness} ${color}`;
+  let thick = thickness;
+  if (isNonEmptyString(thickness) && thickness.trim().endsWith("%")) {
+    // As em and % are basically equivalent in CSS
+    // (they both are relative to the font-size
+    // of the current element)
+    // We convert the non supported % into the supported em
+    thick = thickness.trim().slice(0, -1);
+    thick = (parseInt(thick, 10) / 100).toString() + "em";
+  }
+  return `-1px -1px ${thick} ${color},` +
+         `1px -1px ${thick} ${color},` +
+         `-1px 1px ${thick} ${color},` +
+         `1px 1px ${thick} ${color}`;
 }