rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/transports/smooth/isobmff/create_video_init_segment.js

@@ -27,10 +27,7 @@ import createInitSegment from "./create_init_segment";
  * @param {Number} vRes
  * @param {Number} nalLength (1, 2 or 4)
  * @param {string} codecPrivateData
- * @param {Uint8Array} keyId - hex string representing the key Id,
- * 32 chars. eg. a800dbed49c12c4cb8e0b25643844b9b
- * @param {Array.<Object>} [pssList] - List of dict, example:
- * {systemId: "DEADBEEF", codecPrivateData: "DEAFBEEF}
+ * @param {Uint8Array} [keyId]
  * @returns {Uint8Array}
  */
 export default function createVideoInitSegment(timescale, width, height, hRes, vRes, nalLength, codecPrivateData, keyId) {

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

@@ -13,23 +13,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
-import { map, tap, } from "rxjs/operators";
+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 features from "../../features";
 import log from "../../log";
 import Manifest from "../../manifest";
 import { getMDAT } from "../../parsers/containers/isobmff";
 import createSmoothManifestParser, { SmoothRepresentationIndex, } from "../../parsers/manifest/smooth";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import { strToUtf8, utf8ToStr, } from "../../utils/string_parsing";
 import warnOnce from "../../utils/warn_once";
 import checkISOBMFFIntegrity from "../utils/check_isobmff_integrity";
 import generateManifestLoader from "../utils/generate_manifest_loader";
-import returnParsedManifest from "../utils/return_parsed_manifest";
 import extractTimingsInfos from "./extract_timings_infos";
 import { patchSegment } from "./isobmff";
 import generateSegmentLoader from "./segment_loader";
-import { extractISML, extractToken, replaceToken, resolveManifest, } from "./utils";
+import { extractISML, extractToken, isMP4EmbeddedTrack, replaceToken, resolveManifest, } from "./utils";
 var WSX_REG = /\.wsx?(\?token=\S+)?/;
 /**
  * @param {Object} adaptation
@@ -53,98 +62,98 @@ function addNextSegments(adaptation, nextSegments, dlSegment) {
 }
 export default function (options) {
     var smoothManifestParser = createSmoothManifestParser(options);
-    var segmentLoader = generateSegmentLoader(options.segmentLoader);
+    var segmentLoader = generateSegmentLoader(options);
     var manifestLoaderOptions = { customManifestLoader: options.manifestLoader };
     var manifestLoader = generateManifestLoader(manifestLoaderOptions, "text");
     var manifestPipeline = {
-        resolver: function (_a) {
-            var url = _a.url;
+        // TODO (v4.x.x) Remove that function
+        resolveManifestUrl: function (url, cancelSignal) {
             if (url === undefined) {
-                return observableOf({ url: undefined });
+                return PPromise.resolve(undefined);
             }
-            // TODO Remove WSX logic
             var resolving;
             if (WSX_REG.test(url)) {
                 warnOnce("Giving WSX URL to loadVideo is deprecated." +
                     " You should only give Manifest URLs.");
                 resolving = request({ url: replaceToken(url, ""),
-                    responseType: "document" })
-                    .pipe(map(function (_a) {
-                    var value = _a.value;
+                    responseType: "document", cancelSignal: cancelSignal })
+                    .then(function (value) {
                     var extractedURL = extractISML(value.responseData);
                     if (extractedURL === null || extractedURL.length === 0) {
                         throw new Error("Invalid ISML");
                     }
                     return extractedURL;
-                }));
+                });
             }
             else {
-                resolving = observableOf(url);
+                resolving = PPromise.resolve(url);
             }
             var token = extractToken(url);
-            return resolving.pipe(map(function (_url) { return ({
-                url: replaceToken(resolveManifest(_url), token),
-            }); }));
+            return resolving.then(function (_url) {
+                return replaceToken(resolveManifest(_url), token);
+            });
         },
-        loader: manifestLoader,
-        parser: function (_a) {
-            var response = _a.response, reqURL = _a.url;
-            var url = response.url === undefined ? reqURL :
-                response.url;
-            var data = typeof response.responseData === "string" ?
-                new DOMParser().parseFromString(response.responseData, "text/xml") :
-                response.responseData; // TODO find a way to check if Document?
-            var manifestReceivedTime = response.receivedTime;
-            var parserResult = smoothManifestParser(data, url, manifestReceivedTime);
+        loadManifest: manifestLoader,
+        parseManifest: function (manifestData, parserOptions) {
+            var _a;
+            var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+            var manifestReceivedTime = manifestData.receivedTime, responseData = manifestData.responseData;
+            var documentData = typeof responseData === "string" ?
+                new DOMParser().parseFromString(responseData, "text/xml") :
+                responseData; // TODO find a way to check if Document?
+            var parserResult = smoothManifestParser(documentData, url, manifestReceivedTime);
             var manifest = new Manifest(parserResult, {
                 representationFilter: options.representationFilter,
                 supplementaryImageTracks: options.supplementaryImageTracks,
                 supplementaryTextTracks: options.supplementaryTextTracks,
             });
-            return returnParsedManifest(manifest, url);
+            return { manifest: manifest, url: url };
         },
     };
-    var segmentPipeline = {
-        loader: function (content) {
-            if (content.segment.isInit || options.checkMediaSegmentIntegrity !== true) {
-                return segmentLoader(content);
-            }
-            return segmentLoader(content).pipe(tap(function (res) {
-                if ((res.type === "data-loaded" || res.type === "data-chunk") &&
-                    res.value.responseData !== null) {
-                    checkISOBMFFIntegrity(new Uint8Array(res.value.responseData), content.segment.isInit);
-                }
-            }));
+    /**
+     * Export functions allowing to load and parse audio and video smooth
+     * segments.
+     */
+    var audioVideoPipeline = {
+        /**
+         * Load a Smooth audio/video segment.
+         * @param {string|null} url
+         * @param {Object} content
+         * @param {Object} cancelSignal
+         * @param {Object} callbacks
+         * @returns {Promise}
+         */
+        loadSegment: function (url, content, cancelSignal, callbacks) {
+            return segmentLoader(url, content, cancelSignal, callbacks);
         },
-        parser: function (_a) {
-            var _b, _c;
-            var content = _a.content, response = _a.response, initTimescale = _a.initTimescale;
+        parseSegment: function (loadedSegment, content, initTimescale) {
+            var _a, _b;
             var segment = content.segment, adaptation = content.adaptation, manifest = content.manifest;
-            var data = response.data, isChunked = response.isChunked;
+            var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
             if (data === null) {
                 if (segment.isInit) {
-                    return observableOf({ type: "parsed-init-segment",
-                        value: { initializationData: null,
-                            protectionDataUpdate: false,
-                            initTimescale: undefined } });
+                    return { segmentType: "init",
+                        initializationData: null,
+                        protectionDataUpdate: false,
+                        initTimescale: undefined };
                 }
-                return observableOf({ type: "parsed-segment",
-                    value: { chunkData: null,
-                        chunkInfos: null,
-                        chunkOffset: 0,
-                        appendWindow: [undefined, undefined],
-                        protectionDataUpdate: false } });
+                return { segmentType: "media",
+                    chunkData: null,
+                    chunkInfos: null,
+                    chunkOffset: 0,
+                    protectionDataUpdate: false,
+                    appendWindow: [undefined, undefined] };
             }
             var responseBuffer = data instanceof Uint8Array ? data :
                 new Uint8Array(data);
             if (segment.isInit) {
-                var timescale = (_c = (_b = segment.privateInfos) === null || _b === void 0 ? void 0 : _b.smoothInitSegment) === null || _c === void 0 ? void 0 : _c.timescale;
-                return observableOf({ type: "parsed-init-segment",
-                    value: { initializationData: data,
-                        // smooth init segments are crafted by hand.
-                        // Their timescale is the one from the manifest.
-                        initTimescale: timescale,
-                        protectionDataUpdate: false } });
+                var timescale = (_b = (_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothInitSegment) === null || _b === void 0 ? void 0 : _b.timescale;
+                return { segmentType: "init",
+                    initializationData: data,
+                    // smooth init segments are crafted by hand.
+                    // Their timescale is the one from the manifest.
+                    initTimescale: timescale,
+                    protectionDataUpdate: false };
             }
             var timingInfos = initTimescale !== undefined ?
                 extractTimingsInfos(responseBuffer, isChunked, initTimescale, segment, manifest.isLive) :
@@ -159,57 +168,58 @@ export default function (options) {
             if (nextSegments.length > 0) {
                 addNextSegments(adaptation, nextSegments, segment);
             }
-            return observableOf({ type: "parsed-segment",
-                value: { chunkData: chunkData,
-                    chunkInfos: chunkInfos,
-                    chunkOffset: 0,
-                    appendWindow: [undefined, undefined],
-                    protectionDataUpdate: false } });
+            return { segmentType: "media", chunkData: chunkData, chunkInfos: chunkInfos, chunkOffset: 0,
+                protectionDataUpdate: false,
+                appendWindow: [undefined, undefined] };
         },
     };
     var textTrackPipeline = {
-        loader: function (_a) {
-            var segment = _a.segment, representation = _a.representation, url = _a.url;
+        loadSegment: function (url, content, cancelSignal, callbacks) {
+            var segment = content.segment, representation = content.representation;
             if (segment.isInit || url === null) {
-                return observableOf({ type: "data-created",
-                    value: { responseData: null } });
+                return PPromise.resolve({ resultType: "segment-created",
+                    resultData: null });
             }
             var isMP4 = isMP4EmbeddedTrack(representation);
-            if (!isMP4 || options.checkMediaSegmentIntegrity !== true) {
-                return request({ url: url,
-                    responseType: isMP4 ? "arraybuffer" : "text",
-                    sendProgressEvents: true });
+            if (!isMP4) {
+                return request({ url: url, responseType: "text", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+                    .then(function (data) { return ({ resultType: "segment-loaded",
+                    resultData: data }); });
+            }
+            else {
+                return request({ url: url, responseType: "arraybuffer", cancelSignal: cancelSignal, onProgress: callbacks.onProgress })
+                    .then(function (data) {
+                    if (options.checkMediaSegmentIntegrity !== true) {
+                        return { resultType: "segment-loaded",
+                            resultData: data };
+                    }
+                    var dataU8 = new Uint8Array(data.responseData);
+                    checkISOBMFFIntegrity(dataU8, content.segment.isInit);
+                    return { resultType: "segment-loaded",
+                        resultData: __assign(__assign({}, data), { responseData: dataU8 }) };
+                });
             }
-            return request({ url: url,
-                responseType: "arraybuffer",
-                sendProgressEvents: true })
-                .pipe(tap(function (res) {
-                if (res.type === "data-loaded") {
-                    checkISOBMFFIntegrity(new Uint8Array(res.value.responseData), segment.isInit);
-                }
-            }));
         },
-        parser: function (_a) {
-            var _b;
-            var content = _a.content, response = _a.response, initTimescale = _a.initTimescale;
+        parseSegment: function (loadedSegment, content, initTimescale) {
+            var _a;
             var manifest = content.manifest, adaptation = content.adaptation, representation = content.representation, segment = content.segment;
             var language = adaptation.language;
             var isMP4 = isMP4EmbeddedTrack(representation);
-            var _c = representation.mimeType, mimeType = _c === void 0 ? "" : _c, _d = representation.codec, codec = _d === void 0 ? "" : _d;
-            var data = response.data, isChunked = response.isChunked;
+            var _b = representation.mimeType, mimeType = _b === void 0 ? "" : _b, _c = representation.codec, codec = _c === void 0 ? "" : _c;
+            var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
             if (segment.isInit) { // text init segment has no use in HSS
-                return observableOf({ type: "parsed-init-segment",
-                    value: { initializationData: null,
-                        protectionDataUpdate: false,
-                        initTimescale: undefined } });
+                return { segmentType: "init",
+                    initializationData: null,
+                    protectionDataUpdate: false,
+                    initTimescale: undefined };
             }
             if (data === null) {
-                return observableOf({ type: "parsed-segment",
-                    value: { chunkData: null,
-                        chunkInfos: null,
-                        chunkOffset: 0,
-                        appendWindow: [undefined, undefined],
-                        protectionDataUpdate: false } });
+                return { segmentType: "media",
+                    chunkData: null,
+                    chunkInfos: null,
+                    chunkOffset: 0,
+                    protectionDataUpdate: false,
+                    appendWindow: [undefined, undefined] };
             }
             var nextSegments;
             var chunkInfos = null;
@@ -230,7 +240,7 @@ export default function (options) {
                     extractTimingsInfos(chunkBytes, isChunked, initTimescale, segment, manifest.isLive) :
                     null;
                 nextSegments = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.nextSegments;
-                chunkInfos = (_b = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.chunkInfos) !== null && _b !== void 0 ? _b : null;
+                chunkInfos = (_a = timingInfos === null || timingInfos === void 0 ? void 0 : timingInfos.chunkInfos) !== null && _a !== void 0 ? _a : null;
                 if (chunkInfos === null) {
                     if (isChunked) {
                         log.warn("Smooth: Unavailable time data for current text track.");
@@ -256,7 +266,7 @@ export default function (options) {
                     _sdType = "vtt";
                 }
                 else {
-                    throw new Error("could not find a text-track parser for the type " + mimeType);
+                    throw new Error("could not find a text-track parser for the type ".concat(mimeType));
                 }
                 var mdat = getMDAT(chunkBytes);
                 _sdData = mdat === null ? "" :
@@ -292,7 +302,7 @@ export default function (options) {
                         _sdType = "srt";
                     }
                     else {
-                        throw new Error("could not find a text-track parser for the type " + mimeType);
+                        throw new Error("could not find a text-track parser for the type ".concat(mimeType));
                     }
                 }
                 _sdData = chunkString;
@@ -302,80 +312,64 @@ export default function (options) {
                 addNextSegments(adaptation, nextSegments, segment);
             }
             var chunkOffset = segmentStart !== null && segmentStart !== void 0 ? segmentStart : 0;
-            return observableOf({ type: "parsed-segment",
-                value: { chunkData: { type: _sdType,
-                        data: _sdData,
-                        start: segmentStart,
-                        end: segmentEnd,
-                        language: language },
-                    chunkInfos: chunkInfos,
-                    chunkOffset: chunkOffset,
-                    appendWindow: [undefined, undefined],
-                    protectionDataUpdate: false } });
+            return { segmentType: "media",
+                chunkData: { type: _sdType,
+                    data: _sdData,
+                    start: segmentStart,
+                    end: segmentEnd, language: language }, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionDataUpdate: false,
+                appendWindow: [undefined, undefined] };
         },
     };
     var imageTrackPipeline = {
-        loader: function (_a) {
-            var segment = _a.segment, url = _a.url;
-            if (segment.isInit || url === null) {
+        loadSegment: function (url, content, cancelSignal, callbacks) {
+            if (content.segment.isInit || url === null) {
                 // image do not need an init segment. Passthrough directly to the parser
-                return observableOf({ type: "data-created",
-                    value: { responseData: null } });
+                return PPromise.resolve({ resultType: "segment-created",
+                    resultData: null });
             }
-            return request({ url: url,
-                responseType: "arraybuffer",
-                sendProgressEvents: true });
+            return request({ url: url, responseType: "arraybuffer",
+                onProgress: callbacks.onProgress, cancelSignal: cancelSignal })
+                .then(function (data) { return ({ resultType: "segment-loaded",
+                resultData: data }); });
         },
-        parser: function (_a) {
-            var response = _a.response, content = _a.content;
-            var data = response.data, isChunked = response.isChunked;
+        parseSegment: function (loadedSegment, content, _initTimescale) {
+            var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
             if (content.segment.isInit) { // image init segment has no use
-                return observableOf({ type: "parsed-init-segment",
-                    value: { initializationData: null,
-                        protectionDataUpdate: false,
-                        initTimescale: undefined } });
+                return { segmentType: "init",
+                    initializationData: null,
+                    protectionDataUpdate: false,
+                    initTimescale: undefined };
             }
             if (isChunked) {
                 throw new Error("Image data should not be downloaded in chunks");
             }
             // TODO image Parsing should be more on the buffer side, no?
             if (data === null || features.imageParser === null) {
-                return observableOf({ type: "parsed-segment",
-                    value: { chunkData: null,
-                        chunkInfos: null,
-                        chunkOffset: 0,
-                        appendWindow: [undefined, undefined],
-                        protectionDataUpdate: false } });
+                return { segmentType: "media",
+                    chunkData: null,
+                    chunkInfos: null,
+                    chunkOffset: 0,
+                    protectionDataUpdate: false,
+                    appendWindow: [undefined, undefined] };
             }
             var bifObject = features.imageParser(new Uint8Array(data));
             var thumbsData = bifObject.thumbs;
-            return observableOf({ type: "parsed-segment",
-                value: { chunkData: { data: thumbsData,
-                        start: 0,
-                        end: Number.MAX_VALUE,
-                        timescale: 1,
-                        type: "bif" },
-                    chunkInfos: { time: 0,
-                        duration: Number.MAX_VALUE,
-                        timescale: bifObject.timescale },
-                    chunkOffset: 0,
-                    protectionDataUpdate: false,
-                    appendWindow: [undefined, undefined] } });
+            return { segmentType: "media",
+                chunkData: { data: thumbsData,
+                    start: 0,
+                    end: Number.MAX_VALUE,
+                    timescale: 1,
+                    type: "bif" },
+                chunkInfos: { time: 0,
+                    duration: Number.MAX_VALUE },
+                chunkOffset: 0,
+                protectionDataUpdate: false,
+                appendWindow: [undefined, undefined] };
         },
     };
     return { manifest: manifestPipeline,
-        audio: segmentPipeline,
-        video: segmentPipeline,
+        audio: audioVideoPipeline,
+        video: audioVideoPipeline,
         text: textTrackPipeline,
         image: imageTrackPipeline };
 }
-/**
- * Returns true if the given texttrack segment represents a textrack embedded
- * in a mp4 file.
- * @param {Representation} representation
- * @returns {Boolean}
- */
-function isMP4EmbeddedTrack(representation) {
-    return typeof representation.mimeType === "string" &&
-        representation.mimeType.indexOf("mp4") >= 0;
-}

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

@@ -13,11 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { CustomSegmentLoader, ISegmentLoaderArguments, ISegmentLoaderEvent } from "../types";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { ICustomSegmentLoader, ISegmentContext, ISegmentLoaderCallbacks, ISegmentLoaderResultSegmentCreated, ISegmentLoaderResultSegmentLoaded } from "../types";
 /**
  * Defines the url for the request, load the right loader (custom/default
  * one).
  */
-declare const generateSegmentLoader: (customSegmentLoader?: CustomSegmentLoader | undefined) => ({ segment, representation, adaptation, period, manifest, url, }: ISegmentLoaderArguments) => Observable<ISegmentLoaderEvent<Uint8Array | ArrayBuffer | null>>;
+declare const generateSegmentLoader: ({ checkMediaSegmentIntegrity, customSegmentLoader, }: {
+    checkMediaSegmentIntegrity?: boolean | undefined;
+    customSegmentLoader?: ICustomSegmentLoader | undefined;
+}) => (url: string | null, content: ISegmentContext, cancelSignal: CancellationSignal, callbacks: ISegmentLoaderCallbacks<Uint8Array | ArrayBuffer | null>) => Promise<ISegmentLoaderResultSegmentLoaded<Uint8Array | ArrayBuffer | null> | ISegmentLoaderResultSegmentCreated<Uint8Array | ArrayBuffer | null>>;
 export default generateSegmentLoader;