rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/es2017/parsers/manifest/smooth/parse_C_nodes.js

@@ -0,0 +1,69 @@
+/**
+ * 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 isNonEmptyString from "../../../utils/is_non_empty_string";
+/**
+ * Parse C nodes to build index timeline.
+ * @param {Object} nodes
+ */
+export default function parseCNodes(nodes) {
+    return nodes.reduce((timeline, node, i) => {
+        var _a, _b, _c, _d;
+        if (typeof node === "string") {
+            return timeline;
+        }
+        const dAttr = (_a = node.attributes.d) !== null && _a !== void 0 ? _a : null;
+        const tAttr = (_b = node.attributes.t) !== null && _b !== void 0 ? _b : null;
+        const rAttr = (_c = node.attributes.r) !== null && _c !== void 0 ? _c : null;
+        const repeatCount = rAttr !== null ? +rAttr - 1 : 0;
+        let start = tAttr !== null ? +tAttr : undefined;
+        let 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];
+            if (start === undefined || isNaN(start)) {
+                if (prev.duration === undefined || isNaN(prev.duration)) {
+                    throw new Error("Smooth: Invalid CNodes. Missing timestamp.");
+                }
+                start = prev.start + prev.duration * (prev.repeatCount + 1);
+            }
+        }
+        if (duration === undefined || isNaN(duration)) {
+            let nextNodeIdx = i;
+            let nextNodeElt;
+            do {
+                nextNodeIdx++;
+                nextNodeElt = nodes[nextNodeIdx];
+            } while (nextNodeElt !== undefined && typeof nextNodeElt === "string");
+            if (nextNodeElt !== undefined) {
+                const nextTAttr = (_d = nextNodeElt.attributes.t) !== null && _d !== void 0 ? _d : null;
+                const nextStart = isNonEmptyString(nextTAttr) ? +nextTAttr : null;
+                if (nextStart === null) {
+                    throw new Error("Can't build index timeline from Smooth Manifest.");
+                }
+                duration = nextStart - start;
+            }
+            else {
+                return timeline;
+            }
+        }
+        timeline.push({ duration, start, repeatCount });
+        return timeline;
+    }, []);
+}

package/dist/es2017/parsers/manifest/smooth/parse_protection_node.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 type { ITNode } from "../../../utils/xml-parser";
+export interface IKeySystem {
+    systemId: string;
+    privateData: Uint8Array<ArrayBuffer>;
+}
+export interface IContentProtectionSmooth {
+    keyId: Uint8Array<ArrayBuffer>;
+    keySystems: IKeySystem[];
+}
+/**
+ * Parse "Protection" Node, which contains DRM information
+ * @param {Object} protectionNode
+ * @returns {Object}
+ */
+export default function parseProtectionNode(protectionNode: ITNode, keySystemCreator?: (keyId: Uint8Array) => IKeySystem[]): IContentProtectionSmooth;
+//# sourceMappingURL=parse_protection_node.d.ts.map

package/dist/es2017/parsers/manifest/smooth/parse_protection_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_protection_node.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/manifest/smooth/parse_protection_node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAGxD,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IAC/B,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B;AAeD;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,cAAc,EAAE,MAAM,EACtB,gBAAgB,GAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,EAA4B,GAC9E,wBAAwB,CAsC1B"}

package/dist/es2017/parsers/manifest/smooth/parse_protection_node.js

@@ -0,0 +1,71 @@
+/**
+ * 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 { 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", // Widevine
+            privateData: concat([0x08, 0x01, 0x12, 0x10], keyIdBytes),
+        },
+    ];
+}
+/**
+ * Parse "Protection" Node, which contains DRM information
+ * @param {Object} protectionNode
+ * @returns {Object}
+ */
+export default function parseProtectionNode(protectionNode, keySystemCreator = createWidevineKeySystem) {
+    var _a;
+    let header;
+    for (const subNode of protectionNode.children) {
+        if (typeof subNode === "string") {
+            continue;
+        }
+        if (subNode.tagName === "ProtectionHeader") {
+            header = subNode;
+            break;
+        }
+    }
+    if (header === undefined) {
+        throw new Error("Protection should have ProtectionHeader child");
+    }
+    const privateData = base64ToBytes(typeof header.children[0] === "string" ? header.children[0] : "");
+    const keyIdHex = getPlayReadyKIDFromPrivateData(privateData);
+    const keyIdBytes = hexToBytes(keyIdHex);
+    // remove possible braces
+    const systemIdAttr = (_a = header.attributes.SystemID) !== null && _a !== void 0 ? _a : null;
+    const systemId = (systemIdAttr !== null ? systemIdAttr : "")
+        .toLowerCase()
+        .replace(/\{|\}/g, "");
+    const supplementaryKeySystems = keySystemCreator(keyIdBytes);
+    return {
+        keyId: keyIdBytes,
+        keySystems: [
+            {
+                systemId,
+                privateData,
+                /* keyIds: [keyIdBytes], */
+            },
+        ].concat(supplementaryKeySystems),
+    };
+}

package/dist/es2017/parsers/manifest/smooth/representation_index.d.ts

@@ -0,0 +1,242 @@
+/**
+ * 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 type { IRepresentationIndex, ISegment } from "../../../manifest";
+import type { IPlayerError } from "../../../public_types";
+import type SharedSmoothSegmentTimeline from "./shared_smooth_segment_timeline";
+/**
+ * Supplementary options taken by a SmoothRepresentationIndex bringing the
+ * context the segments are in.
+ */
+export interface ISmoothRepresentationIndexContextInformation {
+    /**
+     * 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;
+    /**
+     * Contains information allowing to generate the corresponding initialization
+     * segment.
+     */
+    segmentPrivateInfos: ISmoothInitSegmentPrivateInfos;
+    sharedSmoothTimeline: SharedSmoothSegmentTimeline;
+}
+/** Information allowing to generate a Smooth initialization segment. */
+interface ISmoothInitSegmentPrivateInfos {
+    bitsPerSample?: number | undefined;
+    channels?: number | undefined;
+    codecPrivateData?: string | undefined;
+    packetSize?: number | undefined;
+    samplingRate?: number | undefined;
+    protection?: {
+        keyId: Uint8Array;
+    } | undefined;
+    height?: number | undefined;
+    width?: number | undefined;
+}
+/**
+ * RepresentationIndex implementation for Smooth Manifests.
+ *
+ * Allows to interact with the index to create new Segments.
+ *
+ * @class SmoothRepresentationIndex
+ */
+export default class SmoothRepresentationIndex implements IRepresentationIndex {
+    /**
+     * Information needed to generate an initialization segment.
+     * Taken from the Manifest.
+     */
+    private _initSegmentInfos;
+    /**
+     * 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.
+     * Useful to know if a segment present in the timeline has actually been
+     * generated on the server-side
+     */
+    private _scaledLiveGap;
+    /**
+     * Defines the end of the latest available segment when this index was known to
+     * be valid, in the index's timescale.
+     */
+    private _initialScaledLastPosition;
+    /**
+     * If `true` the corresponding Smooth Manifest was announced as a live
+     * content.
+     * `false` otherwise.
+     */
+    private _isLive;
+    /**
+     * 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;
+    /**
+     * Creates a new `SmoothRepresentationIndex`.
+     * @param {Object} index
+     * @param {Object} options
+     */
+    constructor(options: ISmoothRepresentationIndexContextInformation);
+    /**
+     * Construct init Segment compatible with a Smooth Manifest.
+     * @returns {Object}
+     */
+    getInitSegment(): ISegment;
+    /**
+     * Generate a list of Segments for a particular period of time.
+     *
+     * @param {Number} from
+     * @param {Number} dur
+     * @returns {Array.<Object>}
+     */
+    getSegments(from: number, dur: number): ISegment[];
+    /**
+     * Returns true if, based on the arguments, the index should be refreshed.
+     * (If we should re-fetch the manifest)
+     * @param {Number} up
+     * @param {Number} to
+     * @returns {Boolean}
+     */
+    shouldRefresh(up: number, to: number): boolean;
+    /**
+     * Returns first position available in the index.
+     * @returns {Number|null}
+     */
+    getFirstAvailablePosition(): number | null;
+    /**
+     * Returns last position available in the index.
+     * @returns {Number}
+     */
+    getLastAvailablePosition(): number | undefined;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | null | undefined;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
+    /**
+     * Checks if `timeSec` is in a discontinuity.
+     * That is, if there's no segment available for the `timeSec` position.
+     * @param {number} timeSec - The time to check if it's in a discontinuity, in
+     * seconds.
+     * @returns {number | null} - If `null`, no discontinuity is encountered at
+     * `time`. If this is a number instead, there is one and that number is the
+     * position for which a segment is available in seconds.
+     */
+    checkDiscontinuity(timeSec: number): number | null;
+    /**
+     * Returns `true` if a Segment returned by this index is still considered
+     * available.
+     * Returns `false` if it is not available anymore.
+     * Returns `undefined` if we cannot know whether it is still available or not.
+     * @param {Object} segment
+     * @returns {Boolean|undefined}
+     */
+    isSegmentStillAvailable(segment: ISegment): boolean | undefined;
+    /**
+     * @param {Error} error
+     * @returns {Boolean}
+     */
+    canBeOutOfSyncError(error: IPlayerError): boolean;
+    /**
+     * Returns the `duration` of each segment in the context of its Manifest (i.e.
+     * as the Manifest anounces them, actual segment duration may be different due
+     * to approximations), in seconds.
+     *
+     * NOTE: we could here do a median or a mean but I chose to be lazy (and
+     * more performant) by returning the duration of the first element instead.
+     * As `isPrecize` is `false`, the rest of the code should be notified that
+     * this is only an approximation.
+     * @returns {number}
+     */
+    getTargetSegmentDuration(): {
+        duration: number;
+        isPrecize: boolean;
+    } | undefined;
+    /**
+     * Replace this RepresentationIndex by a newly downloaded one.
+     * Check if the old index had more information about new segments and re-add
+     * them if that's the case.
+     * @param {Object} newIndex
+     */
+    _replace(newIndex: SmoothRepresentationIndex): void;
+    /**
+     * Update the current index with a new, partial, version.
+     * This method might be use to only add information about new segments.
+     * @param {Object} newIndex
+     */
+    _update(newIndex: SmoothRepresentationIndex): void;
+    /**
+     * Returns `false` if the last segments in this index have already been
+     * generated.
+     * Returns `true` if the index is still waiting on future segments to be
+     * generated.
+     *
+     * For Smooth, it should only depend on whether the content is a live content
+     * or not.
+     * TODO What about Smooth live content that finishes at some point?
+     * @returns {boolean}
+     */
+    isStillAwaitingFutureSegments(): boolean;
+    /**
+     * @returns {Boolean}
+     */
+    isInitialized(): true;
+    initialize(): void;
+    /**
+     * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
+     * after `currentSegment`.
+     * @param {Array.<Object>} nextSegments - The segment information parsed.
+     * @param {Object} currentSegment - Information on the segment which contained
+     * that new segment information.
+     */
+    addPredictedSegments(nextSegments: Array<{
+        duration: number;
+        time: number;
+        timescale: number;
+    }>, currentSegment: ISegment): void;
+    /**
+     * Clean-up timeline to remove segment information which should not be
+     * available due to the timeshift window
+     */
+    private _refreshTimeline;
+}
+export {};
+//# sourceMappingURL=representation_index.d.ts.map

package/dist/es2017/parsers/manifest/smooth/representation_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"representation_index.d.ts","sourceRoot":"","sources":["../../../../../src/parsers/manifest/smooth/representation_index.ts"],"names":[],"mappings":"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"}