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

package/dist/commonjs/transports/local/text_parser.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var isobmff_1 = require("../../parsers/containers/isobmff");
+var string_parsing_1 = require("../../utils/string_parsing");
+var get_isobmff_timing_infos_1 = require("../utils/get_isobmff_timing_infos");
+var infer_segment_container_1 = require("../utils/infer_segment_container");
+var parse_text_track_1 = require("../utils/parse_text_track");
+/**
+ * Parse TextTrack data when it is embedded in an ISOBMFF file.
+ * @param {ArrayBuffer|Uint8Array|string} data - The segment data.
+ * @param {boolean} isChunked - If `true`, the `data` may contain only a
+ * decodable subpart of the full data in the linked segment.
+ * @param {Object} context - Object describing the context of the given
+ * segment's data: of which segment, `Representation`, `Adaptation`, `Period`,
+ * `Manifest` it is a part of etc.
+ * @param {number|undefined} initTimescale - `timescale` value - encountered
+ * in this linked initialization segment (if it exists) - that may also apply
+ * to that segment if no new timescale is defined in it.
+ * Can be `undefined` if no timescale was defined, if it is not known, or if
+ * no linked initialization segment was yet parsed.
+ * @returns {Object}
+ */
+function parseISOBMFFEmbeddedTextTrack(data, isChunked, context, initTimescale) {
+    var _a;
+    var periodStart = context.periodStart, periodEnd = context.periodEnd, segment = context.segment;
+    var chunkBytes = typeof data === "string" ? (0, string_parsing_1.strToUtf8)(data) :
+        data instanceof Uint8Array ? data :
+            new Uint8Array(data);
+    if (segment.isInit) {
+        var mdhdTimescale = (0, isobmff_1.getMDHDTimescale)(chunkBytes);
+        return { segmentType: "init",
+            initializationData: null,
+            initializationDataSize: 0,
+            initTimescale: mdhdTimescale,
+            protectionData: [] };
+    }
+    var chunkInfos = (0, get_isobmff_timing_infos_1.default)(chunkBytes, isChunked, segment, initTimescale);
+    var chunkData = (0, parse_text_track_1.getISOBMFFEmbeddedTextTrackData)(context, chunkBytes, chunkInfos, isChunked);
+    var chunkOffset = (_a = segment.timestampOffset) !== null && _a !== void 0 ? _a : 0;
+    return { segmentType: "media", chunkData: chunkData, chunkSize: chunkBytes.length, chunkInfos: chunkInfos, chunkOffset: chunkOffset, protectionData: [],
+        appendWindow: [periodStart, periodEnd] };
+}
+/**
+ * Parse TextTrack data when it is in plain text form.
+ * @param {ArrayBuffer|Uint8Array|string} data - The segment data.
+ * @param {boolean} isChunked - If `true`, the `data` may contain only a
+ * decodable subpart of the full data in the linked segment.
+ * @param {Object} context - Object describing the context of the given
+ * segment's data: of which segment, `Representation`, `Adaptation`, `Period`,
+ * `Manifest` it is a part of etc.
+ * @returns {Object}
+ */
+function parsePlainTextTrack(data, isChunked, context) {
+    var _a;
+    var segment = context.segment, periodStart = context.periodStart, periodEnd = context.periodEnd;
+    if (segment.isInit) {
+        return { segmentType: "init",
+            initializationData: null,
+            initializationDataSize: 0,
+            initTimescale: undefined,
+            protectionData: [] };
+    }
+    var textTrackData;
+    var chunkSize;
+    if (typeof data !== "string") {
+        var bytesData = data instanceof Uint8Array ? data :
+            new Uint8Array(data);
+        textTrackData = (0, string_parsing_1.utf8ToStr)(bytesData);
+        chunkSize = bytesData.length;
+    }
+    else {
+        textTrackData = data;
+    }
+    var chunkData = (0, parse_text_track_1.getPlainTextTrackData)(context, textTrackData, isChunked);
+    var chunkOffset = (_a = segment.timestampOffset) !== null && _a !== void 0 ? _a : 0;
+    return { segmentType: "media", chunkData: chunkData, chunkSize: chunkSize, chunkInfos: null, chunkOffset: chunkOffset, protectionData: [],
+        appendWindow: [periodStart, periodEnd] };
+}
+/**
+ * Parse TextTrack data.
+ * @param {Object} loadedSegment
+ * @param {Object} context
+ * @param {number | undefined} initTimescale
+ * @returns {Object}
+ */
+function textTrackParser(loadedSegment, context, initTimescale) {
+    var _a;
+    var segment = context.segment, periodStart = context.periodStart, periodEnd = context.periodEnd;
+    var data = loadedSegment.data, isChunked = loadedSegment.isChunked;
+    if (data === null) {
+        // No data, just return an empty placeholder object
+        if (segment.isInit) {
+            return { segmentType: "init",
+                initializationData: null,
+                initializationDataSize: 0,
+                protectionData: [],
+                initTimescale: undefined };
+        }
+        var chunkOffset = (_a = segment.timestampOffset) !== null && _a !== void 0 ? _a : 0;
+        return { segmentType: "media",
+            chunkData: null,
+            chunkSize: 0,
+            chunkInfos: null, chunkOffset: chunkOffset, protectionData: [],
+            appendWindow: [periodStart, periodEnd] };
+    }
+    var containerType = (0, infer_segment_container_1.default)(context.type, context.mimeType);
+    // TODO take a look to check if this is an ISOBMFF/webm when undefined?
+    if (containerType === "webm") {
+        // TODO Handle webm containers
+        throw new Error("Text tracks with a WEBM container are not yet handled.");
+    }
+    else if (containerType === "mp4") {
+        return parseISOBMFFEmbeddedTextTrack(data, isChunked, context, initTimescale);
+    }
+    else {
+        return parsePlainTextTrack(data, isChunked, context);
+    }
+}
+exports.default = textTrackParser;

package/dist/commonjs/transports/metaplaylist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 file is feature-switchable.
+ * It always should be imported through the `features` object.
+ */
+import MetaPlaylistPipelines from "./pipelines";
+export default MetaPlaylistPipelines;

package/dist/commonjs/transports/metaplaylist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * /!\ This file is feature-switchable.
+ * It always should be imported through the `features` object.
+ */
+var pipelines_1 = require("./pipelines");
+exports.default = pipelines_1.default;

package/dist/commonjs/transports/metaplaylist/manifest_loader.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { IManifestLoader, ILoadedManifestFormat } from "../../public_types";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IManifestLoaderOptions, IRequestedData } from "../types";
+/**
+ * Generate a manifest loader for the application
+ * @param {Function} [customManifestLoader]
+ * @returns {Function}
+ */
+export default function generateManifestLoader({ customManifestLoader }: {
+    customManifestLoader?: IManifestLoader | undefined;
+}): (url: string | undefined, loaderOptions: IManifestLoaderOptions, cancelSignal: CancellationSignal) => Promise<IRequestedData<ILoadedManifestFormat>>;

package/dist/commonjs/transports/metaplaylist/manifest_loader.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var request_1 = require("../../utils/request");
+var call_custom_manifest_loader_1 = require("../utils/call_custom_manifest_loader");
+/**
+ * Manifest loader triggered if there was no custom-defined one in the API.
+ * @param {string} url
+ * @param {Object} loaderOptions
+ * @param {Object} cancelSignal
+ */
+function regularManifestLoader(url, loaderOptions, cancelSignal) {
+    if (url === undefined) {
+        throw new Error("Cannot perform HTTP(s) request. URL not known");
+    }
+    return (0, request_1.default)({ url: url, responseType: "text",
+        timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
+}
+/**
+ * Generate a manifest loader for the application
+ * @param {Function} [customManifestLoader]
+ * @returns {Function}
+ */
+function generateManifestLoader(_a) {
+    var customManifestLoader = _a.customManifestLoader;
+    return typeof customManifestLoader !== "function" ?
+        regularManifestLoader :
+        (0, call_custom_manifest_loader_1.default)(customManifestLoader, regularManifestLoader);
+}
+exports.default = generateManifestLoader;

package/dist/commonjs/transports/metaplaylist/pipelines.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { ITransportOptions, ITransportPipelines } from "../types";
+export default function (options: ITransportOptions): ITransportPipelines;

package/dist/commonjs/transports/metaplaylist/pipelines.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * 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.
+ */
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("../../config");
+var features_1 = require("../../features");
+var manifest_1 = require("../../manifest");
+var metaplaylist_1 = require("../../parsers/manifest/metaplaylist");
+var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var object_assign_1 = require("../../utils/object_assign");
+var manifest_loader_1 = require("./manifest_loader");
+/**
+ * Get base - real - content from an offseted metaplaylist content.
+ * @param {Object} mplContext
+ * @returns {Object}
+ */
+function getOriginalContext(mplContext) {
+    var _a;
+    var segment = mplContext.segment;
+    if (((_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.metaplaylistInfos) === undefined) {
+        throw new Error("MetaPlaylist: missing private infos");
+    }
+    var _b = segment.privateInfos.metaplaylistInfos, isLive = _b.isLive, periodStart = _b.periodStart, periodEnd = _b.periodEnd, manifestPublishTime = _b.manifestPublishTime;
+    var originalSegment = segment.privateInfos.metaplaylistInfos.originalSegment;
+    return { segment: originalSegment,
+        type: mplContext.type,
+        language: mplContext.language,
+        mimeType: mplContext.mimeType,
+        codecs: mplContext.codecs, isLive: isLive, periodStart: periodStart, periodEnd: periodEnd, manifestPublishTime: manifestPublishTime };
+}
+/**
+ * @param {Object} transports
+ * @param {string} transportName
+ * @param {Object} options
+ * @returns {Object}
+ */
+function getTransportPipelines(transports, transportName, options) {
+    var initialTransport = transports[transportName];
+    if (initialTransport !== undefined) {
+        return initialTransport;
+    }
+    var feature = features_1.default.transports[transportName];
+    if (feature === undefined) {
+        throw new Error("MetaPlaylist: Unknown transport ".concat(transportName, "."));
+    }
+    var transport = feature(options);
+    transports[transportName] = transport;
+    return transport;
+}
+/**
+ * @param {Object} segment
+ * @returns {Object}
+ */
+function getMetaPlaylistPrivateInfos(segment) {
+    var privateInfos = segment.privateInfos;
+    if ((privateInfos === null || privateInfos === void 0 ? void 0 : privateInfos.metaplaylistInfos) === undefined) {
+        throw new Error("MetaPlaylist: Undefined transport for content for metaplaylist.");
+    }
+    return privateInfos.metaplaylistInfos;
+}
+function default_1(options) {
+    var transports = {};
+    var manifestLoader = (0, manifest_loader_1.default)({
+        customManifestLoader: options.manifestLoader,
+    });
+    // remove some options that we might not want to apply to the
+    // other streaming protocols used here
+    var otherTransportOptions = (0, object_assign_1.default)({}, options, { manifestLoader: undefined });
+    var manifestPipeline = {
+        loadManifest: manifestLoader,
+        parseManifest: function (manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
+            var _a;
+            var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+            var responseData = manifestData.responseData;
+            var mplParserOptions = { url: url, serverSyncInfos: options.serverSyncInfos };
+            var parsed = (0, metaplaylist_1.default)(responseData, mplParserOptions);
+            return handleParsedResult(parsed);
+            function handleParsedResult(parsedResult) {
+                if (parsedResult.type === "done") {
+                    var warnings = [];
+                    var manifest = new manifest_1.default(parsedResult.value, options, warnings);
+                    return Promise.resolve({ manifest: manifest, warnings: warnings });
+                }
+                var parsedValue = parsedResult.value;
+                var loaderProms = parsedValue.ressources.map(function (resource) {
+                    var transport = getTransportPipelines(transports, resource.transportType, otherTransportOptions);
+                    return scheduleRequest(loadSubManifest)
+                        .then(function (data) {
+                        return transport.manifest.parseManifest(data, __assign(__assign({}, parserOptions), { originalUrl: resource.url }), onWarnings, cancelSignal, scheduleRequest);
+                    });
+                    function loadSubManifest() {
+                        /*
+                         * Whether a ManifestLoader's timeout should be relied on here
+                         * is ambiguous.
+                         */
+                        var manOpts = { timeout: config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT };
+                        return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
+                    }
+                });
+                return Promise.all(loaderProms).then(function (parsedReqs) {
+                    var loadedRessources = parsedReqs.map(function (e) { return e.manifest; });
+                    return handleParsedResult(parsedResult.value.continue(loadedRessources));
+                });
+            }
+        },
+    };
+    /**
+     * @param {Object} segment
+     * @returns {Object}
+     */
+    function getTransportPipelinesFromSegment(segment) {
+        var transportType = getMetaPlaylistPrivateInfos(segment).transportType;
+        return getTransportPipelines(transports, transportType, otherTransportOptions);
+    }
+    /**
+     * @param {number} contentOffset
+     * @param {number|undefined} contentEnd
+     * @param {Object} segmentResponse
+     * @returns {Object}
+     */
+    function offsetTimeInfos(contentOffset, contentEnd, segmentResponse) {
+        var offsetedSegmentOffset = segmentResponse.chunkOffset + contentOffset;
+        if ((0, is_null_or_undefined_1.default)(segmentResponse.chunkData)) {
+            return { chunkInfos: segmentResponse.chunkInfos,
+                chunkOffset: offsetedSegmentOffset,
+                appendWindow: [undefined, undefined] };
+        }
+        // clone chunkInfos
+        var chunkInfos = segmentResponse.chunkInfos, appendWindow = segmentResponse.appendWindow;
+        var offsetedChunkInfos = chunkInfos === null ? null :
+            (0, object_assign_1.default)({}, chunkInfos);
+        if (offsetedChunkInfos !== null) {
+            offsetedChunkInfos.time += contentOffset;
+        }
+        var offsetedWindowStart = appendWindow[0] !== undefined ?
+            Math.max(appendWindow[0] + contentOffset, contentOffset) :
+            contentOffset;
+        var offsetedWindowEnd;
+        if (appendWindow[1] !== undefined) {
+            offsetedWindowEnd = contentEnd !== undefined ?
+                Math.min(appendWindow[1] + contentOffset, contentEnd) :
+                appendWindow[1] + contentOffset;
+        }
+        else if (contentEnd !== undefined) {
+            offsetedWindowEnd = contentEnd;
+        }
+        return { chunkInfos: offsetedChunkInfos,
+            chunkOffset: offsetedSegmentOffset,
+            appendWindow: [offsetedWindowStart, offsetedWindowEnd] };
+    }
+    var audioPipeline = {
+        loadSegment: function (wantedCdn, context, loaderOptions, cancelToken, callbacks) {
+            var segment = context.segment;
+            var audio = getTransportPipelinesFromSegment(segment).audio;
+            var ogContext = getOriginalContext(context);
+            return audio.loadSegment(wantedCdn, ogContext, loaderOptions, cancelToken, callbacks);
+        },
+        parseSegment: function (loadedSegment, context, initTimescale) {
+            var segment = context.segment;
+            var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
+            var audio = getTransportPipelinesFromSegment(segment).audio;
+            var ogContext = getOriginalContext(context);
+            var parsed = audio.parseSegment(loadedSegment, ogContext, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return (0, object_assign_1.default)({}, parsed, timeInfos);
+        },
+    };
+    var videoPipeline = {
+        loadSegment: function (wantedCdn, context, loaderOptions, cancelToken, callbacks) {
+            var segment = context.segment;
+            var video = getTransportPipelinesFromSegment(segment).video;
+            var ogContext = getOriginalContext(context);
+            return video.loadSegment(wantedCdn, ogContext, loaderOptions, cancelToken, callbacks);
+        },
+        parseSegment: function (loadedSegment, context, initTimescale) {
+            var segment = context.segment;
+            var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
+            var video = getTransportPipelinesFromSegment(segment).video;
+            var ogContext = getOriginalContext(context);
+            var parsed = video.parseSegment(loadedSegment, ogContext, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return (0, object_assign_1.default)({}, parsed, timeInfos);
+        },
+    };
+    var textTrackPipeline = {
+        loadSegment: function (wantedCdn, context, loaderOptions, cancelToken, callbacks) {
+            var segment = context.segment;
+            var text = getTransportPipelinesFromSegment(segment).text;
+            var ogContext = getOriginalContext(context);
+            return text.loadSegment(wantedCdn, ogContext, loaderOptions, cancelToken, callbacks);
+        },
+        parseSegment: function (loadedSegment, context, initTimescale) {
+            var segment = context.segment;
+            var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
+            var text = getTransportPipelinesFromSegment(segment).text;
+            var ogContext = getOriginalContext(context);
+            var parsed = text.parseSegment(loadedSegment, ogContext, initTimescale);
+            if (parsed.segmentType === "init") {
+                return parsed;
+            }
+            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return (0, object_assign_1.default)({}, parsed, timeInfos);
+        },
+    };
+    return { manifest: manifestPipeline,
+        audio: audioPipeline,
+        video: videoPipeline,
+        text: textTrackPipeline };
+}
+exports.default = default_1;

package/dist/commonjs/transports/smooth/extract_timings_infos.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 { ISegment } from "../../manifest";
+import { IChunkTimeInfo } from "../types";
+/** Information on future segments. */
+export interface INextSegmentsInfos {
+    /**
+     * Difference between the latest and the earliest presentation time
+     * available in that segment. The unit is in the corresponding timescale (see
+     * `timescale` property).
+     */
+    duration: number;
+    /**
+     * Earliest presentation time available in that segment.
+     * The unit is in the corresponding timescale (see `timescale` property).
+     */
+    time: number;
+    /**
+     * Allow to convert `duration` and `time` into seconds by dividing them to
+     * that value.
+     * e.g.:
+     *   timeInSeconds = time / timescale
+     *   durationInSeconds = duration / timescale
+     *
+     * Expressing those values relative to a "timescale" allows a greater
+     * precision for the `time` and `duration` values.
+     */
+    timescale: number;
+}
+/**
+ * Try to obtain time information from the given data.
+ * @param {Uint8Array} data
+ * @param {boolean} isChunked
+ * @param {Object} segment
+ * @param {boolean} isLive
+ * @returns {Object}
+ */
+export default function extractTimingsInfos(data: Uint8Array, isChunked: boolean, initTimescale: number, segment: ISegment, isLive: boolean): {
+    /** Possible information on segments after this one. */
+    nextSegments: INextSegmentsInfos[];
+    /** Time information on this segment */
+    chunkInfos: IChunkTimeInfo | null;
+    /**
+     * Start time of this segment in the same timescale than the
+     * initialization segment (so this segment can be patched with this
+     * precize information).
+     */
+    scaledSegmentTime: number | undefined;
+};

package/dist/commonjs/transports/smooth/extract_timings_infos.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var log_1 = require("../../log");
+var isobmff_1 = require("../../parsers/containers/isobmff");
+var isobmff_2 = require("./isobmff");
+/**
+ * Try to obtain time information from the given data.
+ * @param {Uint8Array} data
+ * @param {boolean} isChunked
+ * @param {Object} segment
+ * @param {boolean} isLive
+ * @returns {Object}
+ */
+function extractTimingsInfos(data, isChunked, initTimescale, segment, isLive) {
+    var _a;
+    var nextSegments = [];
+    var chunkInfos;
+    var tfxdSegment;
+    var tfrfSegments;
+    if (isLive) {
+        var traf = (0, isobmff_1.getTRAF)(data);
+        if (traf !== null) {
+            tfrfSegments = (0, isobmff_2.parseTfrf)(traf);
+            tfxdSegment = (0, isobmff_2.parseTfxd)(traf);
+        }
+        else {
+            log_1.default.warn("smooth: could not find traf atom");
+        }
+    }
+    if (tfrfSegments !== undefined) {
+        for (var i = 0; i < tfrfSegments.length; i++) {
+            nextSegments.push({ time: tfrfSegments[i].time,
+                duration: tfrfSegments[i].duration,
+                timescale: initTimescale });
+        }
+    }
+    if (tfxdSegment !== undefined) {
+        chunkInfos = { time: tfxdSegment.time / initTimescale,
+            duration: tfxdSegment.duration / initTimescale };
+        return { nextSegments: nextSegments, chunkInfos: chunkInfos, scaledSegmentTime: tfxdSegment.time };
+    }
+    if (isChunked || !segment.complete) {
+        return { nextSegments: nextSegments, chunkInfos: null,
+            scaledSegmentTime: undefined };
+    }
+    var segmentDuration = segment.duration * initTimescale;
+    // we could always make a mistake when reading a container.
+    // If the estimate is too far from what the segment seems to imply, take
+    // the segment infos instead.
+    var maxDecodeTimeDelta = Math.min(initTimescale * 0.9, segmentDuration / 4);
+    var trunDuration = (0, isobmff_1.getDurationFromTrun)(data);
+    var scaledSegmentTime = ((_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothMediaSegment) !== undefined ?
+        segment.privateInfos.smoothMediaSegment.time :
+        Math.round(segment.time * initTimescale);
+    if (trunDuration !== undefined &&
+        Math.abs(trunDuration - segmentDuration) <= maxDecodeTimeDelta) {
+        chunkInfos = { time: segment.time,
+            duration: trunDuration / initTimescale };
+    }
+    else {
+        chunkInfos = { time: segment.time,
+            duration: segment.duration };
+    }
+    return { nextSegments: nextSegments, chunkInfos: chunkInfos, scaledSegmentTime: scaledSegmentTime };
+}
+exports.default = extractTimingsInfos;

package/dist/commonjs/transports/smooth/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 file is feature-switchable.
+ * It always should be imported through the `features` object.
+ */
+import SmoothPipelines from "./pipelines";
+export default SmoothPipelines;