rx-player 3.33.0 → 3.33.1

package/src/core/decrypt/types.ts

@@ -1,404 +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 Manifest, {
-  Adaptation,
-  Period,
-  Representation,
-} from "../../manifest";
-import { IPlayerError } from "../../public_types";
-import InitDataValuesContainer from "./utils/init_data_values_container";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-import PersistentSessionsStore from "./utils/persistent_sessions_store";
-
-/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
-export interface IContentDecryptorEvent {
-  /**
-   * Event emitted when a major error occured which made the ContentDecryptor
-   * stopped.
-   * When that event is sent, the `ContentDecryptor` is in the `Error` state and
-   * cannot be used anymore.
-   */
-  error : Error;
-
-  /**
-   * Event emitted when a minor error occured which the ContentDecryptor can
-   * recover from.
-   */
-  warning : IPlayerError;
-
-  /**
-   * Event emitted when the `ContentDecryptor`'s state changed.
-   * States are a central aspect of the `ContentDecryptor`, be sure to check the
-   * ContentDecryptorState type.
-   */
-  stateChange: ContentDecryptorState;
-}
-
-/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
-export enum ContentDecryptorState {
-  /**
-   * The `ContentDecryptor` is not yet ready to create key sessions and request
-   * licenses.
-   * This is is the initial state of the ContentDecryptor.
-   */
-  Initializing,
-
-  /**
-   * The `ContentDecryptor` has been initialized.
-   * You should now called the `attach` method when you want to add decryption
-   * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
-   * `ReadyForContent` state until `attach` is called.
-   *
-   * For compatibility reasons, this should be done after the HTMLMediaElement's
-   * src attribute is set.
-   *
-   * It is also from when this state is reached that the `ContentDecryptor`'s
-   * `systemId` property may be known.
-   *
-   * This state is always coming after the `Initializing` state.
-   */
-  WaitingForAttachment,
-
-  /**
-   * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
-   * (this state was needed because some browser quirks sometimes forces us to
-   * call EME API before this can be done).
-   *
-   * This state is always coming after the `WaitingForAttachment` state.
-   */
-  ReadyForContent,
-
-  /**
-   * The `ContentDecryptor` has encountered a fatal error and has been stopped.
-   * It is now unusable.
-   */
-  Error,
-
-  /** The `ContentDecryptor` has been disposed of and is now unusable. */
-  Disposed,
-}
-
-/** Information about the encryption initialization data. */
-export interface IProtectionData {
-  /**
-   * The initialization data type - or the format of the `data` attribute (e.g.
-   * "cenc").
-   * `undefined` if unknown.
-   */
-  type : string | undefined;
-  /**
-   * The key ids linked to those initialization data.
-   * This should be the key ids for the key concerned by the media which have
-   * the present initialization data.
-   *
-   * `undefined` when not known (different from an empty array - which would
-   * just mean that there's no key id involved).
-   */
-  keyIds? : Uint8Array[] | undefined;
-  /** The content linked to that segment protection data. */
-  content? : IContent;
-  /** Every initialization data for that type. */
-  values: IInitDataValue[];
-}
-
-/** Protection initialization data actually processed by the `ContentDecryptor`. */
-export interface IProcessedProtectionData extends Omit<IProtectionData, "values"> {
-  values: InitDataValuesContainer;
-}
-
-/**
- * Represent the initialization data linked to a key system that can be used to
- * generate the license request.
- */
-export interface IInitDataValue {
-  /**
-   * 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 "cenc" initialization data found in an ISOBMFF file,
-   * this will be the whole PSSH box.
-   */
-   data: Uint8Array;
-}
-
-export type ILicense = BufferSource |
-                       ArrayBuffer;
-
-/** Segment protection sent by the RxPlayer to the `ContentDecryptor`. */
-export interface IContentProtection {
-  /** The content linked to that segment protection data. */
-  content : IContent;
-  /**
-   * Initialization data type.
-   * String describing the format of the initialization data sent through this
-   * event.
-   * https://www.w3.org/TR/eme-initdata-registry/
-   */
-  type: string;
-  /**
-   * The key ids linked to those initialization data.
-   * This should be the key ids for the key concerned by the media which have
-   * the present initialization data.
-   *
-   * `undefined` when not known (different from an empty array - which would
-   * just mean that there's no key id involved).
-   */
-  keyIds : Uint8Array[] | undefined;
-  /** Every initialization data for that type. */
-  values: Array<{
-    /**
-     * Hex encoded system id, which identifies the key system.
-     * https://dashif.org/identifiers/content_protection/
-     */
-    systemId: string;
-    /**
-     * The initialization data itself for that type and systemId.
-     * For example, with "cenc" initialization data found in an ISOBMFF file,
-     * this will be the whole PSSH box.
-     */
-     data: Uint8Array;
-  }>;
-}
-
-/** Content linked to protection data. */
-export interface IContent {
-  /** Manifest object associated to the protection data. */
-  manifest : Manifest;
-  /** Period object associated to the protection data. */
-  period : Period;
-  /** Adaptation object associated to the protection data. */
-  adaptation : Adaptation;
-  /** Representation object associated to the protection data. */
-  representation : Representation;
-}
-
-/** Stores helping to create and retrieve MediaKeySessions. */
-export interface IMediaKeySessionStores {
-  /** Retrieve MediaKeySessions already loaded on the current MediaKeys instance. */
-  loadedSessionsStore : LoadedSessionsStore;
-  /** Retrieve persistent MediaKeySessions already created. */
-  persistentSessionsStore : PersistentSessionsStore |
-                            null;
-}
-
-/** Enum identifying the way a new MediaKeySession has been loaded. */
-export const enum MediaKeySessionLoadingType {
-  /**
-   * This MediaKeySession has just been created.
-   * This means that it will necessitate a new license request to be generated
-   * and performed.
-   */
-  Created = "created-session",
-  /**
-   * This MediaKeySession was an already-opened one that is being reused.
-   * Such session had already their license loaded and pushed.
-   */
-  LoadedOpenSession = "loaded-open-session",
-  /**
-   * This MediaKeySession was a persistent MediaKeySession that has been
-   * re-loaded.
-   * Such session are linked to a persistent license which should have already
-   * been fetched.
-   */
-  LoadedPersistentSession = "loaded-persistent-session",
-}
-
-/** Wrap an Uint8Array and allow serialization of it into base64. */
-interface ByteArrayContainer {
-  /**
-   * The wrapped data.
-   * Here named `initData` even when it's not always initialization data for
-   * backward-compatible reasons.
-   */
-  initData : Uint8Array;
-
-  /**
-   * Convert it to base64.
-   * `toJSON` is specially interpreted by JavaScript engines to be able to rely
-   * on it when calling `JSON.stringify` on it or any of its parent objects:
-   * https://tc39.es/ecma262/#sec-serializejsonproperty
-   */
-  toJSON() : string;
-}
-
-/**
- * Stored information about a single persistent `MediaKeySession`, when created
- * since the v3.27.0 RxPlayer version included.
- */
-export interface IPersistentSessionInfoV4 {
-  /** Version for this object. */
-  version : 4;
-
-  /** The persisted MediaKeySession's `id`. Used to load it at a later time. */
-  sessionId : string;
-
-  /** Type giving information about the format of the initialization data. */
-  initDataType : string | undefined;
-
-  /** All key ids linked to that `MediaKeySession`. */
-  keyIds: Array<ByteArrayContainer | string>;
-
-  /**
-   * Every saved initialization data for that session, used as IDs.
-   * Elements are sorted in systemId alphabetical order (putting the `undefined`
-   * ones last).
-   */
-  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;
-    /**
-     * A hash of the initialization data (generated by the `hashBuffer` function,
-     * at the time of v3.20.1 at least). Allows for a faster comparison than just
-     * comparing initialization data multiple times.
-     */
-    hash : number;
-    /**
-     * The initialization data associated to the systemId, wrapped in a
-     * container to allow efficient serialization.
-     */
-    data : ByteArrayContainer | string;
-  }>;
-}
-
-/**
- * Stored information about a single persistent `MediaKeySession`, when created
- * from the v3.24.0 RxPlayer version included to the v3.26.2 included.
- */
-export interface IPersistentSessionInfoV3 {
-  /** Version for this object. */
-  version : 3;
-
-  /** The persisted MediaKeySession's `id`. Used to load it at a later time. */
-  sessionId : string;
-
-  /** Type giving information about the format of the initialization data. */
-  initDataType : string | undefined;
-
-  /**
-   * Every saved initialization data for that session, used as IDs.
-   * Elements are sorted in systemId alphabetical order (putting the `undefined`
-   * ones last).
-   */
-  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;
-    /**
-     * A hash of the initialization data (generated by the `hashBuffer` function,
-     * at the time of v3.20.1 at least). Allows for a faster comparison than just
-     * comparing initialization data multiple times.
-     */
-    hash : number;
-    /**
-     * The initialization data associated to the systemId, wrapped in a
-     * container to allow efficient serialization.
-     */
-    data : ByteArrayContainer | string;
-  }>;
-}
-
-/**
- * Stored information about a single persistent `MediaKeySession`, when created
- * between the RxPlayer versions v3.21.0 and v3.21.1 included.
- * The previous implementation (version 1) was fine enough but did not serialize
- * well due to it containing an Uint8Array. This data is now wrapped into a
- * container which will convert it to base64 when linearized through
- * `JSON.stringify`.
- */
-export interface IPersistentSessionInfoV2 {
-  /** Version for this object. */
-  version : 2;
-  /** The persisted MediaKeySession's `id`. Used to load it at a later time. */
-  sessionId : string;
-  /**
-   * The initialization data associated to the `MediaKeySession`, wrapped in a
-   * container to allow efficient linearization.
-   */
-  initData : ByteArrayContainer;
-  /**
-   * A hash of the initialization data (generated by the `hashBuffer` function,
-   * at the time of v3.20.1 at least). Allows for a faster comparison than just
-   * comparing initialization data multiple times.
-   */
-  initDataHash : number;
-  /** Type giving information about the format of the initialization data. */
-  initDataType? : string | undefined;
-}
-
-/**
- * Stored information about a single persistent `MediaKeySession`, when created
- * in the v3.20.1 RxPlayer version.
- * Add sub-par (as in not performant) collision prevention by setting both
- * the hash of the initialization data and the initialization data itself.
- * The hash could be checked first for a fast comparison, then the full data.
- * Had to do this way because this structure is documented in the API as being
- * put in an array with one element per sessionId.
- * We might implement a HashMap in future versions instead.
- */
-export interface IPersistentSessionInfoV1 {
-  /** Version for this object. */
-  version : 1;
-  /** The persisted MediaKeySession's `id`. Used to load it at a later time. */
-  sessionId : string;
-  /** The initialization data associated to the `MediaKeySession`, untouched. */
-  initData : Uint8Array;
-  /**
-   * A hash of the initialization data (generated by the `hashBuffer` function,
-   * at the time of v3.20.1 at least). Allows for a faster comparison than just
-   * comparing initialization data multiple times.
-   */
-  initDataHash : number;
-  /** Type giving information about the format of the initialization data. */
-  initDataType? : string | undefined;
-}
-
-/**
- * Stored information about a single persistent `MediaKeySession`, when created
- * in RxPlayer versions before the v3.20.1
- * Here we have no collision detection. We could theorically load the wrong
- * persistent session.
- */
-export interface IPersistentSessionInfoV0 {
-  /** Version for this object. Usually not defined here. */
-  version? : undefined;
-  /** The persisted MediaKeySession's `id`. Used to load it at a later time. */
-  sessionId : string;
-  /** This initData is a hash of a real one. Here we don't handle collision. */
-  initData : number;
-  /** Type giving information about the format of the initialization data. */
-  initDataType? : string | undefined;
-}

package/src/core/decrypt/utils/__tests__/are_init_values_compatible.test.ts

@@ -1,261 +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 areInitializationValuesCompatible from "../are_init_values_compatible";
-
-describe("decrypt - utils - areInitializationValuesCompatible", () => {
-  it("should return false if either initialization data is empty", () => {
-    const test1 = areInitializationValuesCompatible([], []);
-    const test2 = areInitializationValuesCompatible(
-      [],
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) } ]);
-    const test3 = areInitializationValuesCompatible(
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) } ],
-      []);
-    expect(test1).toEqual(false);
-    expect(test2).toEqual(false);
-    expect(test3).toEqual(false);
-  });
-
-  it("should return true for equivalent initialization data", () => {
-    const test1 = areInitializationValuesCompatible(
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) } ],
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) } ]
-    );
-    const test2 = areInitializationValuesCompatible(
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) } ]);
-    expect(test1).toEqual(true);
-    expect(test2).toEqual(true);
-  });
-
-  /* eslint-disable max-len */
-  it("should return true if the first initializationData is contained in the second", () => {
-  /* eslint-enable max-len */
-    const test1 = areInitializationValuesCompatible(
-
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ]);
-    expect(test1).toEqual(true);
-  });
-
-  /* eslint-disable max-len */
-  it("should return true if the second initializationData is contained in the first", () => {
-  /* eslint-enable max-len */
-    const test1 = areInitializationValuesCompatible(
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ]
-    );
-    expect(test1).toEqual(true);
-  });
-
-  /* eslint-disable max-len */
-  it("should return false if initializationData systemIds are different", () => {
-  /* eslint-enable max-len */
-    const test1 = areInitializationValuesCompatible(
-
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "BB",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "CC",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "DD",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ]);
-    expect(test1).toEqual(false);
-  });
-
-  /* eslint-disable max-len */
-  it("should return false if at least one hash is different", () => {
-  /* eslint-enable max-len */
-    const test1 = areInitializationValuesCompatible(
-
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "FE",
-          hash: 19,
-          data: new Uint8Array([4, 4, 2]) } ]);
-    const test2 = areInitializationValuesCompatible(
-
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 25,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ]);
-    expect(test1).toEqual(false);
-    expect(test2).toEqual(false);
-  });
-
-  /* eslint-disable max-len */
-  it("should return false if init data are different", () => {
-  /* eslint-enable max-len */
-    const test1 = areInitializationValuesCompatible(
-
-      [ { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 27,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 3, 3]) } ]);
-    const test2 = areInitializationValuesCompatible(
-
-      [ { systemId: "F054",
-          hash: 25,
-          data: new Uint8Array([2, 9, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ],
-
-      [ { systemId: "AA",
-          hash: 15,
-          data: new Uint8Array([1, 2, 3]) },
-        { systemId: "F054",
-          hash: 25,
-          data: new Uint8Array([2, 8, 2]) },
-        { systemId: "FA",
-          hash: 18,
-          data: new Uint8Array([2, 2, 2]) },
-        { systemId: "FE",
-          hash: 18,
-          data: new Uint8Array([4, 4, 2]) } ]);
-    expect(test1).toEqual(false);
-    expect(test2).toEqual(false);
-  });
-});