rx-player 3.33.0 → 3.33.1

package/src/compat/eme/close_session.ts

@@ -1,111 +0,0 @@
-/**
- * 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.
- */
-
-import log from "../../log";
-import cancellableSleep from "../../utils/cancellable_sleep";
-import TaskCanceller, {
-  CancellationError,
-} from "../../utils/task_canceller";
-import { ICustomMediaKeySession } from "./custom_media_keys";
-
-/**
- * Close the given `MediaKeySession` and returns a Promise resolving when the
- * session is closed.
- * This promise does not reject, even if we're unable to close the
- * `MediaKeySession`.
- *
- * Note that there is a lot of browser issues linked to the impossibility to
- * either close a MediaKeySession or to know if a MediaKeySession was closed.
- * Due to this, the returned Promise might take some time before resolving on
- * some devices.
- * @param {MediaKeySession|Object} session
- * @returns {Promise.<undefined>}
- */
-export default function closeSession(
-  session: MediaKeySession | ICustomMediaKeySession
-): Promise<void> {
-  const timeoutCanceller = new TaskCanceller();
-
-  return Promise.race([
-    session.close()
-      .then(() => { timeoutCanceller.cancel(); }),
-    // The `closed` promise may resolve, even if `close()` result has not
-    // (seen at some point on Firefox).
-    session.closed
-      .then(() => { timeoutCanceller.cancel(); }),
-    waitTimeoutAndCheck(),
-  ]);
-
-  /**
-   * If the session is not closed after 1000ms, try to communicate with the
-   * MediaKeySession and check if an error is returned.
-   * This is needed because on some browsers with poor EME implementation,
-   * knowing when a MediaKeySession is closed is actually a hard task.
-   *
-   * The returned Promise will never reject.
-   * @returns {Promise.<undefined>}
-   */
-  async function waitTimeoutAndCheck() : Promise<void> {
-    try {
-      await cancellableSleep(1000, timeoutCanceller.signal);
-      await tryUpdatingSession();
-    } catch (err) {
-      if (err instanceof CancellationError) { // cancelled == session closed
-        return;
-      }
-      const message = err instanceof Error ?
-        err.message :
-        "Unknown error made it impossible to close the session";
-      log.error(`DRM: ${message}`);
-    }
-  }
-
-  /**
-   * Try to update `MediaKeySession` and check its error if it failed.
-   * If we still don't know whether it closed yet, wait a second
-   * timeout then quit.
-   *
-   * The returned Promise resolves if the `MediaKeySession` seems closed and
-   * rejects if we couldn't know or it doesn't.
-   * @returns {Promise.<undefined>}
-   */
-  async function tryUpdatingSession() : Promise<void> {
-    try {
-      await session.update(new Uint8Array(1));
-    } catch (err) {
-      if (timeoutCanceller.isUsed()) { // Reminder: cancelled == session closed
-        return;
-      }
-
-      // The caught error can tell if session is closed
-      // (Chrome may throw this error)
-      // I know... Checking the error message is not the best practice ever.
-      if (err instanceof Error &&
-          err.message === "The session is already closed."
-      ) {
-        return;
-      }
-
-      await cancellableSleep(1000, timeoutCanceller.signal);
-    }
-
-    if (timeoutCanceller.isUsed()) { // Reminder: cancelled == session closed
-      return;
-    }
-
-    throw new Error("Compat: Couldn't know if session is closed");
-  }
-}

package/src/compat/eme/constants.ts

@@ -1,21 +0,0 @@
-/**
- * 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.
- */
-
-import { be4toi } from "../../utils/byte_parsing";
-import { strToUtf8 } from "../../utils/string_parsing";
-
-// The way "pssh" will be written in ISOBMFF files
-export const PSSH_TO_INTEGER : number = be4toi(strToUtf8("pssh"), 0);

package/src/compat/eme/custom_key_system_access.ts

@@ -1,67 +0,0 @@
-/**
- * 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.
- */
-import { ICustomMediaKeys } from "./custom_media_keys";
-
-// MediaKeySystemAccess implementation
-export interface ICustomMediaKeySystemAccess {
-  readonly keySystem : string;
-  getConfiguration() : MediaKeySystemConfiguration;
-  createMediaKeys() : Promise<MediaKeys|ICustomMediaKeys>;
-}
-
-/**
- * Simple implementation of the MediaKeySystemAccess EME API.
- *
- * All needed arguments are given to the constructor
- * @class CustomMediaKeySystemAccess
- */
-export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystemAccess {
-  /**
-   * @param {string} _keyType - type of key system (e.g. "widevine" or
-   * "com.widevine.alpha").
-   * @param {Object} _mediaKeys - MediaKeys implementation
-   * @param {Object} _configuration - Configuration accepted for this
-   * MediaKeySystemAccess.
-   */
-  constructor(
-    private readonly _keyType: string,
-    private readonly _mediaKeys: ICustomMediaKeys|MediaKeys,
-    private readonly _configuration: MediaKeySystemConfiguration
-  ) {}
-
-  /**
-   * @returns {string} - current key system type (e.g. "widevine" or
-   * "com.widevine.alpha").
-   */
-  get keySystem() : string {
-    return this._keyType;
-  }
-
-  /**
-   * @returns {Promise.<Object>} - Promise wrapping the MediaKeys for this
-   * MediaKeySystemAccess. Never rejects.
-   */
-  public createMediaKeys() : Promise<ICustomMediaKeys|MediaKeys> {
-    return new Promise((res) => res(this._mediaKeys));
-  }
-
-  /**
-   * @returns {Object} - Configuration accepted for this MediaKeySystemAccess.
-   */
-  public getConfiguration() : MediaKeySystemConfiguration {
-    return this._configuration;
-  }
-}

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

@@ -1,186 +0,0 @@
-/**
- * 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.
- */
-
-import EventEmitter from "../../../utils/event_emitter";
-import TaskCanceller from "../../../utils/task_canceller";
-import wrapInPromise from "../../../utils/wrapInPromise";
-import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import * as events from "../../event_listeners";
-import {
-  MSMediaKeysConstructor,
-  MSMediaKeys,
-  MSMediaKeySession,
-} from "./ms_media_keys_constructor";
-import {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
-
-class IE11MediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
-{
-  public readonly update: (license: Uint8Array) => Promise<void>;
-  public readonly closed: Promise<void>;
-  public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
-  private readonly _mk: MSMediaKeys;
-  private readonly _sessionClosingCanceller: TaskCanceller;
-  private _ss: MSMediaKeySession | undefined;
-  constructor(mk: MSMediaKeys) {
-    super();
-    this.expiration = NaN;
-    this.keyStatuses = new Map();
-    this._mk = mk;
-    this._sessionClosingCanceller = new TaskCanceller();
-    this.closed = new Promise((resolve) => {
-      this._sessionClosingCanceller.signal.register(() => resolve());
-    });
-    this.update = (license: Uint8Array) => {
-      return new Promise((resolve, reject) => {
-        if (this._ss === undefined) {
-          return reject("MediaKeySession not set.");
-        }
-        try {
-          resolve(
-            (this._ss.update as (
-              license : Uint8Array,
-              sessionId : string
-            ) => void)(license, "")
-          );
-        } catch (err) {
-          reject(err);
-        }
-      });
-    };
-  }
-  generateRequest(_initDataType: string, initData: BufferSource): Promise<void> {
-    return new Promise((resolve) => {
-      const initDataU8 =
-        initData instanceof Uint8Array  ? initData :
-        initData instanceof ArrayBuffer ? new Uint8Array(initData) :
-                                          new Uint8Array(initData.buffer);
-      this._ss = this._mk.createSession("video/mp4", initDataU8);
-      events.onKeyMessage(this._ss, (evt) => {
-        this.trigger((evt as Event).type ?? "message", evt as Event);
-      }, this._sessionClosingCanceller.signal);
-      events.onKeyAdded(this._ss, (evt) => {
-        this.trigger((evt as Event).type ?? "keyadded", evt as Event);
-      }, this._sessionClosingCanceller.signal);
-      events.onKeyError(this._ss, (evt) => {
-        this.trigger((evt as Event).type ?? "keyerror", evt as Event);
-      }, this._sessionClosingCanceller.signal);
-      resolve();
-    });
-  }
-  close(): Promise<void> {
-    return new Promise((resolve) => {
-      if (this._ss != null) {
-        this._ss.close();
-        this._ss = undefined;
-      }
-      this._sessionClosingCanceller.cancel();
-      resolve();
-    });
-  }
-  load(): Promise<boolean> {
-    return Promise.resolve(false);
-  }
-  remove(): Promise<void> {
-    return Promise.resolve();
-  }
-  get sessionId(): string {
-    return this._ss?.sessionId ?? "";
-  }
-}
-
-class IE11CustomMediaKeys implements ICustomMediaKeys {
-  private _videoElement?: ICompatHTMLMediaElement;
-  private _mediaKeys?: MSMediaKeys;
-
-  constructor(keyType: string) {
-    if (MSMediaKeysConstructor === undefined) {
-      throw new Error("No MSMediaKeys API.");
-    }
-    this._mediaKeys = new MSMediaKeysConstructor(keyType);
-  }
-
-  _setVideo(videoElement: HTMLMediaElement): Promise<unknown> {
-    return wrapInPromise(() => {
-      this._videoElement = videoElement as ICompatHTMLMediaElement;
-      if (this._videoElement.msSetMediaKeys !== undefined) {
-        this._videoElement.msSetMediaKeys(this._mediaKeys);
-      }
-    });
-  }
-
-  createSession(/* sessionType */): ICustomMediaKeySession {
-    if (this._videoElement === undefined || this._mediaKeys === undefined) {
-      throw new Error("Video not attached to the MediaKeys");
-    }
-    return new IE11MediaKeySession(this._mediaKeys);
-  }
-
-  setServerCertificate(): Promise<void> {
-    throw new Error("Server certificate is not implemented in your browser");
-  }
-}
-
-export default function getIE11MediaKeysCallbacks() : {
-  isTypeSupported: (keyType: string) => boolean;
-  createCustomMediaKeys: (keyType: string) => IE11CustomMediaKeys;
-  setMediaKeys: (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => Promise<unknown>;
-} {
-  const isTypeSupported = (keySystem: string, type?: string|null) => {
-    if (MSMediaKeysConstructor === undefined) {
-      throw new Error("No MSMediaKeys API.");
-    }
-    if (type !== undefined) {
-      return MSMediaKeysConstructor.isTypeSupported(keySystem, type);
-    }
-    return MSMediaKeysConstructor.isTypeSupported(keySystem);
-  };
-  const createCustomMediaKeys = (keyType: string) =>
-    new IE11CustomMediaKeys(keyType);
-  const setMediaKeys = (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): Promise<unknown> => {
-    if (mediaKeys === null) {
-      // msSetMediaKeys only accepts native MSMediaKeys as argument.
-      // Calling it with null or undefined will raise an exception.
-      // There is no way to unset the mediakeys in that case, so return here.
-      return Promise.resolve(undefined);
-    }
-    if (!(mediaKeys instanceof IE11CustomMediaKeys)) {
-      throw new Error("Custom setMediaKeys is supposed to be called " +
-                      "with IE11 custom MediaKeys.");
-    }
-    return mediaKeys._setVideo(elt);
-  };
-  return {
-    isTypeSupported,
-    createCustomMediaKeys,
-    setMediaKeys,
-  };
-}
-
-export { MSMediaKeysConstructor };

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

@@ -1,28 +0,0 @@
-import getIE11MediaKeysCallbacks, {
-  MSMediaKeysConstructor,
-} from "./ie11_media_keys";
-import getMozMediaKeysCallbacks, {
-  MozMediaKeysConstructor,
-} from "./moz_media_keys_constructor";
-import getOldKitWebKitMediaKeyCallbacks, {
-  isOldWebkitMediaElement,
-} from "./old_webkit_media_keys";
-import {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-} from "./types";
-import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
-import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
-
-export {
-  getIE11MediaKeysCallbacks,
-  MSMediaKeysConstructor,
-  getMozMediaKeysCallbacks,
-  MozMediaKeysConstructor,
-  getOldKitWebKitMediaKeyCallbacks,
-  isOldWebkitMediaElement,
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  getWebKitMediaKeysCallbacks,
-  WebKitMediaKeysConstructor,
-};

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

@@ -1,88 +0,0 @@
-/**
- * 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.
- */
-
-import wrapInPromise from "../../../utils/wrapInPromise";
-import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import isNode from "../../is_node";
-import { ICustomMediaKeys } from "./types";
-
-interface IMozMediaKeysConstructor {
-  new(keySystem: string): ICustomMediaKeys;
-  isTypeSupported(keySystem: string, type?: string | null): boolean;
-}
-
-let MozMediaKeysConstructor: IMozMediaKeysConstructor|undefined;
-if (!isNode) {
-  const { MozMediaKeys } = (window as Window & {
-    MozMediaKeys? : IMozMediaKeysConstructor;
-  });
-  if (
-    MozMediaKeys !== undefined &&
-    MozMediaKeys.prototype !== undefined &&
-    typeof MozMediaKeys.isTypeSupported === "function" &&
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    typeof MozMediaKeys.prototype.createSession === "function"
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-  ) {
-    MozMediaKeysConstructor = MozMediaKeys;
-  }
-}
-export { MozMediaKeysConstructor };
-
-export default function getMozMediaKeysCallbacks() : {
-  isTypeSupported: (keyType: string) => boolean;
-  createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-  setMediaKeys: (
-    elt: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ) => Promise<unknown>;
-} {
-  const isTypeSupported = (keySystem: string, type?: string|null) => {
-    if (MozMediaKeysConstructor === undefined) {
-      throw new Error("No MozMediaKeys API.");
-    }
-    if (type !== undefined) {
-      return MozMediaKeysConstructor.isTypeSupported(keySystem, type);
-    }
-    return MozMediaKeysConstructor.isTypeSupported(keySystem);
-  };
-  const createCustomMediaKeys = (keyType: string) => {
-    if (MozMediaKeysConstructor === undefined) {
-      throw new Error("No MozMediaKeys API.");
-    }
-    return new MozMediaKeysConstructor(keyType);
-  };
-  const setMediaKeys = (
-    mediaElement: HTMLMediaElement,
-    mediaKeys: MediaKeys|ICustomMediaKeys|null
-  ): Promise<unknown> => {
-    return wrapInPromise(() => {
-      const elt : ICompatHTMLMediaElement = mediaElement;
-      if (
-        elt.mozSetMediaKeys === undefined ||
-        typeof elt.mozSetMediaKeys !== "function"
-      ) {
-        throw new Error("Can't set video on MozMediaKeys.");
-      }
-      return elt.mozSetMediaKeys(mediaKeys);
-    });
-  };
-  return {
-    isTypeSupported,
-    createCustomMediaKeys,
-    setMediaKeys,
-  };
-}

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

@@ -1,69 +0,0 @@
-/**
- * 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.
- */
-
-import isNode from "../../is_node";
-
-export interface MSMediaKeyError {
-    readonly code: number;
-    readonly systemCode: number;
-    readonly MS_MEDIA_KEYERR_CLIENT: number;
-    readonly MS_MEDIA_KEYERR_DOMAIN: number;
-    readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
-    readonly MS_MEDIA_KEYERR_OUTPUT: number;
-    readonly MS_MEDIA_KEYERR_SERVICE: number;
-    readonly MS_MEDIA_KEYERR_UNKNOWN: number;
-}
-
-export interface MSMediaKeySession extends EventTarget {
-    readonly error: MSMediaKeyError | null;
-    readonly keySystem: string;
-    readonly sessionId: string;
-    close(): void;
-    update(key: Uint8Array): void;
-}
-
-export interface MSMediaKeys {
-    readonly keySystem: string;
-    createSession(
-      type: string,
-      initData: Uint8Array,
-      cdmData?: Uint8Array | null
-    ): MSMediaKeySession;
-}
-
-interface IMSMediaKeysConstructor {
-  new(keySystem: string): MSMediaKeys;
-  isTypeSupported(keySystem: string, type?: string | null): boolean;
-  isTypeSupportedWithFeatures(keySystem: string, type?: string | null): string;
-}
-
-let MSMediaKeysConstructor: IMSMediaKeysConstructor|undefined;
-if (!isNode) {
-  const { MSMediaKeys } = (window as Window & {
-    MSMediaKeys? : IMSMediaKeysConstructor;
-  });
-  if (
-    MSMediaKeys !== undefined &&
-    MSMediaKeys.prototype !== undefined &&
-    typeof MSMediaKeys.isTypeSupported === "function" &&
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    typeof MSMediaKeys.prototype.createSession === "function"
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-  ) {
-    MSMediaKeysConstructor = MSMediaKeys;
-  }
-}
-export { MSMediaKeysConstructor };