rx-player 3.27.0-dev.2022032100 → 3.27.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.27.0-dev.2022032100",
+  "version": "3.27.0",
   "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.0-dev.2022032100
+sonar.projectVersion=3.27.0
 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/compat/eme/custom_media_keys/old_webkit_media_keys.ts

@@ -66,7 +66,6 @@ class OldWebkitMediaKeySession
   private readonly _vid: IOldWebkitHTMLMediaElement;
   private readonly _key: string;
 
-  private readonly _onSessionRelatedEvent : (evt : Event) => void;
   private _closeSession : () => void;
 
   constructor(mediaElement: IOldWebkitHTMLMediaElement, keySystem: string) {
@@ -76,18 +75,29 @@ class OldWebkitMediaKeySession
 
     this.sessionId = "";
     this._closeSession = noop; // Just here to make TypeScript happy
-    this.closed = new Promise((resolve) => {
-      this._closeSession = resolve;
-    });
     this.keyStatuses = new Map();
     this.expiration = NaN;
 
-    this._onSessionRelatedEvent = (evt : Event) => {
+    const onSessionRelatedEvent = (evt : Event) => {
       this.trigger(evt.type, evt);
     };
+    this.closed = new Promise((resolve) => {
+      this._closeSession = () => {
+        ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+          .forEach(evt => {
+            mediaElement.removeEventListener(evt, onSessionRelatedEvent);
+            mediaElement.removeEventListener(`webkit${evt}`, onSessionRelatedEvent);
+          });
+        resolve();
+      };
+    });
+
 
     ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-      .forEach(evt => mediaElement.addEventListener(evt, this._onSessionRelatedEvent));
+      .forEach(evt => {
+        mediaElement.addEventListener(evt, onSessionRelatedEvent);
+        mediaElement.addEventListener(`webkit${evt}`, onSessionRelatedEvent);
+      });
   }
 
   public update(license: Uint8Array) : Promise<void> {
@@ -128,7 +138,6 @@ class OldWebkitMediaKeySession
 
   public close(): Promise<void> {
     return new Promise((resolve) => {
-      this._unbindSession();
       this._closeSession();
       resolve();
     });
@@ -147,11 +156,6 @@ class OldWebkitMediaKeySession
   public remove(): Promise<void> {
     return Promise.resolve();
   }
-
-  private _unbindSession() {
-    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-      .forEach(evt => this._vid.removeEventListener(evt, this._onSessionRelatedEvent));
-  }
 }
 
 class OldWebKitCustomMediaKeys implements ICustomMediaKeys {

package/src/compat/eme/custom_media_keys/webkit_media_keys.ts

@@ -83,7 +83,6 @@ class WebkitMediaKeySession
   private _nativeSession: undefined | MediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
-  private readonly _onEvent : (evt : Event) => void;
   private _closeSession : () => void;
   private _unbindSession : () => void;
 
@@ -109,10 +108,6 @@ class WebkitMediaKeySession
     });
     this.keyStatuses = new Map();
     this.expiration = NaN;
-
-    this._onEvent = (evt : Event) => {
-      this.trigger(evt.type, evt);
-    };
   }
 
   public update(license: BufferSource) : Promise<void> {
@@ -124,9 +119,17 @@ class WebkitMediaKeySession
         return reject("Unavailable WebKit key session.");
       }
       try {
+        let uInt8Arraylicense: Uint8Array;
+        if (license instanceof ArrayBuffer) {
+          uInt8Arraylicense = new Uint8Array(license);
+        } else if (license instanceof Uint8Array) {
+          uInt8Arraylicense = license;
+        } else {
+          uInt8Arraylicense = new Uint8Array(license.buffer);
+        }
         /* eslint-disable @typescript-eslint/no-unsafe-member-access */
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        resolve(this._nativeSession.update(license));
+        resolve(this._nativeSession.update(uInt8Arraylicense));
         /* eslint-enable @typescript-eslint/no-unsafe-member-access */
       } catch (err) {
         reject(err);
@@ -202,15 +205,25 @@ class WebkitMediaKeySession
   private _listenEvent(session: MediaKeySession) : void {
     this._unbindSession(); // If previous session was linked
 
+    const onEvent = (evt : Event) => {
+      this.trigger(evt.type, evt);
+    };
+
     /* eslint-disable @typescript-eslint/no-unsafe-call */
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     /* eslint-disable @typescript-eslint/no-unsafe-return */
     ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-      .forEach(evt => session.addEventListener(evt, this._onEvent));
+      .forEach(evt => {
+        session.addEventListener(evt, onEvent);
+        session.addEventListener(`webkit${evt}`, onEvent);
+      });
 
     this._unbindSession = () => {
       ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-        .forEach(evt => session.removeEventListener(evt, this._onEvent));
+        .forEach(evt => {
+          session.removeEventListener(evt, onEvent);
+          session.removeEventListener(`webkit${evt}`, onEvent);
+        });
     };
     /* eslint-disable @typescript-eslint/no-unsafe-return */
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */

package/src/compat/eme/generate_key_request.ts

@@ -124,12 +124,10 @@ export function patchInitData(initData : Uint8Array) : Uint8Array {
  * Generate a request from session.
  * @param {MediaKeySession} session - MediaKeySession on which the request will
  * be done.
- * @param {Uint8Array} initData - Initialization data given e.g. by the
- * "encrypted" event for the corresponding request.
- * @param {string} initDataType - Initialization data type given e.g. by the
- * "encrypted" event for the corresponding request.
- * @param {string} sessionType - Type of session you want to generate. Consult
- * EME Specification for more information on session types.
+ * @param {string} initializationDataType - Initialization data type given e.g.
+ * by the "encrypted" event for the corresponding request.
+ * @param {Uint8Array} initializationData - Initialization data given e.g. by
+ * the "encrypted" event for the corresponding request.
  * @returns {Promise} - Emit when done. Errors if fails.
  */
 export default function generateKeyRequest(

package/src/compat/get_start_date.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+/**
+ * Calculating a live-offseted media position necessitate to obtain first an
+ * offset, and then adding that offset to the wanted position.
+ *
+ * That offset is in most case present inside the Manifest file, yet in cases
+ * without it or without a Manifest, such as the "directfile" mode, the RxPlayer
+ * won't know that offset.
+ *
+ * Thankfully Safari declares a `getStartDate` method allowing to obtain that
+ * offset when available. This logic is mainly useful when playing HLS contents
+ * in directfile mode on Safari.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {number|undefined}
+ */
+export default function getStartDate(
+  mediaElement : HTMLMediaElement
+) : number | undefined {
+  const _mediaElement : HTMLMediaElement & {
+    getStartDate? : () => number | Date | null | undefined;
+  } = mediaElement;
+  if (typeof _mediaElement.getStartDate === "function") {
+    const startDate = _mediaElement.getStartDate();
+    if (typeof startDate === "object" && startDate !== null) {
+      const startDateNum = +startDate;
+      if (!isNaN(startDateNum)) {
+        return startDateNum / 1000;
+      }
+    } else if (typeof startDate === "number" && !isNaN(startDate)) {
+      return startDate;
+    }
+  }
+}

package/src/compat/index.ts

@@ -44,6 +44,7 @@ import {
   isFullscreen,
   requestFullscreen,
 } from "./fullscreen";
+import getStartDate from "./get_start_date";
 import hasEMEAPIs from "./has_eme_apis";
 import isCodecSupported from "./is_codec_supported";
 import isNode from "./is_node";
@@ -79,6 +80,7 @@ export {
   exitFullscreen,
   generateKeyRequest,
   getInitData,
+  getStartDate,
   hasEMEAPIs,
   ICompatTextTrack,
   ICompatVTTCue,

package/src/core/api/public_api.ts

@@ -46,6 +46,7 @@ import {
 import {
   events,
   exitFullscreen,
+  getStartDate,
   isFullscreen,
   requestFullscreen,
 } from "../../compat";
@@ -427,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.0-dev.2022032100";
+    this.version = /* PLAYER_VERSION */"3.27.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -1276,24 +1277,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     const { isDirectFile, manifest } = this._priv_contentInfos;
     if (isDirectFile) {
-      // Calculating the "wall-clock time" necessitate to obtain first an offset,
-      // and then adding that offset to the HTMLMediaElement's current position.
-      // That offset is in most case present inside the Manifest file, yet in
-      // directfile mode, the RxPlayer won't parse that file, the browser does it.
-      //
-      // Thankfully Safari declares a `getStartDate` method allowing to obtain
-      // that offset when available. This logic is thus mainly useful when
-      // playing HLS contents in directfile mode on Safari.
-      const mediaElement : HTMLMediaElement & {
-        getStartDate? : () => number | null | undefined;
-      } = this.videoElement;
-      if (typeof mediaElement.getStartDate === "function") {
-        const startDate = mediaElement.getStartDate();
-        if (typeof startDate === "number" && !isNaN(startDate)) {
-          return startDate + mediaElement.currentTime;
-        }
-      }
-      return mediaElement.currentTime;
+      const startDate = getStartDate(this.videoElement);
+      return (startDate ?? 0) + this.videoElement.currentTime;
     }
     if (manifest !== null) {
       const currentTime = this.videoElement.currentTime;
@@ -1596,12 +1581,19 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       } else if (!isNullOrUndefined(timeObj.position)) {
         positionWanted = timeObj.position;
       } else if (!isNullOrUndefined(timeObj.wallClockTime)) {
-        positionWanted = (isDirectFile || manifest === null) ?
-          timeObj.wallClockTime :
-          timeObj.wallClockTime - (
-            manifest.availabilityStartTime !== undefined ?
-              manifest.availabilityStartTime :
-              0);
+        if (manifest !== null) {
+          positionWanted = timeObj.wallClockTime - (
+            manifest.availabilityStartTime ?? 0
+          );
+        } else if (isDirectFile && this.videoElement !== null) {
+          const startDate = getStartDate(this.videoElement);
+          if (startDate !== undefined) {
+            positionWanted = timeObj.wallClockTime - startDate;
+          }
+        }
+        if (positionWanted === undefined) {
+          positionWanted = timeObj.wallClockTime;
+        }
       } else {
         throw new Error("invalid time object. You must set one of the " +
                         "following properties: \"relative\", \"position\" or " +
@@ -2893,8 +2885,12 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       const ast = manifest.availabilityStartTime ?? 0;
       positionData.wallClockTime = observation.position + ast;
       positionData.liveGap = maximumPosition - observation.position;
+    } else if (isDirectFile && this.videoElement !== null) {
+      const startDate = getStartDate(this.videoElement);
+      if (startDate !== undefined) {
+        positionData.wallClockTime = startDate + observation.position;
+      }
     }
-
     this.trigger("positionUpdate", positionData);
   }
 
@@ -2946,7 +2942,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.27.0-dev.2022032100";
+Player.version = /* PLAYER_VERSION */"3.27.0";
 
 /** Payload emitted with a `positionUpdate` event. */
 export interface IPositionUpdateItem {

package/src/core/decrypt/content_decryptor.ts

@@ -16,7 +16,6 @@
 
 import {
   events,
-  generateKeyRequest,
   getInitData,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
@@ -567,10 +566,22 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     if (sessionRes.type === MediaKeySessionLoadingType.Created) {
       const requestData = initializationData.values.constructRequestData();
       try {
-        await generateKeyRequest(mediaKeySession,
-                                 initializationData.type,
-                                 requestData);
+        await stores.loadedSessionsStore.generateLicenseRequest(
+          mediaKeySession,
+          initializationData.type,
+          requestData);
       } catch (error) {
+        // First check that the error was not due to the MediaKeySession closing
+        // or being closed
+        const entry = stores.loadedSessionsStore.getEntryForSession(mediaKeySession);
+        if (entry === null || entry.closingStatus.type !== "none") {
+          // MediaKeySession closing/closed: Just remove from handled list and abort.
+          const indexInCurrent = this._currentSessions.indexOf(sessionInfo);
+          if (indexInCurrent >= 0) {
+            this._currentSessions.splice(indexInCurrent, 1);
+          }
+          return Promise.resolve();
+        }
         throw new EncryptedMediaError("KEY_GENERATE_REQUEST_ERROR",
                                       error instanceof Error ? error.toString() :
                                       "Unknown error");

package/src/core/decrypt/create_or_load_session.ts

@@ -88,7 +88,10 @@ export default async function createOrLoadSession(
     throw cancelSignal.cancellationError; // stop here if cancelled since
   }
 
-  const evt = await createSession(stores, initializationData, wantedSessionType);
+  const evt = await createSession(stores,
+                                  initializationData,
+                                  wantedSessionType,
+                                  cancelSignal);
   return { type: evt.type,
            value: { mediaKeySession: evt.value.mediaKeySession,
                     sessionType: evt.value.sessionType,

package/src/core/decrypt/create_session.ts

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  ICustomMediaKeySession,
-  loadSession,
-} from "../../compat";
+import { ICustomMediaKeySession } from "../../compat";
 import log from "../../log";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   IProcessedProtectionData,
   IMediaKeySessionStores,
@@ -42,12 +40,14 @@ import PersistentSessionsStore from "./utils/persistent_sessions_store";
  * @param {Object} stores
  * @param {Object} initData
  * @param {string} wantedSessionType
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
 export default function createSession(
   stores : IMediaKeySessionStores,
   initData : IProcessedProtectionData,
-  wantedSessionType : MediaKeySessionType
+  wantedSessionType : MediaKeySessionType,
+  cancelSignal : CancellationSignal
 ) : Promise<ICreateSessionEvent> {
   const { loadedSessionsStore,
           persistentSessionsStore } = stores;
@@ -61,7 +61,8 @@ export default function createSession(
   }
   return createAndTryToRetrievePersistentSession(loadedSessionsStore,
                                                  persistentSessionsStore,
-                                                 initData);
+                                                 initData,
+                                                 cancelSignal);
 }
 
 /**
@@ -87,13 +88,18 @@ function createTemporarySession(
  * @param {Object} loadedSessionsStore
  * @param {Object} persistentSessionsStore
  * @param {Object} initData
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
 async function createAndTryToRetrievePersistentSession(
   loadedSessionsStore : LoadedSessionsStore,
   persistentSessionsStore : PersistentSessionsStore,
-  initData : IProcessedProtectionData
+  initData : IProcessedProtectionData,
+  cancelSignal : CancellationSignal
 ) : Promise<INewSessionCreatedEvent | IPersistentSessionRecoveryEvent> {
+  if (cancelSignal.cancellationError !== null) {
+    throw cancelSignal.cancellationError;
+  }
   log.info("DRM: Creating persistent MediaKeySession");
 
   const entry = loadedSessionsStore.createSession(initData, "persistent-license");
@@ -104,8 +110,10 @@ async function createAndTryToRetrievePersistentSession(
   }
 
   try {
-    const hasLoadedSession = await loadSession(entry.mediaKeySession,
-                                               storedEntry.sessionId);
+    const hasLoadedSession = await loadedSessionsStore.loadPersistentSession(
+      entry.mediaKeySession,
+      storedEntry.sessionId
+    );
     if (!hasLoadedSession) {
       log.warn("DRM: No data stored for the loaded session");
       persistentSessionsStore.delete(storedEntry.sessionId);
@@ -136,6 +144,9 @@ async function createAndTryToRetrievePersistentSession(
    * @returns {Observable}
    */
   async function recreatePersistentSession() : Promise<INewSessionCreatedEvent> {
+    if (cancelSignal.cancellationError !== null) {
+      throw cancelSignal.cancellationError;
+    }
     log.info("DRM: Removing previous persistent session.");
     const persistentEntry = persistentSessionsStore.get(initData);
     if (persistentEntry !== null) {
@@ -143,6 +154,9 @@ async function createAndTryToRetrievePersistentSession(
     }
 
     await loadedSessionsStore.closeSession(entry.mediaKeySession);
+    if (cancelSignal.cancellationError !== null) {
+      throw cancelSignal.cancellationError;
+    }
     const newEntry = loadedSessionsStore.createSession(initData,
                                                        "persistent-license");
     return { type: MediaKeySessionLoadingType.Created,