rx-player 4.0.0-dev.2023102700 → 4.0.0-dev.2023111400

package/dist/_esm5.processed/parsers/manifest/smooth/get_codecs.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,21 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoCodecs = exports.getAudioCodecs = void 0;
-const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
+import isNonEmptyString from "../../../utils/is_non_empty_string";
 /**
  * @param {string} codecPrivateData
  * @param {string|undefined} fourCC
  * @returns {string}
  */
-function getAudioCodecs(codecPrivateData, fourCC) {
-    let mpProfile;
+export function getAudioCodecs(codecPrivateData, fourCC) {
+    var mpProfile;
     if (fourCC === "AACH") {
         mpProfile = 5; // High Efficiency AAC Profile
     }
     else {
-        mpProfile = (0, is_non_empty_string_1.default)(codecPrivateData) ?
+        mpProfile = isNonEmptyString(codecPrivateData) ?
             (parseInt(codecPrivateData.substring(0, 2), 16) & 0xF8) >> 3 :
             2;
     }
@@ -36,20 +33,18 @@ function getAudioCodecs(codecPrivateData, fourCC) {
         // Return default audio codec
         return "mp4a.40.2";
     }
-    return `mp4a.40.${mpProfile}`;
+    return "mp4a.40.".concat(mpProfile);
 }
-exports.getAudioCodecs = getAudioCodecs;
 /**
  * @param {string} codecPrivateData
  * @returns {string}
  */
-function getVideoCodecs(codecPrivateData) {
+export function getVideoCodecs(codecPrivateData) {
     // we can extract codes only if fourCC is on of "H264", "X264", "DAVC", "AVC1"
-    const arr = /00000001\d7([0-9a-fA-F]{6})/.exec(codecPrivateData);
-    if (arr === null || !(0, is_non_empty_string_1.default)(arr[1])) {
+    var arr = /00000001\d7([0-9a-fA-F]{6})/.exec(codecPrivateData);
+    if (arr === null || !isNonEmptyString(arr[1])) {
         // Return default video codec
         return "avc1.4D401E";
     }
     return "avc1." + arr[1];
 }
-exports.getVideoCodecs = getVideoCodecs;

package/dist/_esm5.processed/parsers/manifest/smooth/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,9 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SmoothRepresentationIndex = void 0;
-const create_parser_1 = require("./create_parser");
-const representation_index_1 = require("./representation_index");
-exports.SmoothRepresentationIndex = representation_index_1.default;
-exports.default = create_parser_1.default;
+import createSmoothStreamingParser from "./create_parser";
+import SmoothRepresentationIndex from "./representation_index";
+export default createSmoothStreamingParser;
+export { SmoothRepresentationIndex, };

package/dist/_esm5.processed/parsers/manifest/smooth/parse_C_nodes.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,26 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
+import isNonEmptyString from "../../../utils/is_non_empty_string";
 /**
  * Parse C nodes to build index timeline.
  * @param {Element} nodes
  */
-function parseCNodes(nodes) {
-    return nodes.reduce((timeline, node, i) => {
-        const dAttr = node.getAttribute("d");
-        const tAttr = node.getAttribute("t");
-        const rAttr = node.getAttribute("r");
-        const repeatCount = rAttr !== null ? +rAttr - 1 : 0;
-        let start = tAttr !== null ? +tAttr : undefined;
-        let duration = dAttr !== null ? +dAttr : undefined;
+export default function parseCNodes(nodes) {
+    return nodes.reduce(function (timeline, node, i) {
+        var dAttr = node.getAttribute("d");
+        var tAttr = node.getAttribute("t");
+        var rAttr = node.getAttribute("r");
+        var repeatCount = rAttr !== null ? +rAttr - 1 : 0;
+        var start = tAttr !== null ? +tAttr : undefined;
+        var duration = dAttr !== null ? +dAttr : undefined;
         if (i === 0) { // first node
             start = start === undefined || isNaN(start) ? 0 :
                 start;
         }
         else { // from second node to the end
-            const prev = timeline[i - 1];
+            var prev = timeline[i - 1];
             if (start == null || isNaN(start)) {
                 if (prev.duration == null || isNaN(prev.duration)) {
                     throw new Error("Smooth: Invalid CNodes. Missing timestamp.");
@@ -42,10 +40,10 @@ function parseCNodes(nodes) {
             }
         }
         if (duration == null || isNaN(duration)) {
-            const nextNode = nodes[i + 1];
+            var nextNode = nodes[i + 1];
             if (nextNode !== undefined) {
-                const nextTAttr = nextNode.getAttribute("t");
-                const nextStart = (0, is_non_empty_string_1.default)(nextTAttr) ? +nextTAttr :
+                var nextTAttr = nextNode.getAttribute("t");
+                var nextStart = isNonEmptyString(nextTAttr) ? +nextTAttr :
                     null;
                 if (nextStart === null) {
                     throw new Error("Can't build index timeline from Smooth Manifest.");
@@ -56,8 +54,7 @@ function parseCNodes(nodes) {
                 return timeline;
             }
         }
-        timeline.push({ duration, start, repeatCount });
+        timeline.push({ duration: duration, start: start, repeatCount: repeatCount });
         return timeline;
     }, []);
 }
-exports.default = parseCNodes;

package/dist/_esm5.processed/parsers/manifest/smooth/parse_protection_node.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,47 +13,46 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const base64_1 = require("../../../utils/base64");
-const byte_parsing_1 = require("../../../utils/byte_parsing");
-const string_parsing_1 = require("../../../utils/string_parsing");
-const isobmff_1 = require("../../containers/isobmff");
+import { base64ToBytes } from "../../../utils/base64";
+import { concat } from "../../../utils/byte_parsing";
+import { hexToBytes } from "../../../utils/string_parsing";
+import { getPlayReadyKIDFromPrivateData } from "../../containers/isobmff";
 /**
  * @param {Uint8Array} keyIdBytes
  * @returns {Array.<Object>}
  */
 function createWidevineKeySystem(keyIdBytes) {
     return [{ systemId: "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed",
-            privateData: (0, byte_parsing_1.concat)([0x08, 0x01, 0x12, 0x10], keyIdBytes) }];
+            privateData: concat([0x08, 0x01, 0x12, 0x10], keyIdBytes) }];
 }
 /**
  * Parse "Protection" Node, which contains DRM information
  * @param {Element} protectionNode
  * @returns {Object}
  */
-function parseProtectionNode(protectionNode, keySystemCreator = createWidevineKeySystem) {
+export default function parseProtectionNode(protectionNode, keySystemCreator) {
+    if (keySystemCreator === void 0) { keySystemCreator = createWidevineKeySystem; }
     if (protectionNode.firstElementChild === null ||
         protectionNode.firstElementChild.nodeName !== "ProtectionHeader") {
         throw new Error("Protection should have ProtectionHeader child");
     }
-    const header = protectionNode.firstElementChild;
-    const privateData = (0, base64_1.base64ToBytes)(header.textContent === null ? "" :
+    var header = protectionNode.firstElementChild;
+    var privateData = base64ToBytes(header.textContent === null ? "" :
         header.textContent);
-    const keyIdHex = (0, isobmff_1.getPlayReadyKIDFromPrivateData)(privateData);
-    const keyIdBytes = (0, string_parsing_1.hexToBytes)(keyIdHex);
+    var keyIdHex = getPlayReadyKIDFromPrivateData(privateData);
+    var keyIdBytes = hexToBytes(keyIdHex);
     // remove possible braces
-    const systemIdAttr = header.getAttribute("SystemID");
-    const systemId = (systemIdAttr !== null ? systemIdAttr :
+    var systemIdAttr = header.getAttribute("SystemID");
+    var systemId = (systemIdAttr !== null ? systemIdAttr :
         "")
         .toLowerCase()
         .replace(/\{|\}/g, "");
     return {
         keyId: keyIdBytes,
         keySystems: [{
-                systemId,
-                privateData,
+                systemId: systemId,
+                privateData: privateData,
                 /* keyIds: [keyIdBytes], */
             }].concat(keySystemCreator(keyIdBytes)),
     };
 }
-exports.default = parseProtectionNode;

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.d.ts

@@ -15,29 +15,79 @@
  */
 import { IRepresentationIndex, ISegment } from "../../../manifest";
 import { IPlayerError } from "../../../public_types";
-import SharedSmoothSegmentTimeline from "./shared_smooth_segment_timeline";
+/**
+ * Object describing information about one segment or several consecutive
+ * segments.
+ */
+export interface IIndexSegment {
+    /** Time (timescaled) at which the segment starts. */
+    start: number;
+    /** Duration (timescaled) of the segment. */
+    duration: number;
+    /**
+     * Amount of consecutive segments with that duration.
+     *
+     * For example let's consider the following IIndexSegment:
+     * ```
+     * { start: 10, duration: 2, repeatCount: 2 }
+     * ```
+     * Here, because `repeatCount` is set to `2`, this object actually defines 3
+     * segments:
+     *   1. one starting at `10` and ending at `12` (10 + 2)
+     *   2. another one starting at `12` (the previous one's end) and ending at
+     *      `14` (12 + 2)
+     *   3. another one starting at `14` (the previous one's end) and ending at
+     *      `16` (14 +2)
+     */
+    repeatCount: number;
+}
+/**
+ * Object containing information about the segments available in a
+ * `SmoothRepresentationIndex`.
+ */
+interface ITimelineIndex {
+    /**
+     * "Timescale" used here allowing to convert the time in this object into
+     * seconds (by doing `time / timescale`).
+     */
+    timescale: number;
+    /**
+     * Generic tokenized (e.g. with placeholders for time information) URL for
+     * every segments anounced here.
+     */
+    media: string;
+    /** Contains information about all segments available here. */
+    timeline: IIndexSegment[];
+}
 /**
  * Supplementary options taken by a SmoothRepresentationIndex bringing the
  * context the segments are in.
  */
 export interface ISmoothRepresentationIndexContextInformation {
+    /**
+     * if `true`, the `SmoothRepresentationIndex` will return segments even if
+     * we're not sure they had time to be generated on the server side.
+     *
+     * TODO(Paul B.) This is a somewhat ugly option, only here for very specific
+     * Canal+ use-cases for now (most of all for Peer-to-Peer efficiency),
+     * scheduled to be removed in a next major version.
+     */
+    aggressiveMode: boolean;
     /**
      * If `true` the corresponding Smooth Manifest was announced as a live
      * content.
      * `false` otherwise.
      */
     isLive: boolean;
-    /**
-     * Generic tokenized (e.g. with placeholders for time information) URL for
-     * every segments anounced here.
-     */
-    media: string;
+    /** Value of `performance.now()` when the Manifest request was finished. */
+    manifestReceivedTime: number | undefined;
     /**
      * Contains information allowing to generate the corresponding initialization
      * segment.
      */
     segmentPrivateInfos: ISmoothInitSegmentPrivateInfos;
-    sharedSmoothTimeline: SharedSmoothSegmentTimeline;
+    /** Depth of the DVR window, in seconds. */
+    timeShiftBufferDepth: number | undefined;
 }
 /** Information allowing to generate a Smooth initialization segment. */
 interface ISmoothInitSegmentPrivateInfos {
@@ -49,8 +99,6 @@ interface ISmoothInitSegmentPrivateInfos {
     protection?: {
         keyId: Uint8Array;
     } | undefined;
-    height?: number | undefined;
-    width?: number | undefined;
 }
 /**
  * RepresentationIndex implementation for Smooth Manifests.
@@ -65,12 +113,21 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Taken from the Manifest.
      */
     private _initSegmentInfos;
+    /**
+     * if `true`, this class will return segments even if we're not sure they had
+     * time to be generated on the server side.
+     *
+     * This is a somewhat ugly option, only here for very specific Canal+
+     * use-cases for now (most of all for Peer-to-Peer efficiency), scheduled to
+     * be removed in a next major version.
+     */
+    private _isAggressiveMode;
     /**
      * Value only calculated for live contents.
      *
-     * Calculates the difference, in timescale, between the monotonically-raising
-     * timestamp used by the RxPlayer and the time of the last segment known to
-     * have been generated on the server-side.
+     * Calculates the difference, in timescale, between the current time (as
+     * calculated via performance.now()) and the time of the last segment known
+     * to have been generated on the server-side.
      * Useful to know if a segment present in the timeline has actually been
      * generated on the server-side
      */
@@ -80,6 +137,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * be valid, in the index's timescale.
      */
     private _initialScaledLastPosition;
+    /**
+     * Defines the earliest time when this index was known to be valid (that is, when
+     * all segments declared in it are available). This means either:
+     *   - the manifest downloading time, if known
+     *   - else, the time of creation of this RepresentationIndex, as the best guess
+     */
+    private _indexValidityTime;
     /**
      * If `true` the corresponding Smooth Manifest was announced as a live
      * content.
@@ -90,18 +154,15 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Contains information on the list of segments available in this
      * SmoothRepresentationIndex.
      */
-    private _sharedSmoothTimeline;
-    /**
-     * Generic tokenized (e.g. with placeholders for time information) URL for
-     * every segments anounced here.
-     */
-    private _media;
+    private _index;
+    /** Depth of the DVR window anounced in the Manifest, in seconds. */
+    private _timeShiftBufferDepth;
     /**
      * Creates a new `SmoothRepresentationIndex`.
      * @param {Object} index
      * @param {Object} options
      */
-    constructor(options: ISmoothRepresentationIndexContextInformation);
+    constructor(index: ITimelineIndex, options: ISmoothRepresentationIndexContextInformation);
     /**
      * Construct init Segment compatible with a Smooth Manifest.
      * @returns {Object}
@@ -204,19 +265,20 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * @returns {Boolean}
      */
     isInitialized(): true;
-    initialize(): void;
     /**
-     * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
-     * after `currentSegment`.
+     * Add new segments to a `SmoothRepresentationIndex`.
      * @param {Array.<Object>} nextSegments - The segment information parsed.
      * @param {Object} segment - Information on the segment which contained that
      * new segment information.
      */
-    addPredictedSegments(nextSegments: Array<{
+    addNewSegments(nextSegments: Array<{
         duration: number;
         time: number;
         timescale: number;
-    }>, currentSegment: ISegment): void;
+    }>, currentSegment: {
+        duration: number;
+        time: number;
+    }): void;
     /**
      * Clean-up timeline to remove segment information which should not be
      * available due to the timeshift window