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

package/dist/es2017/parsers/manifest/dash/common/infer_adaptation_type.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { IRepresentationIntermediateRepresentation } from "../node_parser_types";
+/** Different "type" a parsed Adaptation can be. */
+type IAdaptationType = "audio" | "video" | "text";
+/** Structure of a parsed "scheme-like" element in the MPD. */
+interface IScheme {
+    schemeIdUri?: string | undefined;
+    value?: string | undefined;
+}
+/**
+ * Infers the type of adaptation from codec and mimetypes found in it.
+ *
+ * This follows the guidelines defined by the DASH-IF IOP:
+ *   - one adaptation set contains a single media type
+ *   - The order of verifications are:
+ *       1. mimeType
+ *       2. Role
+ *       3. codec
+ *
+ * Note: This is based on DASH-IF-IOP-v4.0 with some more freedom.
+ * @param {Array.<Object>} representations
+ * @param {string|null} adaptationMimeType
+ * @param {string|null} adaptationCodecs
+ * @param {Array.<Object>|null} adaptationRoles
+ * @returns {string} - "audio"|"video"|"text"|"metadata"|"unknown"
+ */
+export default function inferAdaptationType(representations: IRepresentationIntermediateRepresentation[], adaptationMimeType: string | null, adaptationCodecs: string | null, adaptationRoles: IScheme[] | null): IAdaptationType | undefined;
+export {};

package/dist/es2017/parsers/manifest/dash/common/infer_adaptation_type.js

@@ -0,0 +1,107 @@
+/**
+ * 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 { SUPPORTED_ADAPTATIONS_TYPE } from "../../../../manifest";
+import arrayFind from "../../../../utils/array_find";
+import arrayIncludes from "../../../../utils/array_includes";
+/** Different `role`s a text Adaptation can be. */
+const SUPPORTED_TEXT_TYPES = ["subtitle", "caption"];
+/**
+ * Infers the type of adaptation from codec and mimetypes found in it.
+ *
+ * This follows the guidelines defined by the DASH-IF IOP:
+ *   - one adaptation set contains a single media type
+ *   - The order of verifications are:
+ *       1. mimeType
+ *       2. Role
+ *       3. codec
+ *
+ * Note: This is based on DASH-IF-IOP-v4.0 with some more freedom.
+ * @param {Array.<Object>} representations
+ * @param {string|null} adaptationMimeType
+ * @param {string|null} adaptationCodecs
+ * @param {Array.<Object>|null} adaptationRoles
+ * @returns {string} - "audio"|"video"|"text"|"metadata"|"unknown"
+ */
+export default function inferAdaptationType(representations, adaptationMimeType, adaptationCodecs, adaptationRoles) {
+    function fromMimeType(mimeType, roles) {
+        const topLevel = mimeType.split("/")[0];
+        if (arrayIncludes(SUPPORTED_ADAPTATIONS_TYPE, topLevel)) {
+            return topLevel;
+        }
+        if (mimeType === "application/ttml+xml") {
+            return "text";
+        }
+        // manage DASH-IF mp4-embedded subtitles and metadata
+        if (mimeType === "application/mp4") {
+            if (roles != null) {
+                if (arrayFind(roles, (role) => role.schemeIdUri === "urn:mpeg:dash:role:2011" &&
+                    arrayIncludes(SUPPORTED_TEXT_TYPES, role.value)) != null) {
+                    return "text";
+                }
+            }
+            return undefined;
+        }
+    }
+    function fromCodecs(codecs) {
+        switch (codecs.substring(0, 3)) {
+            case "avc":
+            case "hev":
+            case "hvc":
+            case "vp8":
+            case "vp9":
+            case "av1":
+                return "video";
+            case "vtt":
+                return "text";
+        }
+        switch (codecs.substring(0, 4)) {
+            case "mp4a":
+                return "audio";
+            case "wvtt":
+            case "stpp":
+                return "text";
+        }
+    }
+    if (adaptationMimeType !== null) {
+        const typeFromMimeType = fromMimeType(adaptationMimeType, adaptationRoles);
+        if (typeFromMimeType !== undefined) {
+            return typeFromMimeType;
+        }
+    }
+    if (adaptationCodecs !== null) {
+        const typeFromCodecs = fromCodecs(adaptationCodecs);
+        if (typeFromCodecs !== undefined) {
+            return typeFromCodecs;
+        }
+    }
+    for (let i = 0; i < representations.length; i++) {
+        const representation = representations[i];
+        const { mimeType, codecs } = representation.attributes;
+        if (mimeType !== undefined) {
+            const typeFromMimeType = fromMimeType(mimeType, adaptationRoles);
+            if (typeFromMimeType !== undefined) {
+                return typeFromMimeType;
+            }
+        }
+        if (codecs !== undefined) {
+            const typeFromCodecs = fromCodecs(codecs);
+            if (typeFromCodecs !== undefined) {
+                return typeFromCodecs;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/es2017/parsers/manifest/dash/common/manifest_bounds_calculator.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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.
+ */
+/**
+ * This class allows to easily calculate the first and last available positions
+ * in a content at any time.
+ *
+ * That task can be an hard for dynamic DASH contents: it depends on a
+ * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
+ * position.
+ *
+ * The latter can come from either a clock synchronization mechanism or the
+ * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
+ * Periods.
+ * As such, it might only be known once a large chunk of the MPD has already
+ * been parsed.
+ *
+ * By centralizing the manifest bounds calculation in this class and by giving
+ * an instance of it to each parsed elements which might depend on it, we
+ * ensure that we can provide it once it is known to every one of those
+ * elements without needing to parse a second time the MPD.
+ * @class ManifestBoundsCalculator
+ */
+export default class ManifestBoundsCalculator {
+    /** Value of MPD@timeShiftBufferDepth. */
+    private _timeShiftBufferDepth;
+    /**
+     * Monotonically-raising timestamp (the one used by the RxPlayer) when
+     * `lastPosition` was calculated.
+     */
+    private _positionTime;
+    /** Last position calculated at a given moment (itself indicated by `_positionTime`. */
+    private _lastPosition;
+    /** `true` if MPD@type is equal to "dynamic". */
+    private _isDynamic;
+    /**
+     * @param {Object} args
+     */
+    constructor(args: {
+        timeShiftBufferDepth: number | undefined;
+        isDynamic: boolean;
+    });
+    /**
+     * Set the last position and the position time (the value of the RxPlayer's
+     * monotonically-raising timestamp at the time that position was true
+     * converted into seconds).
+     *
+     * @example
+     * Example if you trust `Date.now()` to give you a reliable offset:
+     * ```js
+     * const lastPosition = Date.now();
+     * const positionTime = getMonotonicTimeStamp() / 1000;
+     * manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
+     * ```
+     *
+     * @param {number} lastPosition
+     * @param {number|undefined} positionTime
+     */
+    setLastPosition(lastPosition: number, positionTime?: number): void;
+    /**
+     * Returns `true` if the last position and the position time
+     * (for dynamic content only) have been comunicated.
+     * `false` otherwise.
+     * @returns {boolean}
+     */
+    lastPositionIsKnown(): boolean;
+    /**
+     * Estimate a minimum bound for the content from the last set segment time
+     * and buffer depth.
+     * Consider that it is only an estimation, not the real value.
+     * @return {number|undefined}
+     */
+    estimateMinimumBound(): number | undefined;
+    /**
+     * Estimate a maximum bound for the content from the last set segment time.
+     * Consider that it is only an estimation, not the real value.
+     * @return {number|undefined}
+     */
+    estimateMaximumBound(): number | undefined;
+}

package/dist/es2017/parsers/manifest/dash/common/manifest_bounds_calculator.js

@@ -0,0 +1,111 @@
+/**
+ * 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 getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
+/**
+ * This class allows to easily calculate the first and last available positions
+ * in a content at any time.
+ *
+ * That task can be an hard for dynamic DASH contents: it depends on a
+ * `timeShiftBufferDepth` defined in the MPD and on the maximum possible
+ * position.
+ *
+ * The latter can come from either a clock synchronization mechanism or the
+ * indexing schemes (e.g. SegmentTemplate, SegmentTimeline etc.) of the last
+ * Periods.
+ * As such, it might only be known once a large chunk of the MPD has already
+ * been parsed.
+ *
+ * By centralizing the manifest bounds calculation in this class and by giving
+ * an instance of it to each parsed elements which might depend on it, we
+ * ensure that we can provide it once it is known to every one of those
+ * elements without needing to parse a second time the MPD.
+ * @class ManifestBoundsCalculator
+ */
+export default class ManifestBoundsCalculator {
+    /**
+     * @param {Object} args
+     */
+    constructor(args) {
+        this._isDynamic = args.isDynamic;
+        this._timeShiftBufferDepth = !args.isDynamic ||
+            args.timeShiftBufferDepth === undefined ?
+            null :
+            args.timeShiftBufferDepth;
+    }
+    /**
+     * Set the last position and the position time (the value of the RxPlayer's
+     * monotonically-raising timestamp at the time that position was true
+     * converted into seconds).
+     *
+     * @example
+     * Example if you trust `Date.now()` to give you a reliable offset:
+     * ```js
+     * const lastPosition = Date.now();
+     * const positionTime = getMonotonicTimeStamp() / 1000;
+     * manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
+     * ```
+     *
+     * @param {number} lastPosition
+     * @param {number|undefined} positionTime
+     */
+    setLastPosition(lastPosition, positionTime) {
+        this._lastPosition = lastPosition;
+        this._positionTime = positionTime;
+    }
+    /**
+     * Returns `true` if the last position and the position time
+     * (for dynamic content only) have been comunicated.
+     * `false` otherwise.
+     * @returns {boolean}
+     */
+    lastPositionIsKnown() {
+        if (this._isDynamic) {
+            return this._positionTime != null && this._lastPosition != null;
+        }
+        return this._lastPosition != null;
+    }
+    /**
+     * Estimate a minimum bound for the content from the last set segment time
+     * and buffer depth.
+     * Consider that it is only an estimation, not the real value.
+     * @return {number|undefined}
+     */
+    estimateMinimumBound() {
+        if (!this._isDynamic || this._timeShiftBufferDepth === null) {
+            return 0;
+        }
+        const maximumBound = this.estimateMaximumBound();
+        if (maximumBound === undefined) {
+            return undefined;
+        }
+        const minimumBound = maximumBound - this._timeShiftBufferDepth;
+        return minimumBound;
+    }
+    /**
+     * Estimate a maximum bound for the content from the last set segment time.
+     * Consider that it is only an estimation, not the real value.
+     * @return {number|undefined}
+     */
+    estimateMaximumBound() {
+        if (this._isDynamic &&
+            this._positionTime != null &&
+            this._lastPosition != null) {
+            return Math.max((this._lastPosition - this._positionTime) +
+                (getMonotonicTimeStamp() / 1000), 0);
+        }
+        return this._lastPosition;
+    }
+}

package/dist/es2017/parsers/manifest/dash/common/parse_adaptation_sets.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 { Period } from "../../../../manifest";
+import { IParsedAdaptations } from "../../types";
+import { IAdaptationSetIntermediateRepresentation, ISegmentTemplateIntermediateRepresentation } from "../node_parser_types";
+import { IRepresentationContext } from "./parse_representations";
+/**
+ * Process AdaptationSets intermediate representations to return under its final
+ * form.
+ * Note that the AdaptationSets returned are sorted by priority (from the most
+ * priority to the least one).
+ * @param {Array.<Object>} adaptationsIR
+ * @param {Object} context
+ * @returns {Array.<Object>}
+ */
+export default function parseAdaptationSets(adaptationsIR: IAdaptationSetIntermediateRepresentation[], context: IAdaptationSetContext): IParsedAdaptations;
+/** Context needed when calling `parseAdaptationSets`. */
+export interface IAdaptationSetContext extends IInheritedRepresentationContext {
+    /** SegmentTemplate parsed in the Period, if found. */
+    segmentTemplate?: ISegmentTemplateIntermediateRepresentation | undefined;
+    /**
+     * The parser should take this Period - which is from a previously parsed
+     * Manifest for the same dynamic content - as a base to speed-up the parsing
+     * process.
+     * /!\ If unexpected differences exist between both, there is a risk of
+     * de-synchronization with what is actually on the server,
+     * Use with moderation.
+     */
+    unsafelyBaseOnPreviousPeriod: Period | null;
+}
+/**
+ * Supplementary context needed to parse a Representation common with
+ * `IRepresentationContext`.
+ */
+type IInheritedRepresentationContext = Omit<IRepresentationContext, "unsafelyBaseOnPreviousAdaptation" | "parentSegmentTemplates">;
+export {};