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

package/dist/_esm5.processed/transports/smooth/segment_loader.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,187 +13,186 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../errors");
-const assert_1 = require("../../utils/assert");
-const request_1 = require("../../utils/request");
-const byte_range_1 = require("../utils/byte_range");
-const check_isobmff_integrity_1 = require("../utils/check_isobmff_integrity");
-const is_mp4_embedded_track_1 = require("./is_mp4_embedded_track");
-const isobmff_1 = require("./isobmff");
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { CustomLoaderError } from "../../errors";
+import assert from "../../utils/assert";
+import request from "../../utils/request";
+import byteRange from "../utils/byte_range";
+import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
+import { createAudioInitSegment, createVideoInitSegment, } from "./isobmff";
+import { isMP4EmbeddedTrack } from "./utils";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
  * @param {string} url
- * @param {Object} context
+ * @param {Object} content
  * @param {Object} loaderOptions
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  * @param {boolean} checkMediaSegmentIntegrity
  * @returns {Promise}
  */
-function regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
-    let headers;
-    const range = context.segment.range;
+function regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity) {
+    var headers;
+    var range = content.segment.range;
     if (Array.isArray(range)) {
-        headers = { Range: (0, byte_range_1.default)(range) };
+        headers = { Range: byteRange(range) };
     }
-    return (0, request_1.default)({ url,
-        responseType: "arraybuffer",
-        headers,
-        timeout: loaderOptions.timeout,
-        cancelSignal,
-        onProgress: callbacks.onProgress })
-        .then((data) => {
-        const isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
+    return request({ url: url, responseType: "arraybuffer", headers: headers, timeout: loaderOptions.timeout, cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+        .then(function (data) {
+        var isMP4 = isMP4EmbeddedTrack(content.representation);
         if (!isMP4 || checkMediaSegmentIntegrity !== true) {
             return { resultType: "segment-loaded",
                 resultData: data };
         }
-        const dataU8 = new Uint8Array(data.responseData);
-        (0, check_isobmff_integrity_1.default)(dataU8, context.segment.isInit);
+        var dataU8 = new Uint8Array(data.responseData);
+        checkISOBMFFIntegrity(dataU8, content.segment.isInit);
         return { resultType: "segment-loaded",
-            resultData: Object.assign(Object.assign({}, data), { responseData: dataU8 }) };
+            resultData: __assign(__assign({}, data), { responseData: dataU8 }) };
     });
 }
 /**
  * Defines the url for the request, load the right loader (custom/default
  * one).
  */
-const generateSegmentLoader = ({ checkMediaSegmentIntegrity, segmentLoader, }) => (url, context, loaderOptions, cancelSignal, callbacks) => {
-    const { segment } = context;
-    if (segment.isInit) {
-        if (segment.privateInfos === undefined ||
-            segment.privateInfos.smoothInitSegment === undefined) {
-            throw new Error("Smooth: Invalid segment format");
-        }
-        const smoothInitPrivateInfos = segment.privateInfos.smoothInitSegment;
-        let responseData;
-        const { codecPrivateData, timescale, height, width, protection = { keyId: undefined,
-            keySystems: undefined } } = smoothInitPrivateInfos;
-        if (codecPrivateData === undefined) {
-            throw new Error("Smooth: no codec private data.");
-        }
-        switch (context.type) {
-            case "video": {
-                responseData = (0, isobmff_1.createVideoInitSegment)(timescale, width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0, 72, 72, 4, // vRes, hRes, nal
-                codecPrivateData, protection.keyId);
-                break;
+var generateSegmentLoader = function (_a) {
+    var checkMediaSegmentIntegrity = _a.checkMediaSegmentIntegrity, customSegmentLoader = _a.customSegmentLoader;
+    return function (url, content, loaderOptions, cancelSignal, callbacks) {
+        var segment = content.segment, manifest = content.manifest, period = content.period, adaptation = content.adaptation, representation = content.representation;
+        if (segment.isInit) {
+            if (segment.privateInfos === undefined ||
+                segment.privateInfos.smoothInitSegment === undefined) {
+                throw new Error("Smooth: Invalid segment format");
             }
-            case "audio": {
-                const { channels = 0, bitsPerSample = 0, packetSize = 0, samplingRate = 0 } = smoothInitPrivateInfos;
-                responseData = (0, isobmff_1.createAudioInitSegment)(timescale, channels, bitsPerSample, packetSize, samplingRate, codecPrivateData, protection.keyId);
-                break;
+            var smoothInitPrivateInfos = segment.privateInfos.smoothInitSegment;
+            var responseData = void 0;
+            var codecPrivateData = smoothInitPrivateInfos.codecPrivateData, timescale = smoothInitPrivateInfos.timescale, _a = smoothInitPrivateInfos.protection, protection = _a === void 0 ? { keyId: undefined,
+                keySystems: undefined } : _a;
+            if (codecPrivateData === undefined) {
+                throw new Error("Smooth: no codec private data.");
             }
-            default:
-                if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-                    (0, assert_1.default)(false, "responseData should have been set");
+            switch (adaptation.type) {
+                case "video": {
+                    var _b = representation.width, width = _b === void 0 ? 0 : _b, _c = representation.height, height = _c === void 0 ? 0 : _c;
+                    responseData = createVideoInitSegment(timescale, width, height, 72, 72, 4, // vRes, hRes, nal
+                    codecPrivateData, protection.keyId);
+                    break;
+                }
+                case "audio": {
+                    var _d = smoothInitPrivateInfos.channels, channels = _d === void 0 ? 0 : _d, _e = smoothInitPrivateInfos.bitsPerSample, bitsPerSample = _e === void 0 ? 0 : _e, _f = smoothInitPrivateInfos.packetSize, packetSize = _f === void 0 ? 0 : _f, _g = smoothInitPrivateInfos.samplingRate, samplingRate = _g === void 0 ? 0 : _g;
+                    responseData = createAudioInitSegment(timescale, channels, bitsPerSample, packetSize, samplingRate, codecPrivateData, protection.keyId);
+                    break;
                 }
-                responseData = new Uint8Array(0);
+                default:
+                    if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+                        assert(false, "responseData should have been set");
+                    }
+                    responseData = new Uint8Array(0);
+            }
+            return Promise.resolve({ resultType: "segment-created",
+                resultData: responseData });
         }
-        return Promise.resolve({ resultType: "segment-created",
-            resultData: responseData });
-    }
-    else if (url === null) {
-        return Promise.resolve({ resultType: "segment-created",
-            resultData: null });
-    }
-    else {
-        if (typeof segmentLoader !== "function") {
-            return regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
+        else if (url === null) {
+            return Promise.resolve({ resultType: "segment-created",
+                resultData: null });
         }
-        return new Promise((res, rej) => {
-            /** `true` when the custom segmentLoader should not be active anymore. */
-            let hasFinished = false;
-            /**
-             * Callback triggered when the custom segment loader has a response.
-             * @param {Object} args
-             */
-            const resolve = (_args) => {
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                hasFinished = true;
-                cancelSignal.deregister(abortCustomLoader);
-                const isMP4 = (0, is_mp4_embedded_track_1.default)(context.mimeType);
-                if (!isMP4 || checkMediaSegmentIntegrity !== true) {
+        else {
+            var args_1 = { adaptation: adaptation, manifest: manifest, period: period, representation: representation, segment: segment, transport: "smooth",
+                timeout: loaderOptions.timeout, url: url };
+            if (typeof customSegmentLoader !== "function") {
+                return regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity);
+            }
+            return new Promise(function (res, rej) {
+                /** `true` when the custom segmentLoader should not be active anymore. */
+                var hasFinished = false;
+                /**
+                 * Callback triggered when the custom segment loader has a response.
+                 * @param {Object} args
+                 */
+                var resolve = function (_args) {
+                    if (hasFinished || cancelSignal.isCancelled()) {
+                        return;
+                    }
+                    hasFinished = true;
+                    cancelSignal.deregister(abortCustomLoader);
+                    var isMP4 = isMP4EmbeddedTrack(content.representation);
+                    if (!isMP4 || checkMediaSegmentIntegrity !== true) {
+                        res({ resultType: "segment-loaded",
+                            resultData: { responseData: _args.data,
+                                size: _args.size,
+                                requestDuration: _args.duration } });
+                    }
+                    var dataU8 = _args.data instanceof Uint8Array ? _args.data :
+                        new Uint8Array(_args.data);
+                    checkISOBMFFIntegrity(dataU8, content.segment.isInit);
                     res({ resultType: "segment-loaded",
-                        resultData: { responseData: _args.data,
+                        resultData: { responseData: dataU8,
                             size: _args.size,
                             requestDuration: _args.duration } });
-                }
-                const dataU8 = _args.data instanceof Uint8Array ? _args.data :
-                    new Uint8Array(_args.data);
-                (0, check_isobmff_integrity_1.default)(dataU8, context.segment.isInit);
-                res({ resultType: "segment-loaded",
-                    resultData: { responseData: dataU8,
+                };
+                /**
+                 * Callback triggered when the custom segment loader fails
+                 * @param {*} err - The corresponding error encountered
+                 */
+                var reject = function (err) {
+                    var _a, _b, _c;
+                    if (hasFinished || cancelSignal.isCancelled()) {
+                        return;
+                    }
+                    hasFinished = true;
+                    cancelSignal.deregister(abortCustomLoader);
+                    // Format error and send it
+                    var castedErr = err;
+                    var message = (_a = castedErr === null || castedErr === void 0 ? void 0 : castedErr.message) !== null && _a !== void 0 ? _a : "Unknown error when fetching a Smooth segment through a " +
+                        "custom segmentLoader.";
+                    var emittedErr = new CustomLoaderError(message, (_b = castedErr === null || castedErr === void 0 ? void 0 : castedErr.canRetry) !== null && _b !== void 0 ? _b : false, (_c = castedErr === null || castedErr === void 0 ? void 0 : castedErr.isOfflineError) !== null && _c !== void 0 ? _c : false, castedErr === null || castedErr === void 0 ? void 0 : castedErr.xhr);
+                    rej(emittedErr);
+                };
+                var progress = function (_args) {
+                    if (hasFinished || cancelSignal.isCancelled()) {
+                        return;
+                    }
+                    callbacks.onProgress({ duration: _args.duration,
                         size: _args.size,
-                        requestDuration: _args.duration } });
-            };
-            /**
-             * Callback triggered when the custom segment loader fails
-             * @param {*} err - The corresponding error encountered
-             */
-            const reject = (err) => {
-                var _a, _b;
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                hasFinished = true;
-                cancelSignal.deregister(abortCustomLoader);
-                // Format error and send it
-                const castedErr = err;
-                const message = (_a = castedErr === null || castedErr === void 0 ? void 0 : castedErr.message) !== null && _a !== void 0 ? _a : "Unknown error when fetching a Smooth segment through a " +
-                    "custom segmentLoader.";
-                const emittedErr = new errors_1.CustomLoaderError(message, (_b = castedErr === null || castedErr === void 0 ? void 0 : castedErr.canRetry) !== null && _b !== void 0 ? _b : false, castedErr === null || castedErr === void 0 ? void 0 : castedErr.xhr);
-                rej(emittedErr);
-            };
-            const progress = (_args) => {
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                callbacks.onProgress({ duration: _args.duration,
-                    size: _args.size,
-                    totalSize: _args.totalSize });
-            };
-            const fallback = () => {
-                if (hasFinished || cancelSignal.isCancelled()) {
-                    return;
-                }
-                hasFinished = true;
-                cancelSignal.deregister(abortCustomLoader);
-                regularSegmentLoader(url, context, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity)
-                    .then(res, rej);
-            };
-            const customCallbacks = { reject, resolve, fallback, progress };
-            let byteRanges;
-            if (context.segment.range !== undefined) {
-                byteRanges = [context.segment.range];
-                if (context.segment.indexRange !== undefined) {
-                    byteRanges.push(context.segment.indexRange);
-                }
-            }
-            const args = { isInit: context.segment.isInit,
-                timeout: loaderOptions.timeout,
-                byteRanges,
-                trackType: context.type,
-                url };
-            const abort = segmentLoader(args, customCallbacks);
-            cancelSignal.register(abortCustomLoader);
-            /**
-             * The logic to run when the custom loader is cancelled while pending.
-             * @param {Error} err
-             */
-            function abortCustomLoader(err) {
-                if (hasFinished) {
-                    return;
-                }
-                hasFinished = true;
-                if (!hasFinished && typeof abort === "function") {
-                    abort();
+                        totalSize: _args.totalSize });
+                };
+                var fallback = function () {
+                    if (hasFinished || cancelSignal.isCancelled()) {
+                        return;
+                    }
+                    hasFinished = true;
+                    cancelSignal.deregister(abortCustomLoader);
+                    regularSegmentLoader(url, content, callbacks, loaderOptions, cancelSignal, checkMediaSegmentIntegrity)
+                        .then(res, rej);
+                };
+                var customCallbacks = { reject: reject, resolve: resolve, fallback: fallback, progress: progress };
+                var abort = customSegmentLoader(args_1, customCallbacks);
+                cancelSignal.register(abortCustomLoader);
+                /**
+                 * The logic to run when the custom loader is cancelled while pending.
+                 * @param {Error} err
+                 */
+                function abortCustomLoader(err) {
+                    if (hasFinished) {
+                        return;
+                    }
+                    hasFinished = true;
+                    if (!hasFinished && typeof abort === "function") {
+                        abort();
+                    }
+                    rej(err);
                 }
-                rej(err);
-            }
-        });
-    }
+            });
+        }
+    };
 };
-exports.default = generateSegmentLoader;
+export default generateSegmentLoader;

package/dist/_esm5.processed/transports/smooth/utils.d.ts

@@ -15,6 +15,31 @@
  */
 import { ISegment, Representation } from "../../manifest";
 import { ICdnMetadata } from "../../parsers/manifest";
+/**
+ * TODO Remove this logic completely from the player
+ * @param {Document} doc
+ * @returns {string|null}
+ */
+declare function extractISML(doc: Document): string | null;
+/**
+ * Returns string corresponding to the token contained in the url's querystring.
+ * Empty string if no token is found.
+ * @param {string} url
+ * @returns {string}
+ */
+declare function extractToken(url: string): string;
+/**
+ * Replace/Remove token from the url's querystring
+ * @param {string} url
+ * @param {string} [token]
+ * @returns {string}
+ */
+declare function replaceToken(url: string, token?: string): string;
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+declare function resolveManifest(url: string): string;
 /**
  * Returns `true` if the given Representation refers to segments in an MP4
  * container
@@ -23,4 +48,4 @@ import { ICdnMetadata } from "../../parsers/manifest";
  */
 declare function isMP4EmbeddedTrack(representation: Representation): boolean;
 declare function constructSegmentUrl(wantedCdn: ICdnMetadata | null, segment: ISegment): string | null;
-export { constructSegmentUrl, isMP4EmbeddedTrack, };
+export { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };

package/dist/_esm5.processed/transports/smooth/utils.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,9 +13,61 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMP4EmbeddedTrack = exports.constructSegmentUrl = void 0;
-const resolve_url_1 = require("../../utils/resolve_url");
+import isNonEmptyString from "../../utils/is_non_empty_string";
+import resolveURL from "../../utils/resolve_url";
+import warnOnce from "../../utils/warn_once";
+var ISM_REG = /(\.isml?)(\?token=\S+)?$/;
+var TOKEN_REG = /\?token=(\S+)/;
+/**
+ * TODO Remove this logic completely from the player
+ * @param {Document} doc
+ * @returns {string|null}
+ */
+function extractISML(doc) {
+    return doc.getElementsByTagName("media")[0].getAttribute("src");
+}
+/**
+ * Returns string corresponding to the token contained in the url's querystring.
+ * Empty string if no token is found.
+ * @param {string} url
+ * @returns {string}
+ */
+function extractToken(url) {
+    var tokenMatch = TOKEN_REG.exec(url);
+    if (tokenMatch !== null) {
+        var match = tokenMatch[1];
+        if (match !== undefined) {
+            return match;
+        }
+    }
+    return "";
+}
+/**
+ * Replace/Remove token from the url's querystring
+ * @param {string} url
+ * @param {string} [token]
+ * @returns {string}
+ */
+function replaceToken(url, token) {
+    if (isNonEmptyString(token)) {
+        return url.replace(TOKEN_REG, "?token=" + token);
+    }
+    else {
+        return url.replace(TOKEN_REG, "");
+    }
+}
+/**
+ * @param {string} url
+ * @returns {string}
+ */
+function resolveManifest(url) {
+    if (ISM_REG.test(url)) {
+        warnOnce("Giving a isml URL to loadVideo is deprecated." +
+            " Please give the Manifest URL directly");
+        return url.replace(ISM_REG, "$1/manifest$2");
+    }
+    return url;
+}
 /**
  * Returns `true` if the given Representation refers to segments in an MP4
  * container
@@ -27,10 +78,9 @@ function isMP4EmbeddedTrack(representation) {
     return typeof representation.mimeType === "string" &&
         representation.mimeType.indexOf("mp4") >= 0;
 }
-exports.isMP4EmbeddedTrack = isMP4EmbeddedTrack;
 function constructSegmentUrl(wantedCdn, segment) {
     return wantedCdn === null ? null :
         segment.url === null ? wantedCdn.baseUrl :
-            (0, resolve_url_1.default)(wantedCdn.baseUrl, segment.url);
+            resolveURL(wantedCdn.baseUrl, segment.url);
 }
-exports.constructSegmentUrl = constructSegmentUrl;
+export { constructSegmentUrl, extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, };