rx-player 3.33.0 → 3.33.1

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/utils.test.ts

@@ -1,361 +0,0 @@
-/**
- * Copyright 2017 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 {
-  ICapabilities,
-  IMediaConfiguration,
-} from "../types";
-import {
-  extend,
-  filterConfigurationWithCapabilities,
-} from "../utils";
-
-describe("MediaCapabilitiesProber utils - extends", () => {
-  it("should return extender if target is empty", () => {
-    const target: ICapabilities = [];
-    const extenders: ICapabilities[] = [
-      [
-        "Pierre",
-        "Paul",
-        "Jacques",
-        { key: ["usb"] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        "Pierre",
-        "Paul",
-        "Jacques",
-        { key: ["usb"] },
-      ]
-    );
-  });
-
-  it("should return a mix of extenders if target is empty", () => {
-    const target: ICapabilities = [];
-    const extenders: ICapabilities[] = [
-      [
-        "Pierre",
-        "Paul",
-        "Jacques",
-        { key: ["usb"] },
-      ],
-      [
-        "Pierre",
-        "Paul",
-        "Jules",
-        { key: ["usb"] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        "Pierre",
-        "Paul",
-        "Jacques",
-        { key: ["usb"] },
-        "Jules",
-      ]
-    );
-  });
-
-  it("should return an empty extended object if target is empty", () => {
-    const target: ICapabilities = [];
-    const extenders: ICapabilities[] = [];
-    expect(extend(target, extenders)).toEqual([]);
-  });
-
-  it("should return target if no extenders", () => {
-    const target: ICapabilities = [
-      { key : ["usb"] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [];
-    expect(extend(target, extenders)).toEqual(target);
-  });
-
-  it("should extend target attributes if extender includes some new ones", () => {
-    const target: ICapabilities = [
-      { key : ["usb"] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [
-      [
-        "Paul",
-        "Jacques",
-        { key : ["usb", "flat-minor"] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        { key : ["usb", "flat-minor"] },
-        "Paul",
-        "Jacques",
-      ]
-    );
-  });
-
-  it("should extend target attributes if extender includes only new ones", () => {
-    const target: ICapabilities = [
-      { key : ["usb"] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [
-      [
-        "Jacques",
-        { key : ["flat-minor"] },
-        { planet: ["earth"] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        { key : ["usb", "flat-minor"] },
-        "Paul",
-        "Jacques",
-        { planet: ["earth"] },
-      ]
-    );
-  });
-
-  it("should extend target attributes if extenders includes some new ones", () => {
-    const target: ICapabilities = [
-      { key : ["usb"] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [
-      [
-        "Paul",
-        "Jacques",
-        { key : ["usb", "flat-minor"] },
-      ],
-      [
-        "Henry",
-        "Jacques",
-        { key : ["passphrase", "flat-minor"] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        { key : ["usb", "flat-minor", "passphrase"] },
-        "Paul",
-        "Jacques",
-        "Henry",
-      ]
-    );
-  });
-
-  it("should extend target attributes if extenders includes only new ones", () => {
-    const target: ICapabilities = [
-      { key : ["usb"] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [
-      [
-        "Jacques",
-        { key : ["flat-minor"] },
-      ],
-      [
-        "Henry",
-        { key : ["passphrase"] },
-        { planet: ["earth"] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        { key : ["usb", "flat-minor", "passphrase"] },
-        "Paul",
-        "Jacques",
-        "Henry",
-        { planet: ["earth"] },
-      ]
-    );
-  });
-
-  it("should extend target attributes if extender has an object with empty array", () => {
-    const target: ICapabilities = [
-      { key : ["usb"] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [
-      [
-        { key : [] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        { key : ["usb"] },
-        "Paul",
-      ]
-    );
-  });
-
-  it("should extend target if a shared object has an object child", () => {
-    const target: ICapabilities = [
-      { key : ["usb", { key: ["passphrase"] } ] },
-      "Paul",
-    ];
-    const extenders: ICapabilities[] = [
-      [
-        "Jacques",
-        { key : ["flat-minor"] },
-      ],
-      [
-        { key : [ { key: ["lock"] } ] },
-      ],
-    ];
-    expect(extend(target, extenders)).toEqual(
-      [
-        { key : ["usb", { key: ["passphrase", "lock"] }, "flat-minor"] },
-        "Paul",
-        "Jacques",
-      ]
-    );
-  });
-});
-
-describe("MediaCapabilitiesProber utils - filterConfigurationWithCapabilities", () => {
-  it("should normally filter a part of configuration", () => {
-    const configuration: IMediaConfiguration = {
-      type: "media-source",
-      video: {
-        contentType: "video/mp5",
-        width: 1920,
-        height: 1080,
-        bitrate: 3000,
-        framerate: "24000/1001",
-      },
-      audio: {
-        contentType: "audio/wma",
-        channels: "5.1",
-        bitrate: 128,
-        samplerate: 44100,
-      },
-    };
-
-    const capabilities: ICapabilities = [
-      "type",
-      { video : ["contentType", "width"] },
-    ];
-
-    expect(filterConfigurationWithCapabilities(capabilities, configuration)).toEqual(
-      {
-        type: "media-source",
-        video: {
-          contentType: "video/mp5",
-          width: 1920,
-        },
-      }
-    );
-  });
-
-  it("should return an empty conf if no capabilities", () => {
-    const configuration: IMediaConfiguration = {
-      type: "media-source",
-      video: {
-        contentType: "video/mp5",
-        width: 1920,
-        height: 1080,
-        bitrate: 3000,
-        framerate: "24000/1001",
-      },
-      audio: {
-        contentType: "audio/wma",
-        channels: "5.1",
-        bitrate: 128,
-        samplerate: 44100,
-      },
-    };
-
-    const capabilities: ICapabilities = [];
-
-    expect(filterConfigurationWithCapabilities(capabilities, configuration)).toEqual({});
-  });
-
-  it("should return an empty conf if unknown capabilities", () => {
-    const configuration: IMediaConfiguration = {
-      type: "media-source",
-      video: {
-        contentType: "video/mp5",
-        width: 1920,
-        height: 1080,
-        bitrate: 3000,
-        framerate: "24000/1001",
-      },
-      audio: {
-        contentType: "audio/wma",
-        channels: "5.1",
-        bitrate: 128,
-        samplerate: 44100,
-      },
-    };
-
-    const capabilities: ICapabilities = [
-      "text",
-      { video: ["gamma"] },
-    ];
-
-    expect(filterConfigurationWithCapabilities(capabilities, configuration)).toEqual({});
-  });
-
-  it("should return configuration if filter all capabilities", () => {
-    const configuration: IMediaConfiguration = {
-      type: "media-source",
-      video: {
-        contentType: "video/mp5",
-        width: 1920,
-        height: 1080,
-        bitrate: 3000,
-        framerate: "24000/1001",
-      },
-      audio: {
-        contentType: "audio/wma",
-        channels: "5.1",
-        bitrate: 128,
-        samplerate: 44100,
-      },
-    };
-
-    const capabilities: ICapabilities = [
-      "type",
-      { video: ["contentType", "width", "height", "bitrate", "framerate"] },
-      { audio: ["contentType", "channels", "bitrate", "samplerate"] },
-    ];
-
-    expect(filterConfigurationWithCapabilities(capabilities, configuration))
-      .toEqual(configuration);
-  });
-
-  it("should return an empty object with empty conf and non-empty capabilities", () => {
-    const configuration: IMediaConfiguration = {};
-
-    const capabilities: ICapabilities = [
-      "type",
-      { video: ["contentType", "width", "height", "bitrate", "framerate"] },
-      { audio: ["contentType", "channels", "bitrate", "samplerate"] },
-    ];
-
-    expect(filterConfigurationWithCapabilities(capabilities, configuration))
-      .toEqual({});
-  });
-
-  it("should return an empty object with empty conf and empty capabilities", () => {
-    const configuration: IMediaConfiguration = {};
-
-    const capabilities: ICapabilities = [];
-
-    expect(filterConfigurationWithCapabilities(capabilities, configuration))
-      .toEqual({});
-  });
-});

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

@@ -1,184 +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 arrayFind from "../../../../utils/array_find";
-import log from "../log";
-import {
-  ICompatibleKeySystem,
-  IDisplayConfiguration,
-  IMediaConfiguration,
-  IMediaKeySystemConfiguration,
-  ProberStatus,
-} from "../types";
-import probeMediaConfiguration, { IBrowserAPIS } from "./probeMediaConfiguration";
-
-/**
- * Probe configuration and get status from result.
- * @param {Object} config
- * @param {Array.<Object>} browserAPIS
- * @returns {Promise.<string>}
- */
-function getStatusFromConfiguration(
-  config: IMediaConfiguration,
-  browserAPIS: IBrowserAPIS[]
-): Promise<string> {
-  return probeMediaConfiguration(config, browserAPIS)
-    .then(({ globalStatus }) => {
-      switch (globalStatus) {
-        case ProberStatus.Unknown:
-          return "Unknown";
-        case ProberStatus.Supported:
-          return "Supported";
-      }
-      return "NotSupported";
-    });
-}
-
-/**
- * A set of API to probe media capabilites.
- * Each API allow to evalute a specific feature (HDCP support, decoding infos, etc)
- * and relies on different browser API to probe capabilites.
- */
-const mediaCapabilitiesProber = {
-
-  /**
-   * Set logger level
-   * @param {string} level
-   */
-  set LogLevel(level: string) {
-    log.setLevel(level);
-  },
-
-  /**
-   * Get logger level
-   * @returns {string}
-   */
-  get LogLevel() : string {
-    return log.getLevel();
-  },
-
-  /**
-   * Get HDCP status. Evaluates if current equipement support given
-   * HDCP revision.
-   * @param {string} hdcp
-   * @returns {Promise}
-   */
-  getStatusForHDCP(hdcp: string) : Promise<string> {
-    if (hdcp === undefined || hdcp.length === 0) {
-      return Promise.reject("MediaCapabilitiesProbers >>> Bad Arguments: " +
-        "No HDCP Policy specified.");
-    }
-    const config = {
-      hdcp,
-    };
-    const browserAPIS: IBrowserAPIS[] = [
-      "isTypeSupportedWithFeatures",
-      "getStatusForPolicy",
-    ];
-    return getStatusFromConfiguration (config, browserAPIS);
-  },
-
-  /**
-   * Get decoding capabilities from a given video and/or audio
-   * configuration.
-   * @param {Object} mediaConfig
-   * @returns {Promise}
-   */
-  getDecodingCapabilities(
-    mediaConfig: IMediaConfiguration
-  ) : Promise<string> {
-    const config = {
-      type: mediaConfig.type,
-      video: mediaConfig.video,
-      audio: mediaConfig.audio,
-    };
-    const browserAPIS: IBrowserAPIS[] = [
-      "isTypeSupported",
-      "isTypeSupportedWithFeatures",
-      "decodingInfos",
-    ];
-    return getStatusFromConfiguration(config, browserAPIS);
-  },
-
-  /**
-   * From an array of given configurations (type and key system configuration), return
-   * supported ones.
-   * @param {Array.<Object>} configurations
-   * @returns {Promise}
-   */
-  getCompatibleDRMConfigurations(
-    configurations: Array<{
-      type: string;
-      configuration: IMediaKeySystemConfiguration;
-    }>
-  ) : Promise<ICompatibleKeySystem[]> {
-    const promises: Array<Promise<{ globalStatus: ProberStatus;
-                                    result? : ICompatibleKeySystem | undefined; }>> = [];
-    configurations.forEach((configuration) => {
-      const globalConfig = {
-        keySystem: configuration,
-      };
-      const browserAPIS: IBrowserAPIS[] = ["requestMediaKeySystemAccess"];
-      promises.push(probeMediaConfiguration(globalConfig, browserAPIS)
-        .then(({ globalStatus, resultsFromAPIS }) => {
-          const requestMediaKeySystemAccessResults =
-            arrayFind(resultsFromAPIS,
-                      (result) => result.APIName === "requestMediaKeySystemAccess");
-
-          return {
-            // As only one API is called, global status is
-            // requestMediaKeySystemAccess status.
-            globalStatus,
-            result: requestMediaKeySystemAccessResults === undefined ? undefined :
-              requestMediaKeySystemAccessResults.result,
-          };
-        })
-        .catch(() => { // API couln't be called.
-          return { globalStatus: ProberStatus.NotSupported };
-        })
-      );
-    });
-    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
-        // understand and shouldn't we also rely on things like `globalStatus`
-        // here?
-        return configs
-          .filter((x) : x is { globalStatus : ProberStatus;
-                               result : ICompatibleKeySystem; } =>
-            x.result !== undefined)
-          .map(({ result }: { result: ICompatibleKeySystem }) => result);
-      });
-  },
-
-  /**
-   * Get display capabilites. Tells if display can output
-   * with specific video and/or audio constrains.
-   * @param {Object} displayConfig
-   * @returns {Promise}
-   */
-  getDisplayCapabilities(displayConfig: IDisplayConfiguration) : Promise<string> {
-    const config = { display: displayConfig };
-    const browserAPIS: IBrowserAPIS[] = [
-      "matchMedia",
-      "isTypeSupportedWithFeatures",
-    ];
-    return getStatusFromConfiguration(config, browserAPIS);
-  },
-};
-
-export default mediaCapabilitiesProber;

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

@@ -1,136 +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 getProbedConfiguration, { ICapabilitiesTypes } from "../capabilities";
-import log from "../log";
-import probers, {
-  IResultsFromAPI,
-} from "../probers";
-import {
-  IMediaConfiguration,
-  ProberStatus,
-} from "../types";
-
-export type IBrowserAPIS =
-  "isTypeSupported" |
-  "isTypeSupportedWithFeatures" |
-  "matchMedia" |
-  "decodingInfos" |
-  "requestMediaKeySystemAccess" |
-  "getStatusForPolicy";
-
-export interface IProbedMediaConfiguration {
-  globalStatus: ProberStatus;
-  resultsFromAPIS: Array<{
-    APIName: ICapabilitiesTypes;
-    result?: IResultsFromAPI | undefined;
-  }>;
-}
-
-/**
- * Probe media capabilities, evaluating capabilities with available browsers
- * API.
- *
- * Probe every given features with configuration.
- * If the browser API is not available OR we can't call browser API with enough
- * arguments, do nothing but warn the user (e.g. HDCP is not specified for
- * calling "getStatusForPolicy" API, "mediaCapabilites" API is not available.).
- *
- * From all API results, we return the worst state (e.g. if one API returns a
- * "Not Supported" status among other "Probably" statuses, we return
- * "Not Supported").
- *
- * @param {Object} config
- * @param {Array.<Object>} browserAPIS
- * @returns {Promise}
- */
-function probeMediaConfiguration(
-  config: IMediaConfiguration,
-  browserAPIS: IBrowserAPIS[]
-): Promise<IProbedMediaConfiguration> {
-  let globalStatus : ProberStatus|undefined;
-  const resultsFromAPIS: Array<{
-    APIName: ICapabilitiesTypes;
-    result: IResultsFromAPI | undefined;
-  }> = [];
-  const promises = [];
-  for (const browserAPI of browserAPIS) {
-    const probeWithBrowser = probers[browserAPI];
-    if (probeWithBrowser !== undefined) {
-      const prom = probeWithBrowser(config).then(([currentStatus, result]) => {
-        resultsFromAPIS.push({ APIName: browserAPI, result });
-
-        if (globalStatus == null) {
-          globalStatus = currentStatus;
-        } else {
-          switch (currentStatus) {
-            // Here, globalStatus can't be null. Hence, if the new current status is
-            // 'worse' than global status, then re-assign the latter.
-            case ProberStatus.NotSupported:
-              // `NotSupported` is either worse or equal.
-              globalStatus = ProberStatus.NotSupported;
-              break;
-            case ProberStatus.Unknown:
-              // `Unknown` is worse than 'Supported' only.
-              if (globalStatus === ProberStatus.Supported) {
-                globalStatus = ProberStatus.Unknown;
-              }
-              break;
-            default:
-              // new status is either `Supported` or unknown status. Global status
-              // shouldn't be changed.
-              break;
-          }
-        }
-      }).catch((error: unknown) => {
-        if (error instanceof Error) {
-          log.debug(error.message);
-        }
-      });
-      promises.push(prom);
-    }
-  }
-
-  return Promise.all(promises).then(() => {
-    if (globalStatus === undefined) {
-      globalStatus = ProberStatus.Unknown;
-    }
-
-    const probedCapabilities =
-      getProbedConfiguration(config, resultsFromAPIS.map((a) => a.APIName));
-    const areUnprobedCapabilities =
-      JSON.stringify(probedCapabilities).length !== JSON.stringify(config).length;
-
-    if (areUnprobedCapabilities && globalStatus === ProberStatus.Supported) {
-      globalStatus = ProberStatus.Unknown;
-    }
-
-    if (areUnprobedCapabilities) {
-      log.warn("MediaCapabilitiesProber >>> PROBER: Some capabilities " +
-        "could not be probed, due to the incompatibility of browser APIs, or the " +
-        "lack of arguments to call them. See debug logs for more details.");
-    }
-
-    if (log.hasLevel("INFO")) {
-      log.info("MediaCapabilitiesProber >>> PROBER: Probed capabilities: ",
-               JSON.stringify(probedCapabilities));
-    }
-
-    return { globalStatus, resultsFromAPIS };
-  });
-}
-
-export default probeMediaConfiguration;