rx-player 3.33.0 → 3.33.1

package/src/compat/eme/eme-api-implementation.ts

@@ -1,318 +0,0 @@
-import { MediaError } from "../../errors";
-import assert from "../../utils/assert";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import { CancellationSignal } from "../../utils/task_canceller";
-import { ICompatHTMLMediaElement } from "../browser_compatibility_types";
-import { isIE11 } from "../browser_detection";
-import { createCompatibleEventListener, IEventTargetLike } from "../event_listeners";
-import isNode from "../is_node";
-import shouldFavourCustomSafariEME from "../should_favour_custom_safari_EME";
-import CustomMediaKeySystemAccess from "./custom_key_system_access";
-import getIE11MediaKeysCallbacks, {
-  MSMediaKeysConstructor,
-} from "./custom_media_keys/ie11_media_keys";
-import getMozMediaKeysCallbacks, {
-  MozMediaKeysConstructor,
-} from "./custom_media_keys/moz_media_keys_constructor";
-import getOldKitWebKitMediaKeyCallbacks, {
-  isOldWebkitMediaElement,
-} from "./custom_media_keys/old_webkit_media_keys";
-import {
-  ICustomMediaKeys,
-} from "./custom_media_keys/types";
-import getWebKitMediaKeysCallbacks from "./custom_media_keys/webkit_media_keys";
-import {
-  WebKitMediaKeysConstructor,
-} from "./custom_media_keys/webkit_media_keys_constructor";
-
-/**
- * Automatically detect and set which EME implementation should be used in the
- * current platform.
- *
- * You can call `getEmeApiImplementation` for a different implementation.
- */
-const defaultEmeImplementation = getEmeApiImplementation("auto");
-
-export default defaultEmeImplementation;
-
-/**
- * Generic interface harmonizing the structure of the different EME API
- * implementations the RxPlayer could use.
- */
-export interface IEmeApiImplementation {
-  /**
-   * API implementing the `navigator.requestMediaKeySystemAccess` static method
-   * from EME.
-   * @param {string} keyType - Key system name, as a reverse domain name.
-   * @param {Array.<MediaKeySystemMediaCapability>} Wanted configurations, from
-   * the most wanted to the least.
-   * @returns {Promise}
-   */
-  requestMediaKeySystemAccess : (
-    keyType : string,
-    config : MediaKeySystemConfiguration[]
-  ) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
-
-  /**
-   * API allowing to listen for `"encrypted"` events, presumably sent by the
-   * HTMLMediaElement on which encrypted content is pushed.
-   * @param {EventTarget} The element on which the event will be listened to.
-   * Generally it is the HTMLMediaElement.
-   * @param {Function} listener - The event listener on which that event's
-   * payload will be dispatched.
-   * @param {Object} cancelSignal - The event listener will be removed once that
-   * `CancellationSignal` emits.
-   */
-  onEncrypted : (
-    target : IEventTargetLike,
-    listener : (evt : unknown) => void,
-    cancelSignal : CancellationSignal,
-  ) => void;
-
-  /**
-   * API allowing to attach a `MediaKeys` instance (or an `ICustomMediaKeys`) to
-   * the HTMLMediaElement so it can start decoding.
-   * @param {HTMLMediaElement} The HTMLMediaElement on which the content plays.
-   * @param {MediaKeys} mediaKeys - The MediaKeys instance to attach.
-   * @returns {Promise} - That promise resolves if the `MediaKeys` instance was
-   * attached to the `HTMLMediaElement` with success, or rejects on the opposite
-   * scenario.
-   */
-  setMediaKeys : (
-    mediaElement: HTMLMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null
-  ) => Promise<unknown>;
-
-  /**
-   * String describing the currently used EME implementation:
-   *
-   *   - "standard": regular EME implementation
-   *
-   *   - "webkit": The webkit-prefixed variant of the EME API
-   *
-   *   - "older-webkit": An even older webkit-prefixed variant of the EME API
-   *
-   *   - "ms": The ms-prefixed variant of the EME API
-   *
-   *   - "moz": The moz-prefixed variant of the EME API
-   *
-   *   - "unknown": An unidentified variant of the EME API
-   */
-  implementation : "standard" | "webkit" | "older-webkit" | "ms" | "moz" | "unknown";
-}
-
-/**
- * Union of all the different value the preferred EME API type can be set to:
- *
- *   - "auto": The implementation will be chosen automatically based on what
- *     we've most confidence on on the current device.
- *
- *   - "standard": If present, the standard EME API will be given precedence
- *     over custom and browser-specific ones.
- *
- *   - "webkit": The webkit-prefixed variant of the EME API will be given
- *     precedence over any other one if present.
- *
- */
-export type IPreferredEmeApiType = "auto" | "standard" | "webkit";
-
-/**
- * Returns the current EME implementation based on what's present on the device
- * and the given preference.
- * @param {string} preferredApiType - EME API preference
- * (@see IPreferredEmeApiType).
- * @returns {Object}
- */
-function getEmeApiImplementation(
-  preferredApiType : IPreferredEmeApiType
-) : IEmeApiImplementation {
-  let requestMediaKeySystemAccess : IEmeApiImplementation["requestMediaKeySystemAccess"];
-  let onEncrypted : IEmeApiImplementation["onEncrypted"];
-  let setMediaKeys : IEmeApiImplementation["setMediaKeys"] = defaultSetMediaKeys;
-  let implementation : IEmeApiImplementation["implementation"];
-  if (
-    (
-      preferredApiType === "standard" ||
-      (preferredApiType === "auto" && !shouldFavourCustomSafariEME())
-    ) &&
-    (
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      isNode || !isNullOrUndefined(navigator.requestMediaKeySystemAccess)
-    )
-  ) {
-    requestMediaKeySystemAccess = (...args) =>
-      navigator.requestMediaKeySystemAccess(...args);
-    onEncrypted = createCompatibleEventListener(["encrypted"]);
-    implementation = "standard";
-  } else {
-    let isTypeSupported: (keyType: string) => boolean;
-    let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-
-    if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
-      onEncrypted = createCompatibleEventListener(["needkey"]);
-      const callbacks = getWebKitMediaKeysCallbacks();
-      isTypeSupported = callbacks.isTypeSupported;
-      createCustomMediaKeys = callbacks.createCustomMediaKeys;
-      setMediaKeys = callbacks.setMediaKeys;
-      implementation = "webkit";
-    } else {
-      // This is for Chrome with unprefixed EME api
-      if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
-        onEncrypted = createCompatibleEventListener(["needkey"]);
-        const callbacks = getOldKitWebKitMediaKeyCallbacks();
-        isTypeSupported = callbacks.isTypeSupported;
-        createCustomMediaKeys = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-        implementation = "older-webkit";
-      // This is for WebKit with prefixed EME api
-      } else if (WebKitMediaKeysConstructor !== undefined) {
-        onEncrypted = createCompatibleEventListener(["needkey"]);
-        const callbacks = getWebKitMediaKeysCallbacks();
-        isTypeSupported = callbacks.isTypeSupported;
-        createCustomMediaKeys = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-        implementation = "webkit";
-      } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
-        onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
-        const callbacks = getIE11MediaKeysCallbacks();
-        isTypeSupported = callbacks.isTypeSupported;
-        createCustomMediaKeys = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-        implementation = "ms";
-      } else if (MozMediaKeysConstructor !== undefined) {
-        onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
-        const callbacks = getMozMediaKeysCallbacks();
-        isTypeSupported = callbacks.isTypeSupported;
-        createCustomMediaKeys = callbacks.createCustomMediaKeys;
-        setMediaKeys = callbacks.setMediaKeys;
-        implementation = "moz";
-      } else {
-        onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
-        const MK = window.MediaKeys as unknown as typeof MediaKeys & {
-          isTypeSupported? : (keyType : string) => boolean;
-          new(keyType? : string) : ICustomMediaKeys;
-        };
-        const checkForStandardMediaKeys = () => {
-          if (MK === undefined) {
-            throw new MediaError("MEDIA_KEYS_NOT_SUPPORTED",
-                                 "No `MediaKeys` implementation found " +
-                                 "in the current browser.");
-          }
-          if (typeof MK.isTypeSupported === "undefined") {
-            const message = "This browser seems to be unable to play encrypted " +
-                            "contents currently." +
-                            "Note: Some browsers do not allow decryption " +
-                            "in some situations, like when not using HTTPS.";
-            throw new Error(message);
-          }
-        };
-        isTypeSupported = (keyType: string): boolean => {
-          checkForStandardMediaKeys();
-          assert(typeof MK.isTypeSupported === "function");
-          return MK.isTypeSupported(keyType);
-        };
-        createCustomMediaKeys = (keyType: string) => {
-          checkForStandardMediaKeys();
-          return new MK(keyType);
-        };
-        implementation = "unknown";
-      }
-    }
-
-    requestMediaKeySystemAccess = function(
-      keyType : string,
-      keySystemConfigurations : MediaKeySystemConfiguration[]
-    ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
-      if (!isTypeSupported(keyType)) {
-        return Promise.reject(new Error("Unsupported key type"));
-      }
-
-      for (let i = 0; i < keySystemConfigurations.length; i++) {
-        const keySystemConfiguration = keySystemConfigurations[i];
-        const { videoCapabilities,
-                audioCapabilities,
-                initDataTypes,
-                distinctiveIdentifier } = keySystemConfiguration;
-        let supported = true;
-        supported = supported &&
-                    (initDataTypes == null ||
-                     initDataTypes.some((idt) => idt === "cenc"));
-        supported = supported && (distinctiveIdentifier !== "required");
-
-        if (supported) {
-          const keySystemConfigurationResponse : MediaKeySystemConfiguration = {
-            initDataTypes: ["cenc"],
-            distinctiveIdentifier: "not-allowed" as const,
-            persistentState: "required" as const,
-            sessionTypes: ["temporary", "persistent-license"],
-          };
-          if (videoCapabilities !== undefined) {
-            keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
-          }
-          if (audioCapabilities !== undefined) {
-            keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
-          }
-
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          const customMediaKeys = createCustomMediaKeys(keyType);
-          return Promise.resolve(
-            new CustomMediaKeySystemAccess(keyType,
-                                           customMediaKeys,
-                                           keySystemConfigurationResponse)
-          );
-        }
-      }
-
-      return Promise.reject(new Error("Unsupported configuration"));
-    };
-  }
-  return { requestMediaKeySystemAccess,
-           onEncrypted,
-           setMediaKeys,
-           implementation };
-}
-
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} mediaKeys
- * @returns {Promise}
- */
-function defaultSetMediaKeys(
-  mediaElement: HTMLMediaElement,
-  mediaKeys: MediaKeys | ICustomMediaKeys | null
-): Promise<unknown> {
-  try {
-    let ret : unknown;
-    const elt : ICompatHTMLMediaElement = mediaElement;
-    /* eslint-disable @typescript-eslint/unbound-method */
-    if (typeof elt.setMediaKeys === "function") {
-      ret = elt.setMediaKeys(mediaKeys as MediaKeys);
-    }
-    /* eslint-enable @typescript-eslint/unbound-method */
-
-    // If we get in the following code, it means that no compat case has been
-    // found and no standard setMediaKeys API exists. This case is particulary
-    // rare. We will try to call each API with native media keys.
-    else if (typeof elt.webkitSetMediaKeys === "function") {
-      ret = elt.webkitSetMediaKeys(mediaKeys);
-    } else if (typeof elt.mozSetMediaKeys === "function") {
-      ret = elt.mozSetMediaKeys(mediaKeys);
-    } else if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
-      ret = elt.msSetMediaKeys(mediaKeys);
-    }
-
-    if (
-      typeof ret === "object" &&
-      ret !== null &&
-      typeof (ret as Promise<unknown>).then === "function"
-    ) {
-      return ret as Promise<unknown>;
-    } else {
-      return Promise.resolve(ret);
-    }
-  } catch (err) {
-    return Promise.reject(err);
-  }
-}

package/src/compat/eme/generate_key_request.ts

@@ -1,162 +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 { getNextBoxOffsets } from "../../parsers/containers/isobmff";
-import {
-  be4toi,
-  concat,
-} from "../../utils/byte_parsing";
-import { PSSH_TO_INTEGER } from "./constants";
-import { ICustomMediaKeySession } from "./custom_media_keys";
-
-/**
- * Modify "initialization data" sent to a `generateKeyRequest` EME call to
- * improve the player's browser compatibility:
- *
- *   1. some browsers/CDM have problems when the CENC PSSH box is the first
- *      encountered PSSH box in the initialization data (for the moment just
- *      Edge was noted with this behavior).
- *      We found however that it works on every browser when the CENC pssh
- *      box(es) is/are the last box(es) encountered.
- *
- *      To that end, we move CENC pssh boxes at the end of the initialization
- *      data in this function.
- *
- *   2. Some poorly encoded/packaged contents communicate both a CENC with a
- *      pssh version of 0 and one with a version of 1. We found out that this is
- *      not always well handled on some devices/browsers (on Edge and some other
- *      embedded devices that shall remain nameless for now!).
- *
- *      Here this function will filter out CENC pssh with a version different to
- *      1 when one(s) with a version of 1 is/are already present.
- *
- * If the initData is unrecognized or if a CENC PSSH is not found, this function
- * throws.
- * @param {Uint8Array} initData - Initialization data you want to patch
- * @returns {Uint8Array} - Initialization data, patched
- */
-export function patchInitData(initData : Uint8Array) : Uint8Array {
-  log.info("Compat: Trying to move CENC PSSH from init data at the end of it.");
-  let foundCencV1 = false;
-  let concatenatedCencs = new Uint8Array();
-  let resInitData = new Uint8Array();
-
-  let offset = 0;
-  while (offset < initData.length) {
-    if (initData.length < offset + 8 ||
-        be4toi(initData, offset + 4) !== PSSH_TO_INTEGER
-    ) {
-      log.warn("Compat: unrecognized initialization data. Cannot patch it.");
-      throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
-    }
-
-    const len = be4toi(new Uint8Array(initData), offset);
-    if (offset + len > initData.length) {
-      log.warn("Compat: unrecognized initialization data. Cannot patch it.");
-      throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
-    }
-
-    const currentPSSH = initData.subarray(offset, offset + len);
-    // yep
-    if (initData[offset + 12] === 0x10 &&
-        initData[offset + 13] === 0x77 &&
-        initData[offset + 14] === 0xEF &&
-        initData[offset + 15] === 0xEC &&
-        initData[offset + 16] === 0xC0 &&
-        initData[offset + 17] === 0xB2 &&
-        initData[offset + 18] === 0x4D &&
-        initData[offset + 19] === 0x02 &&
-        initData[offset + 20] === 0xAC &&
-        initData[offset + 21] === 0xE3 &&
-        initData[offset + 22] === 0x3C &&
-        initData[offset + 23] === 0x1E &&
-        initData[offset + 24] === 0x52 &&
-        initData[offset + 25] === 0xE2 &&
-        initData[offset + 26] === 0xFB &&
-        initData[offset + 27] === 0x4B
-    ) {
-      const cencOffsets = getNextBoxOffsets(currentPSSH);
-      const version = cencOffsets === null ? undefined :
-                                             currentPSSH[cencOffsets[1]];
-      log.info("Compat: CENC PSSH found with version", version);
-      if (version === undefined) {
-        log.warn("Compat: could not read version of CENC PSSH");
-      } else if (foundCencV1 === (version === 1)) {
-        // Either `concatenatedCencs` only contains v1 or does not contain any
-        concatenatedCencs = concat(concatenatedCencs, currentPSSH);
-      } else if (version === 1) {
-        log.warn("Compat: cenc version 1 encountered, " +
-                 "removing every other cenc pssh box.");
-        concatenatedCencs = currentPSSH;
-        foundCencV1 = true;
-      } else {
-        log.warn("Compat: filtering out cenc pssh box with wrong version",
-                 version);
-      }
-    } else {
-      resInitData = concat(resInitData, currentPSSH);
-    }
-    offset += len;
-  }
-
-  if (offset !== initData.length) {
-    log.warn("Compat: unrecognized initialization data. Cannot patch it.");
-    throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
-  }
-  return concat(resInitData, concatenatedCencs);
-}
-
-/**
- * Generate a request from session.
- * @param {MediaKeySession} session - MediaKeySession on which the request will
- * be done.
- * @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(
-  session: MediaKeySession|ICustomMediaKeySession,
-  initializationDataType : string | undefined,
-  initializationData : Uint8Array
-) : Promise<unknown> {
-  log.debug("Compat: Calling generateRequest on the MediaKeySession");
-  let patchedInit : Uint8Array;
-  try {
-    patchedInit = patchInitData(initializationData);
-  } catch (_e) {
-    patchedInit = initializationData;
-  }
-  const initDataType = initializationDataType ?? "";
-  return session.generateRequest(initDataType, patchedInit)
-    .catch((error) => {
-      if (initDataType !== "" || !(error instanceof TypeError)) {
-        throw error;
-      }
-
-      // On newer EME versions of the specification, the initialization data
-      // type given to generateRequest cannot be an empty string (it returns
-      // a rejected promise with a TypeError in that case).
-      // Retry with a default "cenc" value for initialization data type if
-      // we're in that condition.
-      log.warn("Compat: error while calling `generateRequest` with an empty " +
-               "initialization data type. Retrying with a default \"cenc\" value.",
-               error);
-      return session.generateRequest("cenc", patchedInit);
-    });
-}

package/src/compat/eme/get_init_data.ts

@@ -1,159 +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 { getPsshSystemID } from "../../parsers/containers/isobmff";
-import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
-import { be4toi } from "../../utils/byte_parsing";
-import { PSSH_TO_INTEGER } from "./constants";
-
-/** Data recuperated from parsing the payload of an `encrypted` event. */
-export interface IEncryptedEventData {
-  /**
-   * Initialization data type.
-   * String describing the format of the initialization data sent through this
-   * event.
-   * https://www.w3.org/TR/eme-initdata-registry/
-   *
-   * `undefined` if not known.
-   */
-  type : string | undefined;
-  /** Every initialization data for that type. */
-  values: Array<{
-    /**
-     * Hex encoded system id, which identifies the key system.
-     * https://dashif.org/identifiers/content_protection/
-     *
-     * If `undefined`, we don't know the system id for that initialization data.
-     * In that case, the initialization data might even be a concatenation of
-     * the initialization data from multiple system ids.
-     */
-    systemId : string | undefined;
-    /**
-     * The initialization data itself for that type and systemId.
-     * For example, with ISOBMFF "cenc" initialization data, this will be the
-     * whole PSSH box.
-     */
-    data: Uint8Array;
-  }>;
-}
-
-/**
- * Take in input initialization data from an encrypted event and generate the
- * corresponding array of initialization data values from it.
- *
- * At the moment, this function only handles initialization data which have the
- * "cenc" initialization data type.
- * It will just return a single value with an `undefined` `systemId` for all
- * other types of data.
- * @param {Uint8Array} initData - Raw initialization data
- * @returns {Array.<Object>}
- */
-function getInitializationDataValues(
-  initData : Uint8Array
-) : Array<{ systemId : string | undefined; data : Uint8Array }> {
-  const result : Array<{ systemId : string | undefined; data : Uint8Array }> = [];
-  let offset = 0;
-
-  while (offset < initData.length) {
-    if (initData.length < offset + 8 ||
-        be4toi(initData, offset + 4) !== PSSH_TO_INTEGER
-    ) {
-      log.warn("Compat: Unrecognized initialization data. Use as is.");
-      return [ { systemId: undefined,
-                 data: initData } ];
-    }
-
-    const len = be4toi(new Uint8Array(initData), offset);
-    if (offset + len > initData.length) {
-      log.warn("Compat: Unrecognized initialization data. Use as is.");
-      return [ { systemId: undefined,
-                 data: initData } ];
-    }
-    const currentPSSH = initData.subarray(offset, offset + len);
-    const systemId = getPsshSystemID(currentPSSH, 8);
-    const currentItem = { systemId, data: currentPSSH };
-    if (isPSSHAlreadyEncountered(result, currentItem)) {
-      // As we observed on some browsers (IE and Edge), the initialization data on
-      // some segments have sometimes duplicated PSSH when sent through an encrypted
-      // event (but not when the corresponding segment has been pushed to the
-      // SourceBuffer).
-      // We prefer filtering them out, to avoid further issues.
-      log.warn("Compat: Duplicated PSSH found in initialization data, removing it.");
-    } else {
-      result.push(currentItem);
-    }
-    offset += len;
-  }
-
-  if (offset !== initData.length) {
-    log.warn("Compat: Unrecognized initialization data. Use as is.");
-    return [ { systemId: undefined,
-               data: initData } ];
-  }
-  return result;
-}
-
-/**
- * Returns `true` if the given PSSH has already been stored in the
- * `encounteredPSSHs` cache given.
- * Returns `false` otherwise.
- * @param {Array.<Object>} encounteredPSSHs
- * @param {Uint8Array} pssh
- * @returns {boolean}
- */
-function isPSSHAlreadyEncountered(
-  encounteredPSSHs : Array<{ systemId : string | undefined; data : Uint8Array }>,
-  pssh : { systemId : string | undefined; data : Uint8Array }
-) : boolean {
-  for (let i = 0; i < encounteredPSSHs.length; i++) {
-    const item = encounteredPSSHs[i];
-    if (pssh.systemId === undefined ||
-        item.systemId === undefined ||
-        pssh.systemId === item.systemId)
-    {
-      if (areArraysOfNumbersEqual(pssh.data, item.data)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-/**
- * Take out the two things we need on an encryptedEvent:
- *   - the initialization Data
- *   - the initialization Data type
- *
- * @param {MediaEncryptedEvent} encryptedEvent - Payload received with an
- * "encrypted" event.
- * @returns {Object} - Initialization data and Initialization data type.
- * @throws {EncryptedMediaError} - Throws if no initialization data is
- * encountered in the given event.
- */
-export default function getInitData(
-  encryptedEvent : MediaEncryptedEvent
-) : IEncryptedEventData | null {
-  const { initData, initDataType } = encryptedEvent;
-  if (initData == null) {
-    log.warn("Compat: No init data found on media encrypted event.");
-    return null;
-  }
-
-  const initDataBytes = new Uint8Array(initData);
-  const values = getInitializationDataValues(initDataBytes);
-  return { type: initDataType, values };
-}

package/src/compat/eme/get_uuid_kid_from_keystatus_kid.ts

@@ -1,37 +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 { guidToUuid } from "../../utils/string_parsing";
-import {
-  isEdgeChromium,
-  isIEOrEdge,
-} from "../browser_detection";
-
-/**
- * Get KID from MediaKeySession keyStatus, and convert it in usual big-endian kid
- * if necessary. On EDGE, Microsoft Playready KID are presented into little-endian GUID.
- * @param {String} keySystem
- * @param {Uint8Array} baseKeyId
- * @returns {Uint8Array}
- */
-export default function getUUIDKIDFromKeyStatusKID(keySystem: string,
-                                                   baseKeyId: Uint8Array): Uint8Array {
-  if (keySystem.indexOf("playready") !== -1 &&
-      (isIEOrEdge || isEdgeChromium)) {
-    return guidToUuid(baseKeyId);
-  }
-  return baseKeyId;
-}