rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

package/src/experimental/index.ts

@@ -0,0 +1,5 @@
+import configHandler from "../config";
+
+export {
+  configHandler as config,
+};

package/src/experimental/tools/VideoThumbnailLoader/push_data.ts

@@ -24,6 +24,7 @@ export default function pushData(
                     adaptation: Adaptation;
                     representation: Representation;
                     segment: ISegment;
+                    chunkSize: number | undefined;
                     start: number;
                     end: number; },
   parsed: ISegmentParserParsedMediaChunk<Uint8Array | ArrayBuffer>,

package/src/experimental/tools/VideoThumbnailLoader/thumbnail_loader.ts

@@ -35,7 +35,6 @@ import createSegmentFetcher, {
 import log from "../../../log";
 import { ISegment } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
-import PPromise from "../../../utils/promise";
 import { freeRequest } from "./create_request";
 import getCompleteSegmentId from "./get_complete_segment_id";
 import getContentInfos from "./get_content_infos";
@@ -110,13 +109,13 @@ export default class VideoThumbnailLoader {
 
     const manifest = this._player.getManifest();
     if (manifest === null) {
-      return PPromise.reject(
+      return Promise.reject(
         new VideoThumbnailLoaderError("NO_MANIFEST",
                                       "No manifest available."));
     }
     const contentInfos = getContentInfos(time, manifest);
     if (contentInfos === null) {
-      return PPromise.reject(
+      return Promise.reject(
         new VideoThumbnailLoaderError("NO_TRACK",
                                       "Couldn't find track for this time."));
     }
@@ -125,7 +124,7 @@ export default class VideoThumbnailLoader {
       .representation.index.getSegments(time, MIN_NEEDED_DATA_AFTER_TIME);
 
     if (segments.length === 0) {
-      return PPromise.reject(
+      return Promise.reject(
         new VideoThumbnailLoaderError("NO_THUMBNAIL",
                                       "Couldn't find thumbnail for the given time."));
     }
@@ -147,7 +146,7 @@ export default class VideoThumbnailLoader {
     if (segments.length === 0) {
       this._videoElement.currentTime = time;
       log.debug("VTL: Thumbnails already loaded.", time);
-      return PPromise.resolve(time);
+      return Promise.resolve(time);
     }
 
     log.debug("VTL: Found thumbnail for time", time, segments);
@@ -193,7 +192,7 @@ export default class VideoThumbnailLoader {
                                       "VideoThumbnailLoaderError: No " +
                                       "imported loader for this transport type: " +
                                       contentInfos.manifest.transport);
-      return PPromise.reject(error);
+      return Promise.reject(error);
     }
     const killTask$ = new Subject<void>();
     const abortError$ = killTask$.pipe(
@@ -249,7 +248,8 @@ export default class VideoThumbnailLoader {
                   if (end === undefined) {
                     end = start + (segment.duration / segment.timescale);
                   }
-                  const inventoryInfos = objectAssign({ segment,
+                  const inventoryInfos = objectAssign({ chunkSize: data.chunkSize,
+                                                        segment,
                                                         start,
                                                         end }, contentInfos);
                   return pushData(inventoryInfos,

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts

@@ -20,11 +20,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable no-restricted-properties */
 
-import {
-  map,
-  of as observableOf,
-} from "rxjs";
 import { ProberStatus } from "../../types";
 
 
@@ -81,7 +78,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
       },
     };
     const mockRequestMediaKeySystemAccess = jest.fn(() => {
-      return observableOf({
+      return Promise.resolve({
         getConfiguration: () => ({}),
       });
     });
@@ -114,11 +111,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
     };
     const mockRequestMediaKeySystemAccess = jest.fn(
       () => {
-        return observableOf(null).pipe(
-          map(() => {
-            throw new Error();
-          })
-        );
+        return Promise.reject(new Error());
       }
     );
     jest.mock("../../../../../compat", () => ({

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts

@@ -20,9 +20,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable no-restricted-properties */
 
-import { of as observableOf } from "rxjs";
-import PPromise from "../../../../../utils/promise";
 import { ProberStatus } from "../../types";
 
 
@@ -57,10 +56,10 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
 
   it("should resolve with `Unknown` if no getStatusForPolicy API", (done) => {
     const mockCreateMediaKeys = jest.fn(() => {
-      return PPromise.resolve({});
+      return Promise.resolve({});
     });
     const mockRequestMediaKeySystemAcces = jest.fn(() => {
-      return observableOf({
+      return Promise.resolve({
         createMediaKeys: mockCreateMediaKeys,
       });
     });
@@ -85,12 +84,12 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
 
   it("should resolve with `Supported` if policy is supported", (done) => {
     const mockCreateMediaKeys = jest.fn(() => {
-      return PPromise.resolve({
-        getStatusForPolicy: () => PPromise.resolve("usable"),
+      return Promise.resolve({
+        getStatusForPolicy: () => Promise.resolve("usable"),
       });
     });
     const mockRequestMediaKeySystemAcces = jest.fn(() => {
-      return observableOf({
+      return Promise.resolve({
         createMediaKeys: mockCreateMediaKeys,
       });
     });
@@ -115,12 +114,12 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
 
   it("should resolve with `NotSupported` if policy is not supported", (done) => {
     const mockCreateMediaKeys = jest.fn(() => {
-      return PPromise.resolve({
-        getStatusForPolicy: () => PPromise.resolve("not-usable"),
+      return Promise.resolve({
+        getStatusForPolicy: () => Promise.resolve("not-usable"),
       });
     });
     const mockRequestMediaKeySystemAcces = jest.fn(() => {
-      return observableOf({
+      return Promise.resolve({
         createMediaKeys: mockCreateMediaKeys,
       });
     });

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/decodingInfos.test.ts

@@ -23,8 +23,6 @@
 /* eslint-disable @typescript-eslint/strict-boolean-expressions */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import PPromise from "../../../../../utils/promise";
-
 import probeDecodingInfos from "../../probers/decodingInfo";
 import {
   IMediaConfiguration,
@@ -42,9 +40,9 @@ const origMediaCapabilities = (navigator as any).mediaCapabilities;
 function stubDecodingInfo(isSupported: boolean, mustReject?: boolean) {
   const decodingInfoStub = jest.fn(() => {
     if (mustReject === true) {
-      return PPromise.reject();
+      return Promise.reject();
     } else {
-      return PPromise.resolve({
+      return Promise.resolve({
         supported: isSupported,
       });
     }

package/src/experimental/tools/mediaCapabilitiesProber/api/index.ts

@@ -15,7 +15,6 @@
  */
 
 import arrayFind from "../../../../utils/array_find";
-import PPromise from "../../../../utils/promise";
 import log from "../log";
 import {
   ICompatibleKeySystem,
@@ -79,7 +78,7 @@ const mediaCapabilitiesProber = {
    */
   getStatusForHDCP(hdcp: string) : Promise<string> {
     if (hdcp === undefined || hdcp.length === 0) {
-      return PPromise.reject("MediaCapabilitiesProbers >>> Bad Arguments: " +
+      return Promise.reject("MediaCapabilitiesProbers >>> Bad Arguments: " +
         "No HDCP Policy specified.");
     }
     const config = {
@@ -152,7 +151,7 @@ const mediaCapabilitiesProber = {
         })
       );
     });
-    return PPromise.all(promises)
+    return Promise.all(promises)
       .then((configs) => {
         // TODO I added those lines to work-around a type issue but does it
         // really correspond to the original intent? I find it hard to

package/src/experimental/tools/mediaCapabilitiesProber/api/probeMediaConfiguration.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PPromise from "../../../../utils/promise";
 import getProbedConfiguration, { ICapabilitiesTypes } from "../capabilities";
 import log from "../log";
 import probers, {
@@ -102,7 +101,7 @@ function probeMediaConfiguration(
     }
   }
 
-  return PPromise.all(promises).then(() => {
+  return Promise.all(promises).then(() => {
     if (globalStatus === undefined) {
       globalStatus = ProberStatus.Unknown;
     }

package/src/experimental/tools/mediaCapabilitiesProber/probers/DRMInfos.ts

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-import { lastValueFrom } from "rxjs";
 import { requestMediaKeySystemAccess } from "../../../../compat";
-import PPromise from "../../../../utils/promise";
 import log from "../log";
 import {
   ICompatibleKeySystem,
@@ -38,7 +36,7 @@ export default function probeDRMInfos(
 ): Promise<[ProberStatus, ICompatibleKeySystem?]> {
   const keySystem = mediaConfig.keySystem;
   if (keySystem == null || keySystem.type == null) {
-    return PPromise.reject("MediaCapabilitiesProber >>> API_CALL: " +
+    return Promise.reject("MediaCapabilitiesProber >>> API_CALL: " +
       "Missing a type argument to request a media key system access.");
   }
 
@@ -52,10 +50,10 @@ export default function probeDRMInfos(
       "Your browser has no API to request a media key system access.");
     // In that case, the API lack means that no EME workflow may be started.
     // So, the DRM configuration is not supported.
-    return PPromise.resolve([ProberStatus.NotSupported, result]);
+    return Promise.resolve([ProberStatus.NotSupported, result]);
   }
 
-  return lastValueFrom(requestMediaKeySystemAccess(type, [configuration]))
+  return requestMediaKeySystemAccess(type, [configuration])
     .then((keySystemAccess) => {
       result.compatibleConfiguration = keySystemAccess.getConfiguration();
       const status : [ProberStatus, ICompatibleKeySystem?] =

package/src/experimental/tools/mediaCapabilitiesProber/probers/HDCPPolicy.ts

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-import { lastValueFrom } from "rxjs";
 import { requestMediaKeySystemAccess } from "../../../../compat";
-import PPromise from "../../../../utils/promise";
 import {
   IMediaConfiguration,
   ProberStatus,
@@ -39,11 +37,11 @@ export default function probeHDCPPolicy(
   config: IMediaConfiguration
 ): Promise<[ProberStatus]> {
   if (requestMediaKeySystemAccess == null) {
-    return PPromise.reject("MediaCapabilitiesProber >>> API_CALL: " +
+    return Promise.reject("MediaCapabilitiesProber >>> API_CALL: " +
       "API not available");
   }
   if (config.hdcp == null) {
-    return PPromise.reject("MediaCapabilitiesProber >>> API_CALL: " +
+    return Promise.reject("MediaCapabilitiesProber >>> API_CALL: " +
       "Missing policy argument for calling getStatusForPolicy.");
   }
 
@@ -61,7 +59,7 @@ export default function probeHDCPPolicy(
     }],
   };
 
-  return lastValueFrom(requestMediaKeySystemAccess(keySystem, [drmConfig]))
+  return requestMediaKeySystemAccess(keySystem, [drmConfig])
     .then((mediaKeysSystemAccess) => {
       return mediaKeysSystemAccess.createMediaKeys().then((mediaKeys) => {
         if (!("getStatusForPolicy" in mediaKeys)) {

package/src/experimental/tools/mediaCapabilitiesProber/probers/decodingInfo.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "../../../../utils/promise";
 import {
   IMediaConfiguration,
   ProberStatus,
@@ -31,7 +30,7 @@ export interface IDecodingInfos {
  * @returns {Promise}
  */
 function isMediaCapabilitiesAPIAvailable(): Promise<void> {
-  return new PPromise((resolve) => {
+  return new Promise((resolve) => {
     if (!("mediaCapabilities" in navigator)) {
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "MediaCapabilities API not available");

package/src/experimental/tools/mediaCapabilitiesProber/probers/mediaContentType.ts

@@ -15,7 +15,6 @@
  */
 
 import { MediaSource_ } from "../../../../compat";
-import PPromise from "../../../../utils/promise";
 import {
   IMediaConfiguration,
   ProberStatus,
@@ -28,7 +27,7 @@ import {
 export default function probeContentType(
   config: IMediaConfiguration
 ): Promise<[ProberStatus]> {
-  return new PPromise((resolve) => {
+  return new Promise((resolve) => {
     if (MediaSource_ == null) {
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "MediaSource API not available");

package/src/experimental/tools/mediaCapabilitiesProber/probers/mediaContentTypeWithFeatures/index.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "../../../../../utils/promise";
 import {
   IMediaConfiguration,
   ProberStatus,
@@ -33,7 +32,7 @@ export type ISupportWithFeatures = ""|"Maybe"|"Not Supported"|"Probably";
  * @returns {Promise}
  */
 function isTypeSupportedWithFeaturesAPIAvailable(): Promise<void> {
-  return new PPromise((resolve) => {
+  return new Promise((resolve) => {
     if (!("MSMediaKeys" in window)) {
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "MSMediaKeys API not available");

package/src/experimental/tools/mediaCapabilitiesProber/probers/mediaDisplayInfos.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "../../../../utils/promise";
 import {
   IMediaConfiguration,
   ProberStatus,
@@ -27,7 +26,7 @@ import {
 export default function probeMatchMedia(
   config: IMediaConfiguration
 ): Promise<[ProberStatus]> {
-  return new PPromise((resolve) => {
+  return new Promise((resolve) => {
     /* eslint-disable @typescript-eslint/unbound-method */
     if (typeof window.matchMedia !== "function") {
     /* eslint-enable @typescript-eslint/unbound-method */

package/src/features/__tests__/initialize_features.test.ts

@@ -93,7 +93,7 @@ describe("Features - initializeFeaturesObject", () => {
       nativeTextTracksParsers: {},
       htmlTextTracksBuffer: null,
       htmlTextTracksParsers: {},
-      emeManager: null,
+      ContentDecryptor: null,
       directfile: null,
     };
     jest.mock("../features_object", () => ({
@@ -113,7 +113,7 @@ describe("Features - initializeFeaturesObject", () => {
         js: require("../../parsers/manifest/dash/js-parser").default,
         wasm: null,
       },
-      emeManager: require("../../core/eme/index").default,
+      ContentDecryptor: require("../../core/decrypt/index").default,
       directfile: {
         initDirectFile: require("../../core/init/initialize_directfile").default,
         mediaElementTrackChoiceManager:

package/src/features/features_object.ts

@@ -23,7 +23,7 @@ import { IFeaturesObject } from "./types";
 const features : IFeaturesObject = { dashParsers: { wasm: null,
                                                     js: null },
                                      directfile: null,
-                                     emeManager: null,
+                                     ContentDecryptor: null,
                                      htmlTextTracksBuffer: null,
                                      htmlTextTracksParsers: {},
                                      imageBuffer: null,

package/src/features/initialize_features.ts

@@ -27,7 +27,7 @@ import features from "./features_object";
  */
 export default function initializeFeaturesObject() : void {
   if (__FEATURES__.EME === __FEATURES__.IS_ENABLED as number) {
-    features.emeManager = require("../core/eme/index.ts").default;
+    features.ContentDecryptor = require("../core/decrypt/index.ts").default;
   }
 
   if (__FEATURES__.BIF_PARSER === __FEATURES__.IS_ENABLED as number) {

package/src/features/list/__tests__/eme.test.ts

@@ -17,20 +17,20 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 
-import emeManager from "../../../core/eme";
+import ContentDecryptor from "../../../core/decrypt";
 import addEMEFeature from "../eme";
 
-jest.mock("../../../core/eme", () => ({
+jest.mock("../../../core/decrypt", () => ({
   __esModule: true as const,
   default: jest.fn(),
 }));
 
 describe("Features list - EME", () => {
-  it("should add EME in the current features", () => {
+  it("should add the ContentDecryptor in the current features", () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const featureObject : any = {};
     addEMEFeature(featureObject);
-    expect(featureObject).toEqual({ emeManager });
-    expect(featureObject.emeManager).toBe(emeManager);
+    expect(featureObject).toEqual({ ContentDecryptor });
+    expect(featureObject.ContentDecryptor).toBe(ContentDecryptor);
   });
 });

package/src/features/list/eme.ts

@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-import EMEManager from "../../core/eme";
+import ContentDecryptor from "../../core/decrypt";
 import { IFeaturesObject } from "../types";
 
 /**
  * Add ability to play encrypted contents
  * @param {Object} features
  */
-function addEMEManagerFeature(features : IFeaturesObject) : void {
-  features.emeManager = EMEManager;
+function addEMEFeature(features : IFeaturesObject) : void {
+  features.ContentDecryptor = ContentDecryptor;
 }
 
-export { addEMEManagerFeature as EME };
-export default addEMEManagerFeature;
+export { addEMEFeature as EME };
+export default addEMEFeature;

package/src/features/types.ts

@@ -17,11 +17,7 @@
 import { Observable } from "rxjs";
 // eslint-disable-next-line max-len
 import MediaElementTrackChoiceManager from "../core/api/media_element_track_choice_manager";
-import {
-  IContentProtection,
-  IEMEManagerEvent,
-  IKeySystemOption,
-} from "../core/eme";
+import type ContentDecryptor from "../core/decrypt";
 import {
   IDirectfileEvent,
   IDirectFileOptions,
@@ -41,10 +37,7 @@ import { ITransportFunction } from "../transports";
 export type IDirectFileInit = (args : IDirectFileOptions) =>
                                 Observable<IDirectfileEvent>;
 
-export type IEMEManager = (mediaElement : HTMLMediaElement,
-                           keySystems: IKeySystemOption[],
-                           contentProtections$ : Observable<IContentProtection>) =>
-                             Observable<IEMEManagerEvent>;
+export type IContentDecryptorClass = typeof ContentDecryptor;
 
 export type IHTMLTextTracksBuffer =
   new(mediaElement : HTMLMediaElement,
@@ -89,7 +82,7 @@ export interface IFeaturesObject {
   directfile : { initDirectFile: IDirectFileInit;
                  mediaElementTrackChoiceManager : IMediaElementTrackChoiceManager; } |
                null;
-  emeManager : IEMEManager|null;
+  ContentDecryptor : IContentDecryptorClass|null;
   htmlTextTracksBuffer : IHTMLTextTracksBuffer|null;
   htmlTextTracksParsers : Partial<Record<string, IHTMLTextTracksParserFn>>;
   imageBuffer : IImageBuffer|null;

package/src/manifest/manifest.ts

@@ -14,13 +14,11 @@
  * limitations under the License.
  */
 
-import { IInitializationDataInfo } from "../core/eme";
 import {
   ICustomError,
   MediaError,
 } from "../errors";
 import { IParsedManifest } from "../parsers/manifest";
-import areArraysOfNumbersEqual from "../utils/are_arrays_of_numbers_equal";
 import arrayFind from "../utils/array_find";
 import EventEmitter from "../utils/event_emitter";
 import idGenerator from "../utils/id_generator";
@@ -502,73 +500,10 @@ export default class Manifest extends EventEmitter<IManifestEvents> {
    * changes performed.
    * @param {Object} keyUpdates
    */
-  public updateDeciperabilitiesBasedOnKeyIds(
-    { whitelistedKeyIds,
-      blacklistedKeyIDs } : { whitelistedKeyIds : Uint8Array[];
-                              blacklistedKeyIDs : Uint8Array[]; }
+  public updateRepresentationsDeciperability(
+    isDecipherableCb : (rep : Representation) => boolean | undefined
   ) : void {
-    const updates = updateDeciperability(this, (representation) => {
-      if (representation.decipherable === false ||
-          representation.contentProtections === undefined)
-      {
-        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 (areArraysOfNumbersEqual(blacklistedKeyIDs[j], elt.keyId)) {
-            return false;
-          }
-        }
-        for (let j = 0; j < whitelistedKeyIds.length; j++) {
-          if (areArraysOfNumbersEqual(whitelistedKeyIds[j], elt.keyId)) {
-            return true;
-          }
-        }
-      }
-      return representation.decipherable;
-    });
-
-    if (updates.length > 0) {
-      this.trigger("decipherabilityUpdate", updates);
-    }
-  }
-
-  /**
-   * Look in the Manifest for Representations linked to the given content
-   * protection initialization data and mark them as being impossible to
-   * decrypt.
-   * Then trigger a "decipherabilityUpdate" event to notify everyone of the
-   * changes performed.
-   * @param {Object} initData
-   */
-  public addUndecipherableProtectionData(initData : IInitializationDataInfo) : void {
-    const updates = updateDeciperability(this, (representation) => {
-      if (representation.decipherable === false) {
-        return false;
-      }
-      const segmentProtections = representation.contentProtections?.initData ?? [];
-      for (let i = 0; i < segmentProtections.length; i++) {
-        if (initData.type === undefined ||
-            segmentProtections[i].type === initData.type)
-        {
-          const containedInitData = initData.values.every(undecipherableVal => {
-            return segmentProtections[i].values.some(currVal => {
-              return (undecipherableVal.systemId === undefined ||
-                      currVal.systemId === undecipherableVal.systemId) &&
-                     areArraysOfNumbersEqual(currVal.data,
-                                             undecipherableVal.data);
-            });
-          });
-          if (containedInitData) {
-            return false;
-          }
-        }
-      }
-      return representation.decipherable;
-    });
-
+    const updates = updateDeciperability(this, isDecipherableCb);
     if (updates.length > 0) {
       this.trigger("decipherabilityUpdate", updates);
     }
@@ -795,14 +730,9 @@ function updateDeciperability(
   isDecipherable : (rep : Representation) => boolean | undefined
 ) : IDecipherabilityUpdateElement[] {
   const updates : IDecipherabilityUpdateElement[] = [];
-  for (let i = 0; i < manifest.periods.length; i++) {
-    const period = manifest.periods[i];
-    const adaptations = period.getAdaptations();
-    for (let j = 0; j < adaptations.length; j++) {
-      const adaptation = adaptations[j];
-      const representations = adaptation.representations;
-      for (let k = 0; k < representations.length; k++) {
-        const representation = representations[k];
+  for (const period of manifest.periods) {
+    for (const adaptation of period.getAdaptations()) {
+      for (const representation of adaptation.representations) {
         const result = isDecipherable(representation);
         if (result !== representation.decipherable) {
           updates.push({ manifest, period, adaptation, representation });

package/src/manifest/representation.ts

@@ -15,7 +15,6 @@
  */
 
 import { isCodecSupported } from "../compat";
-import { IContentProtection } from "../core/eme";
 import log from "../log";
 import {
   IContentProtections,
@@ -166,7 +165,7 @@ class Representation {
    * @param {string} drmSystemId - The hexa-encoded DRM system ID
    * @returns {Array.<Object>}
    */
-  public getEncryptionData(drmSystemId : string) : IContentProtection[] {
+  public getEncryptionData(drmSystemId : string) : IRepresentationProtectionData[] {
     const allInitData = this.getAllEncryptionData();
     const filtered = [];
     for (let i = 0; i < allInitData.length; i++) {
@@ -216,7 +215,7 @@ class Representation {
    * after parsing this Representation's initialization segment, if one exists.
    * @returns {Array.<Object>}
    */
-  public getAllEncryptionData() : IContentProtection[] {
+  public getAllEncryptionData() : IRepresentationProtectionData[] {
     if (this.contentProtections === undefined ||
         this.contentProtections.initData.length === 0)
     {
@@ -297,4 +296,38 @@ class Representation {
   }
 }
 
+/** Protection data as returned by a Representation. */
+export interface IRepresentationProtectionData {
+  /**
+   * 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;
+  }>;
+}
+
 export default Representation;