rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/_esm5.processed/parsers/manifest/dash/common/parse_mpd.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,26 +14,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import config from "../../../../config";
-import log from "../../../../log";
-import arrayFind from "../../../../utils/array_find";
-import { getFilenameIndexInUrl } from "../../../../utils/resolve_url";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
+const log_1 = require("../../../../log");
+const array_find_1 = require("../../../../utils/array_find");
+const monotonic_timestamp_1 = require("../../../../utils/monotonic_timestamp");
+const resolve_url_1 = require("../../../../utils/resolve_url");
 // eslint-disable-next-line max-len
-import getClockOffset from "./get_clock_offset";
-import getHTTPUTCTimingURL from "./get_http_utc-timing_url";
-import getMinimumAndMaximumPositions from "./get_minimum_and_maximum_positions";
-import parseAvailabilityStartTime from "./parse_availability_start_time";
-import parsePeriods from "./parse_periods";
-import resolveBaseURLs from "./resolve_base_urls";
+const get_clock_offset_1 = require("./get_clock_offset");
+const get_http_utc_timing_url_1 = require("./get_http_utc-timing_url");
+const get_minimum_and_maximum_positions_1 = require("./get_minimum_and_maximum_positions");
+const parse_availability_start_time_1 = require("./parse_availability_start_time");
+const parse_periods_1 = require("./parse_periods");
+const resolve_base_urls_1 = require("./resolve_base_urls");
 /**
  * Checks if xlinks needs to be loaded before actually parsing the manifest.
  * @param {Object} mpdIR
@@ -41,19 +35,18 @@ import resolveBaseURLs from "./resolve_base_urls";
  * @param {Array.<Object>} warnings
  * @returns {Object}
  */
-export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkInfos) {
-    if (xlinkInfos === void 0) { xlinkInfos = new WeakMap(); }
-    var rootChildren = mpdIR.children, rootAttributes = mpdIR.attributes;
+function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkInfos = new WeakMap()) {
+    const { children: rootChildren, attributes: rootAttributes } = mpdIR;
     if (args.externalClockOffset == null) {
-        var isDynamic = rootAttributes.type === "dynamic";
-        var directTiming = arrayFind(rootChildren.utcTimings, function (utcTiming) {
+        const isDynamic = rootAttributes.type === "dynamic";
+        const directTiming = (0, array_find_1.default)(rootChildren.utcTimings, (utcTiming) => {
             return utcTiming.schemeIdUri === "urn:mpeg:dash:utc:direct:2014" &&
                 utcTiming.value != null;
         });
-        var clockOffsetFromDirectUTCTiming = directTiming != null &&
-            directTiming.value != null ? getClockOffset(directTiming.value) :
+        const clockOffsetFromDirectUTCTiming = directTiming != null &&
+            directTiming.value != null ? (0, get_clock_offset_1.default)(directTiming.value) :
             undefined;
-        var clockOffset = clockOffsetFromDirectUTCTiming != null &&
+        const clockOffset = clockOffsetFromDirectUTCTiming != null &&
             !isNaN(clockOffsetFromDirectUTCTiming) ?
             clockOffsetFromDirectUTCTiming :
             undefined;
@@ -61,7 +54,7 @@ export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkI
             args.externalClockOffset = clockOffset;
         }
         else if (isDynamic && hasLoadedClock !== true) {
-            var UTCTimingHTTPURL = getHTTPUTCTimingURL(mpdIR);
+            const UTCTimingHTTPURL = (0, get_http_utc_timing_url_1.default)(mpdIR);
             if (UTCTimingHTTPURL != null && UTCTimingHTTPURL.length > 0) {
                 // TODO fetch UTCTiming and XLinks at the same time
                 return {
@@ -71,10 +64,10 @@ export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkI
                         continue: function continueParsingMPD(responseDataClock) {
                             if (!responseDataClock.success) {
                                 warnings.push(responseDataClock.error);
-                                log.warn("DASH Parser: Error on fetching the clock ressource", responseDataClock.error);
+                                log_1.default.warn("DASH Parser: Error on fetching the clock ressource", responseDataClock.error);
                                 return parseMpdIr(mpdIR, args, warnings, true);
                             }
-                            args.externalClockOffset = getClockOffset(responseDataClock.data);
+                            args.externalClockOffset = (0, get_clock_offset_1.default)(responseDataClock.data);
                             return parseMpdIr(mpdIR, args, warnings, true);
                         },
                     },
@@ -82,9 +75,9 @@ export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkI
             }
         }
     }
-    var xlinksToLoad = [];
-    for (var i = 0; i < rootChildren.periods.length; i++) {
-        var _a = rootChildren.periods[i].attributes, xlinkHref = _a.xlinkHref, xlinkActuate = _a.xlinkActuate;
+    const xlinksToLoad = [];
+    for (let i = 0; i < rootChildren.periods.length; i++) {
+        const { xlinkHref, xlinkActuate } = rootChildren.periods[i].attributes;
         if (xlinkHref != null && xlinkActuate === "onLoad") {
             xlinksToLoad.push({ index: i, ressource: xlinkHref });
         }
@@ -95,35 +88,31 @@ export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkI
     return {
         type: "needs-xlinks",
         value: {
-            xlinksUrls: xlinksToLoad.map(function (_a) {
-                var ressource = _a.ressource;
-                return ressource;
-            }),
+            xlinksUrls: xlinksToLoad.map(({ ressource }) => ressource),
             continue: function continueParsingMPD(loadedRessources) {
-                var _a;
                 if (loadedRessources.length !== xlinksToLoad.length) {
                     throw new Error("DASH parser: wrong number of loaded ressources.");
                 }
                 // Note: It is important to go from the last index to the first index in
                 // the resulting array, as we will potentially add elements to the array
-                for (var i = loadedRessources.length - 1; i >= 0; i--) {
-                    var index = xlinksToLoad[i].index;
-                    var _b = loadedRessources[i], periodsIR = _b.parsed, parsingWarnings = _b.warnings, receivedTime = _b.receivedTime, sendingTime = _b.sendingTime, url = _b.url;
+                for (let i = loadedRessources.length - 1; i >= 0; i--) {
+                    const index = xlinksToLoad[i].index;
+                    const { parsed: periodsIR, warnings: parsingWarnings, receivedTime, sendingTime, url } = loadedRessources[i];
                     if (parsingWarnings.length > 0) {
-                        warnings.push.apply(warnings, parsingWarnings);
+                        warnings.push(...parsingWarnings);
                     }
-                    for (var _i = 0, periodsIR_1 = periodsIR; _i < periodsIR_1.length; _i++) {
-                        var periodIR = periodsIR_1[_i];
-                        xlinkInfos.set(periodIR, { receivedTime: receivedTime, sendingTime: sendingTime, url: url });
+                    for (const periodIR of periodsIR) {
+                        xlinkInfos.set(periodIR, { receivedTime, sendingTime, url });
                     }
                     // replace original "xlinked" periods by the real deal
-                    (_a = rootChildren.periods).splice.apply(_a, __spreadArray([index, 1], periodsIR, false));
+                    rootChildren.periods.splice(index, 1, ...periodsIR);
                 }
                 return parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkInfos);
             },
         },
     };
 }
+exports.default = parseMpdIr;
 /**
  * Parse the MPD intermediate representation into a regular Manifest.
  * @param {Object} mpdIR
@@ -134,39 +123,48 @@ export default function parseMpdIr(mpdIR, args, warnings, hasLoadedClock, xlinkI
  */
 function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInfos) {
     var _a, _b, _c;
-    var rootChildren = mpdIR.children, rootAttributes = mpdIR.attributes;
-    var isDynamic = rootAttributes.type === "dynamic";
-    var initialBaseUrl = args.url !== undefined ?
-        [{ url: args.url.substring(0, getFilenameIndexInUrl(args.url)) }] :
+    const { children: rootChildren, attributes: rootAttributes } = mpdIR;
+    const isDynamic = rootAttributes.type === "dynamic";
+    const initialBaseUrl = args.url !== undefined ?
+        [{ url: args.url.substring(0, (0, resolve_url_1.getFilenameIndexInUrl)(args.url)) }] :
         [];
-    var mpdBaseUrls = resolveBaseURLs(initialBaseUrl, rootChildren.baseURLs);
-    var availabilityStartTime = parseAvailabilityStartTime(rootAttributes, args.referenceDateTime);
-    var timeShiftBufferDepth = rootAttributes.timeShiftBufferDepth;
-    var clockOffset = args.externalClockOffset, unsafelyBaseOnPreviousManifest = args.unsafelyBaseOnPreviousManifest;
-    var manifestInfos = { availabilityStartTime: availabilityStartTime, baseURLs: mpdBaseUrls, clockOffset: clockOffset, duration: rootAttributes.duration, isDynamic: isDynamic, manifestProfiles: mpdIR.attributes.profiles,
-        receivedTime: args.manifestReceivedTime, timeShiftBufferDepth: timeShiftBufferDepth, unsafelyBaseOnPreviousManifest: unsafelyBaseOnPreviousManifest, xlinkInfos: xlinkInfos, xmlNamespaces: mpdIR.attributes.namespaces };
-    var parsedPeriods = parsePeriods(rootChildren.periods, manifestInfos);
-    var mediaPresentationDuration = rootAttributes.duration;
-    var lifetime;
-    var minimumTime;
-    var timeshiftDepth = null;
-    var maximumTimeData;
+    const mpdBaseUrls = (0, resolve_base_urls_1.default)(initialBaseUrl, rootChildren.baseURLs);
+    const availabilityStartTime = (0, parse_availability_start_time_1.default)(rootAttributes, args.referenceDateTime);
+    const timeShiftBufferDepth = rootAttributes.timeShiftBufferDepth;
+    const { externalClockOffset: clockOffset, unsafelyBaseOnPreviousManifest } = args;
+    const manifestInfos = { availabilityStartTime,
+        baseURLs: mpdBaseUrls,
+        clockOffset,
+        duration: rootAttributes.duration,
+        isDynamic,
+        manifestProfiles: mpdIR.attributes.profiles,
+        receivedTime: args.manifestReceivedTime,
+        timeShiftBufferDepth,
+        unsafelyBaseOnPreviousManifest,
+        xlinkInfos,
+        xmlNamespaces: mpdIR.attributes.namespaces };
+    const parsedPeriods = (0, parse_periods_1.default)(rootChildren.periods, manifestInfos);
+    const mediaPresentationDuration = rootAttributes.duration;
+    let lifetime;
+    let minimumTime;
+    let timeshiftDepth = null;
+    let maximumTimeData;
     if (rootAttributes.minimumUpdatePeriod !== undefined &&
         rootAttributes.minimumUpdatePeriod >= 0) {
         lifetime = rootAttributes.minimumUpdatePeriod === 0 ?
-            config.getCurrent().DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 :
+            config_1.default.getCurrent().DASH_FALLBACK_LIFETIME_WHEN_MINIMUM_UPDATE_PERIOD_EQUAL_0 :
             rootAttributes.minimumUpdatePeriod;
     }
-    var _d = getMinimumAndMaximumPositions(parsedPeriods), minimumSafePosition = _d.minimumSafePosition, maximumSafePosition = _d.maximumSafePosition, maximumUnsafePosition = _d.maximumUnsafePosition;
-    var now = performance.now();
+    const { minimumSafePosition, maximumSafePosition, maximumUnsafePosition } = (0, get_minimum_and_maximum_positions_1.default)(parsedPeriods);
+    const now = (0, monotonic_timestamp_1.default)();
     if (!isDynamic) {
         minimumTime = minimumSafePosition !== undefined ? minimumSafePosition :
             ((_a = parsedPeriods[0]) === null || _a === void 0 ? void 0 : _a.start) !== undefined ? parsedPeriods[0].start :
                 0;
-        var finalMaximumSafePosition = mediaPresentationDuration !== null && mediaPresentationDuration !== void 0 ? mediaPresentationDuration : Infinity;
+        let finalMaximumSafePosition = mediaPresentationDuration !== null && mediaPresentationDuration !== void 0 ? mediaPresentationDuration : Infinity;
         if (parsedPeriods[parsedPeriods.length - 1] !== undefined) {
-            var lastPeriod = parsedPeriods[parsedPeriods.length - 1];
-            var lastPeriodEnd = (_b = lastPeriod.end) !== null && _b !== void 0 ? _b : (lastPeriod.duration !== undefined ?
+            const lastPeriod = parsedPeriods[parsedPeriods.length - 1];
+            const lastPeriodEnd = (_b = lastPeriod.end) !== null && _b !== void 0 ? _b : (lastPeriod.duration !== undefined ?
                 lastPeriod.start + lastPeriod.duration :
                 undefined);
             if (lastPeriodEnd !== undefined && lastPeriodEnd < finalMaximumSafePosition) {
@@ -185,8 +183,8 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
     else {
         minimumTime = minimumSafePosition;
         timeshiftDepth = timeShiftBufferDepth !== null && timeShiftBufferDepth !== void 0 ? timeShiftBufferDepth : null;
-        var finalMaximumSafePosition = void 0;
-        var livePosition = void 0;
+        let finalMaximumSafePosition;
+        let livePosition;
         if (maximumUnsafePosition !== undefined) {
             livePosition = maximumUnsafePosition;
         }
@@ -194,14 +192,14 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
             finalMaximumSafePosition = maximumSafePosition;
         }
         else {
-            var ast = availabilityStartTime !== null && availabilityStartTime !== void 0 ? availabilityStartTime : 0;
-            var externalClockOffset = args.externalClockOffset;
+            const ast = availabilityStartTime !== null && availabilityStartTime !== void 0 ? availabilityStartTime : 0;
+            const { externalClockOffset } = args;
             if (externalClockOffset === undefined) {
-                log.warn("DASH Parser: use system clock to define maximum position");
+                log_1.default.warn("DASH Parser: use system clock to define maximum position");
                 finalMaximumSafePosition = (Date.now() / 1000) - ast;
             }
             else {
-                var serverTime = performance.now() + externalClockOffset;
+                const serverTime = (0, monotonic_timestamp_1.default)() + externalClockOffset;
                 finalMaximumSafePosition = (serverTime / 1000) - ast;
             }
         }
@@ -209,7 +207,9 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
             livePosition = finalMaximumSafePosition;
         }
         maximumTimeData = { isLinear: true,
-            maximumSafePosition: finalMaximumSafePosition, livePosition: livePosition, time: now };
+            maximumSafePosition: finalMaximumSafePosition,
+            livePosition,
+            time: now };
         // if the minimum calculated time is even below the buffer depth, perhaps we
         // can go even lower in terms of depth
         if (timeshiftDepth !== null && minimumTime !== undefined &&
@@ -224,24 +224,26 @@ function parseCompleteIntermediateRepresentation(mpdIR, args, warnings, xlinkInf
     //      the `minimumUpdatePeriod` is not set. This corresponds to the case
     //      explained in "4.6.4. Transition Phase between Live and On-Demand" of
     //      the DASH-IF IOP v4.3 for live contents transitionning to on-demand.
-    var isLastPeriodKnown = !isDynamic ||
+    const isLastPeriodKnown = !isDynamic ||
         (mpdIR.attributes.minimumUpdatePeriod === undefined &&
             (((_c = parsedPeriods[parsedPeriods.length - 1]) === null || _c === void 0 ? void 0 : _c.end) !== undefined ||
                 mpdIR.attributes.duration !== undefined));
-    var parsedMPD = {
-        availabilityStartTime: availabilityStartTime,
+    const parsedMPD = {
+        availabilityStartTime,
         clockOffset: args.externalClockOffset,
-        isDynamic: isDynamic,
+        isDynamic,
         isLive: isDynamic,
-        isLastPeriodKnown: isLastPeriodKnown,
+        isLastPeriodKnown,
         periods: parsedPeriods,
         publishTime: rootAttributes.publishTime,
         suggestedPresentationDelay: rootAttributes.suggestedPresentationDelay,
         transportType: "dash",
-        timeBounds: { minimumSafePosition: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
-        lifetime: lifetime,
+        timeBounds: { minimumSafePosition: minimumTime,
+            timeshiftDepth,
+            maximumTimeData },
+        lifetime,
         uris: args.url == null ?
-            rootChildren.locations : __spreadArray([args.url], rootChildren.locations, true),
+            rootChildren.locations : [args.url, ...rootChildren.locations],
     };
-    return { type: "done", value: { parsed: parsedMPD, warnings: warnings } };
+    return { type: "done", value: { parsed: parsedMPD, warnings } };
 }

package/dist/_esm5.processed/parsers/manifest/dash/common/parse_periods.d.ts

@@ -36,6 +36,10 @@ export default function parsePeriods(periodsIR: IPeriodIntermediateRepresentatio
 /** Context needed when calling `parsePeriods`. */
 export interface IPeriodContext extends IInheritedAdaptationContext {
     availabilityStartTime: number;
+    /**
+     * Difference between the server's clock, in milliseconds, and the
+     * monotonically-raising timestamp used by the RxPlayer.
+     */
     clockOffset?: number | undefined;
     /** Duration (mediaPresentationDuration) of the whole MPD, in seconds. */
     duration?: number | undefined;

package/dist/_esm5.processed/parsers/manifest/dash/common/parse_periods.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,74 +14,93 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../../log";
-import flatMap from "../../../../utils/flat_map";
-import idGenerator from "../../../../utils/id_generator";
-import objectValues from "../../../../utils/object_values";
-import { utf8ToStr } from "../../../../utils/string_parsing";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../../log");
+const flat_map_1 = require("../../../../utils/flat_map");
+const id_generator_1 = require("../../../../utils/id_generator");
+const monotonic_timestamp_1 = require("../../../../utils/monotonic_timestamp");
+const object_values_1 = require("../../../../utils/object_values");
+const string_parsing_1 = require("../../../../utils/string_parsing");
 // eslint-disable-next-line max-len
-import flattenOverlappingPeriods from "./flatten_overlapping_periods";
-import getPeriodsTimeInformation from "./get_periods_time_infos";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import parseAdaptationSets from "./parse_adaptation_sets";
-import resolveBaseURLs from "./resolve_base_urls";
-var generatePeriodID = idGenerator();
+const flatten_overlapping_periods_1 = require("./flatten_overlapping_periods");
+const get_periods_time_infos_1 = require("./get_periods_time_infos");
+const manifest_bounds_calculator_1 = require("./manifest_bounds_calculator");
+const parse_adaptation_sets_1 = require("./parse_adaptation_sets");
+const resolve_base_urls_1 = require("./resolve_base_urls");
+const generatePeriodID = (0, id_generator_1.default)();
 /**
  * Process intermediate periods to create final parsed periods.
  * @param {Array.<Object>} periodsIR
  * @param {Object} context
  * @returns {Array.<Object>}
  */
-export default function parsePeriods(periodsIR, context) {
+function parsePeriods(periodsIR, context) {
     var _a, _b, _c, _d, _e, _f;
-    var parsedPeriods = [];
-    var periodsTimeInformation = getPeriodsTimeInformation(periodsIR, context);
+    const parsedPeriods = [];
+    const periodsTimeInformation = (0, get_periods_time_infos_1.default)(periodsIR, context);
     if (periodsTimeInformation.length !== periodsIR.length) {
         throw new Error("MPD parsing error: the time information are incoherent.");
     }
-    var isDynamic = context.isDynamic, timeShiftBufferDepth = context.timeShiftBufferDepth;
-    var manifestBoundsCalculator = new ManifestBoundsCalculator({ isDynamic: isDynamic, timeShiftBufferDepth: timeShiftBufferDepth });
+    const { isDynamic, timeShiftBufferDepth } = context;
+    const manifestBoundsCalculator = new manifest_bounds_calculator_1.default({ isDynamic,
+        timeShiftBufferDepth });
     if (!isDynamic && context.duration != null) {
         manifestBoundsCalculator.setLastPosition(context.duration);
     }
-    var _loop_1 = function (i) {
-        var isLastPeriod = i === periodsIR.length - 1;
-        var periodIR = periodsIR[i];
-        var xlinkInfos = context.xlinkInfos.get(periodIR);
-        var periodBaseURLs = resolveBaseURLs(context.baseURLs, periodIR.children.baseURLs);
-        var _g = periodsTimeInformation[i], periodStart = _g.periodStart, periodDuration = _g.periodDuration, periodEnd = _g.periodEnd;
-        var periodID;
+    // We parse it in reverse because we might need to deduce the buffer depth from
+    // the last Periods' indexes
+    for (let i = periodsIR.length - 1; i >= 0; i--) {
+        const isLastPeriod = i === periodsIR.length - 1;
+        const periodIR = periodsIR[i];
+        const xlinkInfos = context.xlinkInfos.get(periodIR);
+        const periodBaseURLs = (0, resolve_base_urls_1.default)(context.baseURLs, periodIR.children.baseURLs);
+        const { periodStart, periodDuration, periodEnd } = periodsTimeInformation[i];
+        let periodID;
         if (periodIR.attributes.id == null) {
-            log.warn("DASH: No usable id found in the Period. Generating one.");
+            log_1.default.warn("DASH: No usable id found in the Period. Generating one.");
             periodID = "gen-dash-period-" + generatePeriodID();
         }
         else {
             periodID = periodIR.attributes.id;
         }
         // Avoid duplicate IDs
-        while (parsedPeriods.some(function (p) { return p.id === periodID; })) {
+        while (parsedPeriods.some(p => p.id === periodID)) {
             periodID += "-dup";
         }
-        var receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime :
+        const receivedTime = xlinkInfos !== undefined ? xlinkInfos.receivedTime :
             context.receivedTime;
-        var unsafelyBaseOnPreviousPeriod = (_b = (_a = context
+        const unsafelyBaseOnPreviousPeriod = (_b = (_a = context
             .unsafelyBaseOnPreviousManifest) === null || _a === void 0 ? void 0 : _a.getPeriod(periodID)) !== null && _b !== void 0 ? _b : null;
-        var availabilityTimeComplete = (_c = periodIR.attributes.availabilityTimeComplete) !== null && _c !== void 0 ? _c : true;
-        var availabilityTimeOffset = (_d = periodIR.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0;
-        var manifestProfiles = context.manifestProfiles;
-        var segmentTemplate = periodIR.children.segmentTemplate;
-        var adapCtxt = { availabilityTimeComplete: availabilityTimeComplete, availabilityTimeOffset: availabilityTimeOffset, baseURLs: periodBaseURLs, manifestBoundsCalculator: manifestBoundsCalculator, end: periodEnd, isDynamic: isDynamic, isLastPeriod: isLastPeriod, manifestProfiles: manifestProfiles, receivedTime: receivedTime, segmentTemplate: segmentTemplate, start: periodStart, timeShiftBufferDepth: timeShiftBufferDepth, unsafelyBaseOnPreviousPeriod: unsafelyBaseOnPreviousPeriod };
-        var adaptations = parseAdaptationSets(periodIR.children.adaptations, adapCtxt);
-        var namespaces = ((_e = context.xmlNamespaces) !== null && _e !== void 0 ? _e : [])
+        const availabilityTimeComplete = (_c = periodIR.attributes.availabilityTimeComplete) !== null && _c !== void 0 ? _c : true;
+        const availabilityTimeOffset = (_d = periodIR.attributes.availabilityTimeOffset) !== null && _d !== void 0 ? _d : 0;
+        const { manifestProfiles } = context;
+        const { segmentTemplate } = periodIR.children;
+        const adapCtxt = { availabilityTimeComplete,
+            availabilityTimeOffset,
+            baseURLs: periodBaseURLs,
+            manifestBoundsCalculator,
+            end: periodEnd,
+            isDynamic,
+            isLastPeriod,
+            manifestProfiles,
+            receivedTime,
+            segmentTemplate,
+            start: periodStart,
+            timeShiftBufferDepth,
+            unsafelyBaseOnPreviousPeriod };
+        const adaptations = (0, parse_adaptation_sets_1.default)(periodIR.children.adaptations, adapCtxt);
+        const namespaces = ((_e = context.xmlNamespaces) !== null && _e !== void 0 ? _e : [])
             .concat((_f = periodIR.attributes.namespaces) !== null && _f !== void 0 ? _f : []);
-        var streamEvents = generateStreamEvents(periodIR.children.eventStreams, periodStart, namespaces);
-        var parsedPeriod = { id: periodID,
+        const streamEvents = generateStreamEvents(periodIR.children.eventStreams, periodStart, namespaces);
+        const parsedPeriod = { id: periodID,
             start: periodStart,
             end: periodEnd,
-            duration: periodDuration, adaptations: adaptations, streamEvents: streamEvents };
+            duration: periodDuration,
+            adaptations,
+            streamEvents };
         parsedPeriods.unshift(parsedPeriod);
         if (!manifestBoundsCalculator.lastPositionIsKnown()) {
-            var lastPosition = getMaximumLastPosition(adaptations);
+            const lastPosition = getMaximumLastPosition(adaptations);
             if (!isDynamic) {
                 if (typeof lastPosition === "number") {
                     manifestBoundsCalculator.setLastPosition(lastPosition);
@@ -88,42 +108,39 @@ export default function parsePeriods(periodsIR, context) {
             }
             else {
                 if (typeof lastPosition === "number") {
-                    var positionTime = performance.now() / 1000;
+                    const positionTime = (0, monotonic_timestamp_1.default)() / 1000;
                     manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
                 }
                 else {
-                    var guessedLastPositionFromClock = guessLastPositionFromClock(context, periodStart);
+                    const guessedLastPositionFromClock = guessLastPositionFromClock(context, periodStart);
                     if (guessedLastPositionFromClock !== undefined) {
-                        var guessedLastPosition = guessedLastPositionFromClock[0], guessedPositionTime = guessedLastPositionFromClock[1];
+                        const [guessedLastPosition, guessedPositionTime] = guessedLastPositionFromClock;
                         manifestBoundsCalculator.setLastPosition(guessedLastPosition, guessedPositionTime);
                     }
                 }
             }
         }
-    };
-    // We parse it in reverse because we might need to deduce the buffer depth from
-    // the last Periods' indexes
-    for (var i = periodsIR.length - 1; i >= 0; i--) {
-        _loop_1(i);
     }
     if (context.isDynamic && !manifestBoundsCalculator.lastPositionIsKnown()) {
         // Guess a last time the last position
-        var guessedLastPositionFromClock = guessLastPositionFromClock(context, 0);
+        const guessedLastPositionFromClock = guessLastPositionFromClock(context, 0);
         if (guessedLastPositionFromClock !== undefined) {
-            var lastPosition = guessedLastPositionFromClock[0], positionTime = guessedLastPositionFromClock[1];
+            const [lastPosition, positionTime] = guessedLastPositionFromClock;
             manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
         }
     }
-    return flattenOverlappingPeriods(parsedPeriods);
+    return (0, flatten_overlapping_periods_1.default)(parsedPeriods);
 }
+exports.default = parsePeriods;
 /**
  * Try to guess the "last position", which is the last position
- * available in the manifest in seconds, and the "position time", the time
- * (`performance.now()`) in which the last position was collected.
+ * available in the manifest in seconds, and the "position time", the
+ * monotonically-raising timestamp used by the RxPlayer, at which the
+ * last position was collected.
  *
  * These values allows to retrieve at any time in the future the new last
  * position, by substracting the position time to the last position, and
- * adding to it the new value returned by `performance.now`.
+ * adding to it the new monotonically-raising timestamp.
  *
  * The last position and position time are returned by this function if and only if
  * it would indicate a last position superior to the `minimumTime` given.
@@ -145,21 +162,21 @@ export default function parsePeriods(periodsIR, context) {
  */
 function guessLastPositionFromClock(context, minimumTime) {
     if (context.clockOffset != null) {
-        var lastPosition = context.clockOffset / 1000 -
+        const lastPosition = context.clockOffset / 1000 -
             context.availabilityStartTime;
-        var positionTime = performance.now() / 1000;
-        var timeInSec = positionTime + lastPosition;
+        const positionTime = (0, monotonic_timestamp_1.default)() / 1000;
+        const timeInSec = positionTime + lastPosition;
         if (timeInSec >= minimumTime) {
             return [timeInSec, positionTime];
         }
     }
     else {
-        var now = Date.now() / 1000;
+        const now = Date.now() / 1000;
         if (now >= minimumTime) {
-            log.warn("DASH Parser: no clock synchronization mechanism found." +
+            log_1.default.warn("DASH Parser: no clock synchronization mechanism found." +
                 " Using the system clock instead.");
-            var lastPosition = now - context.availabilityStartTime;
-            var positionTime = performance.now() / 1000;
+            const lastPosition = now - context.availabilityStartTime;
+            const positionTime = (0, monotonic_timestamp_1.default)() / 1000;
             return [lastPosition, positionTime];
         }
     }
@@ -176,17 +193,15 @@ function guessLastPositionFromClock(context, minimumTime) {
  * @returns {number|null|undefined}
  */
 function getMaximumLastPosition(adaptationsPerType) {
-    var maxEncounteredPosition = null;
-    var allIndexAreEmpty = true;
-    var adaptationsVal = objectValues(adaptationsPerType)
-        .filter(function (ada) { return ada != null; });
-    var allAdaptations = flatMap(adaptationsVal, function (adaptationsForType) { return adaptationsForType; });
-    for (var _i = 0, allAdaptations_1 = allAdaptations; _i < allAdaptations_1.length; _i++) {
-        var adaptation = allAdaptations_1[_i];
-        var representations = adaptation.representations;
-        for (var _a = 0, representations_1 = representations; _a < representations_1.length; _a++) {
-            var representation = representations_1[_a];
-            var position = representation.index.getLastAvailablePosition();
+    let maxEncounteredPosition = null;
+    let allIndexAreEmpty = true;
+    const adaptationsVal = (0, object_values_1.default)(adaptationsPerType)
+        .filter((ada) => ada != null);
+    const allAdaptations = (0, flat_map_1.default)(adaptationsVal, (adaptationsForType) => adaptationsForType);
+    for (const adaptation of allAdaptations) {
+        const representations = adaptation.representations;
+        for (const representation of representations) {
+            const position = representation.index.getLastAvailablePosition();
             if (position !== null) {
                 allIndexAreEmpty = false;
                 if (typeof position === "number") {
@@ -216,20 +231,18 @@ function getMaximumLastPosition(adaptationsPerType) {
  */
 function generateStreamEvents(baseIr, periodStart, xmlNamespaces) {
     var _a, _b;
-    var res = [];
-    for (var _i = 0, baseIr_1 = baseIr; _i < baseIr_1.length; _i++) {
-        var eventStreamIr = baseIr_1[_i];
-        var _c = eventStreamIr.attributes, _d = _c.schemeIdUri, schemeIdUri = _d === void 0 ? "" : _d, _e = _c.timescale, timescale = _e === void 0 ? 1 : _e;
-        var allNamespaces = xmlNamespaces
+    const res = [];
+    for (const eventStreamIr of baseIr) {
+        const { schemeIdUri = "", timescale = 1 } = eventStreamIr.attributes;
+        const allNamespaces = xmlNamespaces
             .concat((_a = eventStreamIr.attributes.namespaces) !== null && _a !== void 0 ? _a : []);
-        for (var _f = 0, _g = eventStreamIr.children.events; _f < _g.length; _f++) {
-            var eventIr = _g[_f];
+        for (const eventIr of eventStreamIr.children.events) {
             if (eventIr.eventStreamData !== undefined) {
-                var start = (((_b = eventIr.presentationTime) !== null && _b !== void 0 ? _b : 0) / timescale) + periodStart;
-                var end = eventIr.duration === undefined ?
+                const start = (((_b = eventIr.presentationTime) !== null && _b !== void 0 ? _b : 0) / timescale) + periodStart;
+                const end = eventIr.duration === undefined ?
                     undefined :
                     start + (eventIr.duration / timescale);
-                var element = void 0;
+                let element;
                 if (eventIr.eventStreamData instanceof Element) {
                     element = eventIr.eventStreamData;
                 }
@@ -239,19 +252,23 @@ function generateStreamEvents(baseIr, periodStart, xmlNamespaces) {
                     // This is needed because the DOMParser API might throw when
                     // encountering unknown namespaced attributes or elements in the given
                     // `<Event>` xml subset.
-                    var parentNode = allNamespaces.reduce(function (acc, ns) {
+                    let parentNode = allNamespaces.reduce((acc, ns) => {
                         return acc + "xmlns:" + ns.key + "=\"" + ns.value + "\" ";
                     }, "<toremove ");
                     parentNode += ">";
-                    var elementToString = utf8ToStr(new Uint8Array(eventIr.eventStreamData));
+                    const elementToString = (0, string_parsing_1.utf8ToStr)(new Uint8Array(eventIr.eventStreamData));
                     element = new DOMParser()
                         .parseFromString(parentNode + elementToString + "</toremove>", "application/xml")
                         .documentElement
                         .childNodes[0]; // unwrap from the `<toremove>` element
                 }
-                res.push({ start: start, end: end, id: eventIr.id,
+                res.push({ start,
+                    end,
+                    id: eventIr.id,
                     data: { type: "dash-event-stream",
-                        value: { schemeIdUri: schemeIdUri, timescale: timescale, element: element } } });
+                        value: { schemeIdUri,
+                            timescale,
+                            element } } });
             }
         }
     }

package/dist/_esm5.processed/parsers/manifest/dash/common/parse_representation_index.d.ts

@@ -55,8 +55,8 @@ export interface IRepresentationIndexContext {
      */
     parentSegmentTemplates: ISegmentTemplateIntermediateRepresentation[];
     /**
-     * Time (in terms of `performance.now`) at which the XML file containing this
-     * Representation was received.
+     * Time (as the monotonically-raising timestamp used by the RxPlayer) at which
+     * the XML file containing this Representation was received.
      */
     receivedTime?: number | undefined;
     /** Start time of the current period, in seconds. */