rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/commonjs/core/stream/period/utils/get_adaptation_switch_strategy.js

@@ -14,6 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("../../../../config");
 var are_codecs_compatible_1 = require("../../../../utils/are_codecs_compatible");
@@ -29,53 +40,59 @@ var segment_buffers_1 = require("../../../segment_buffers");
  * @returns {Object}
  */
 function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackObserver, options) {
+    var e_1, _a, e_2, _b;
+    var _c, _d;
     if (segmentBuffer.codec !== undefined &&
         options.onCodecSwitch === "reload" &&
         !hasCompatibleCodec(adaptation, segmentBuffer.codec)) {
         return { type: "needs-reload", value: undefined };
     }
-    var buffered = segmentBuffer.getBufferedRanges();
-    if (buffered.length === 0) {
-        return { type: "continue", value: undefined };
+    var inventory = segmentBuffer.getLastKnownInventory();
+    var unwantedRange = [];
+    try {
+        for (var inventory_1 = __values(inventory), inventory_1_1 = inventory_1.next(); !inventory_1_1.done; inventory_1_1 = inventory_1.next()) {
+            var elt = inventory_1_1.value;
+            if (elt.infos.period.id === period.id && elt.infos.adaptation.id !== adaptation.id) {
+                (0, ranges_1.insertInto)(unwantedRange, { start: (_c = elt.bufferedStart) !== null && _c !== void 0 ? _c : elt.start,
+                    end: (_d = elt.bufferedEnd) !== null && _d !== void 0 ? _d : elt.end });
+            }
+        }
     }
-    var bufferedRanges = (0, ranges_1.convertToRanges)(buffered);
-    var start = period.start;
-    var end = period.end == null ? Infinity :
-        period.end;
-    var intersection = (0, ranges_1.keepRangeIntersection)(bufferedRanges, [{ start: start, end: end }]);
-    if (intersection.length === 0) {
-        return { type: "continue", value: undefined };
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (inventory_1_1 && !inventory_1_1.done && (_a = inventory_1.return)) _a.call(inventory_1);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
-    segmentBuffer.synchronizeInventory();
-    var inventory = segmentBuffer.getInventory();
-    // Continue if we have no other Adaptation buffered in the current Period
-    if (!inventory.some(function (buf) { return buf.infos.period.id === period.id &&
-        buf.infos.adaptation.id !== adaptation.id; })) {
-        return { type: "continue", value: undefined };
+    var pendingOperations = segmentBuffer.getPendingOperations();
+    try {
+        for (var pendingOperations_1 = __values(pendingOperations), pendingOperations_1_1 = pendingOperations_1.next(); !pendingOperations_1_1.done; pendingOperations_1_1 = pendingOperations_1.next()) {
+            var operation = pendingOperations_1_1.value;
+            if (operation.type === segment_buffers_1.SegmentBufferOperation.Push) {
+                var info = operation.value.inventoryInfos;
+                if (info.period.id === period.id && info.adaptation.id !== adaptation.id) {
+                    var start = info.segment.time;
+                    var end = start + info.segment.duration;
+                    (0, ranges_1.insertInto)(unwantedRange, { start: start, end: end });
+                }
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (pendingOperations_1_1 && !pendingOperations_1_1.done && (_b = pendingOperations_1.return)) _b.call(pendingOperations_1);
+        }
+        finally { if (e_2) throw e_2.error; }
     }
-    /** Data already in the right Adaptation */
-    var adaptationInBuffer = getBufferedRangesFromAdaptation(inventory, period, adaptation);
-    /**
-     * Data different from the wanted Adaptation in the Period's range.
-     * /!\ Could contain some data at the end of the previous Period or at the
-     * beginning of the next one.
-     */
-    var unwantedRange = (0, ranges_1.excludeFromRanges)(intersection, adaptationInBuffer);
+    // Continue if we have no other Adaptation buffered in the current Period
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    var currentTime = playbackObserver.getCurrentTime();
-    var readyState = playbackObserver.getReadyState();
-    if (switchingMode === "reload" && readyState > 1) {
-        var lastObservation = playbackObserver.getReference().getValue();
-        if (lastObservation.position.isAwaitingFuturePosition()) {
-            // We are not at the position we want to reach (e.g. initial seek, tizen
-            // seek-back...), just reload as checks here would be too complex
-            return { type: "needs-reload", value: undefined };
-        }
-        else if ((0, ranges_1.isTimeInRange)({ start: start, end: end }, currentTime) &&
-            // We're not playing the current wanted video Adaptation
-            !(0, ranges_1.isTimeInRanges)(adaptationInBuffer, currentTime)) {
+    if (switchingMode === "reload") {
+        var readyState = playbackObserver.getReadyState();
+        if (readyState === undefined || readyState > 1) {
             return { type: "needs-reload", value: undefined };
         }
     }
@@ -95,19 +112,25 @@ function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchin
         rangesToExclude.push({ start: 0,
             end: period.start + 1 });
     }
-    // Next, exclude data around current position to avoid decoding issues
-    var bufferType = adaptation.type;
-    var ADAP_REP_SWITCH_BUFFER_PADDINGS = config_1.default.getCurrent().ADAP_REP_SWITCH_BUFFER_PADDINGS;
-    /** Ranges that won't be cleaned from the current buffer. */
-    var paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
-    if (paddingBefore == null) {
-        paddingBefore = 0;
-    }
-    var paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
-    if (paddingAfter == null) {
-        paddingAfter = 0;
-    }
     if (!shouldCleanAll) {
+        // Exclude data around current position to avoid decoding issues
+        var bufferType = adaptation.type;
+        var ADAP_REP_SWITCH_BUFFER_PADDINGS = config_1.default.getCurrent().ADAP_REP_SWITCH_BUFFER_PADDINGS;
+        /** Ranges that won't be cleaned from the current buffer. */
+        var paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
+        if (paddingBefore == null) {
+            paddingBefore = 0;
+        }
+        var paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
+        if (paddingAfter == null) {
+            paddingAfter = 0;
+        }
+        var currentTime = playbackObserver.getCurrentTime();
+        if (currentTime === undefined) {
+            // TODO current position might be old. A better solution should be found.
+            var lastObservation = playbackObserver.getReference().getValue();
+            currentTime = lastObservation.position.getPolled();
+        }
         rangesToExclude.push({ start: currentTime - paddingBefore,
             end: currentTime + paddingAfter });
     }
@@ -141,29 +164,9 @@ exports.default = getAdaptationSwitchStrategy;
  * @returns {boolean}
  */
 function hasCompatibleCodec(adaptation, segmentBufferCodec) {
-    return adaptation.getPlayableRepresentations().some(function (rep) {
-        return (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), segmentBufferCodec);
+    return adaptation.representations.some(function (rep) {
+        return rep.isSupported === true &&
+            rep.decipherable !== false &&
+            (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), segmentBufferCodec);
     });
 }
-/**
- * Returns buffered ranges of what we know correspond to the given `adaptation`
- * in the SegmentBuffer.
- * @param {Array.<Object>} inventory
- * @param {Object} period
- * @param {Object} adaptation
- * @returns {Array.<Object>}
- */
-function getBufferedRangesFromAdaptation(inventory, period, adaptation) {
-    return inventory.reduce(function (acc, chunk) {
-        if (chunk.infos.period.id !== period.id ||
-            chunk.infos.adaptation.id !== adaptation.id) {
-            return acc;
-        }
-        var bufferedStart = chunk.bufferedStart, bufferedEnd = chunk.bufferedEnd;
-        if (bufferedStart === undefined || bufferedEnd === undefined) {
-            return acc;
-        }
-        acc.push({ start: bufferedStart, end: bufferedEnd });
-        return acc;
-    }, []);
-}

package/dist/commonjs/core/stream/representation/representation_stream.js

@@ -164,7 +164,7 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
         }
     });
     downloadingQueue.addEventListener("fullyLoadedSegment", function (segment) {
-        segmentBuffer.endOfSegment((0, object_assign_1.default)({ segment: segment }, content), globalCanceller.signal)
+        segmentBuffer.signalSegmentComplete((0, object_assign_1.default)({ segment: segment }, content))
             .catch(onFatalBufferError);
     });
     downloadingQueue.start();
@@ -276,7 +276,7 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
         if (status.isBufferFull) {
             var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
             if (gcedPosition > 0) {
-                segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
+                segmentBuffer.removeBuffer(0, gcedPosition)
                     .catch(onFatalBufferError);
             }
         }
@@ -336,7 +336,7 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
                 var initSegmentUniqueId = representation.uniqueId;
                 initSegmentState.uniqueId = initSegmentUniqueId;
                 segmentBuffer.declareInitSegment(initSegmentUniqueId, evt.initializationData);
-                (0, push_init_segment_1.default)({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
+                (0, push_init_segment_1.default)({ playbackObserver: playbackObserver, bufferGoal: bufferGoal, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
                     segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
                     .then(function (result) {
                     if (result !== null) {
@@ -368,7 +368,7 @@ function RepresentationStream(_a, callbacks, parentCancelSignal) {
                 }
             }
             var initSegmentUniqueId = initSegmentState.uniqueId;
-            (0, push_media_segment_1.default)({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
+            (0, push_media_segment_1.default)({ playbackObserver: playbackObserver, bufferGoal: bufferGoal, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
                 segment: evt.segment, segmentBuffer: segmentBuffer }, globalCanceller.signal)
                 .then(function (result) {
                 if (result !== null) {

package/dist/commonjs/core/stream/representation/types.d.ts

@@ -1,6 +1,7 @@
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
 import { IEMSG } from "../../../parsers/containers/isobmff";
 import { IAudioRepresentationsSwitchingMode, IPlayerError, IVideoRepresentationsSwitchingMode } from "../../../public_types";
+import { IRange } from "../../../utils/ranges";
 import { IReadOnlySharedReference } from "../../../utils/reference";
 import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { IContentProtection } from "../../decrypt";
@@ -121,8 +122,8 @@ export interface IStreamEventAddedSegmentPayload {
     };
     /** The concerned Segment. */
     segment: ISegment;
-    /** TimeRanges of the concerned SegmentBuffer after the segment was pushed. */
-    buffered: TimeRanges;
+    /** Ranges of the concerned SegmentBuffer after the segment was pushed. */
+    buffered: IRange[];
 }
 /** Structure describing an "inband" event, as found in a media segment. */
 export interface IInbandEvent {
@@ -164,6 +165,32 @@ export interface IRepresentationStreamPlaybackObservation {
      * Playback Observation.
      */
     position: IObservationPosition;
+    /**
+     * Information on whether the media element was paused at the time of the
+     * Observation.
+     */
+    paused: IPausedPlaybackObservation;
+    /** Last "playback rate" asked by the user. */
+    speed: number;
+}
+/** Pause-related information linked to an emitted Playback observation. */
+export interface IPausedPlaybackObservation {
+    /**
+     * Known paused state at the time the Observation was emitted.
+     *
+     * `true` indicating that the HTMLMediaElement was in a paused state.
+     *
+     * Note that it might have changed since. If you want truly precize
+     * information, you should recuperate it from the HTMLMediaElement directly
+     * through another mean.
+     */
+    last: boolean;
+    /**
+     * Actually wanted paused state not yet reached.
+     * This might for example be set to `false` when the content is currently
+     * loading (and thus paused) but with autoPlay enabled.
+     */
+    pending: boolean | undefined;
 }
 /** Position-related information linked to an emitted Playback observation. */
 export interface IPositionPlaybackObservation {
@@ -267,7 +294,7 @@ export interface IRepresentationStreamOptions {
 /** Object indicating a choice of allowed Representations made by the user. */
 export interface IRepresentationsChoice {
     /** `Representation`s wanted by the user. */
-    representations: Representation[];
+    representationIds: string[];
     /**
      * How the Streams should react if another, not currently authorized,
      * Representation was previously playing.

package/dist/commonjs/core/stream/representation/utils/append_segment_to_buffer.d.ts

@@ -13,20 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IRange } from "../../../../utils/ranges";
+import { IReadOnlySharedReference } from "../../../../utils/reference";
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import { IInsertedChunkInfos, IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
 import { IRepresentationStreamPlaybackObservation } from "../types";
 /**
  * Append a segment to the given segmentBuffer.
- * If it leads to a QuotaExceededError, try to run our custom range
+ * If it leads to an Error due to a full buffer, try to run our custom range
  * _garbage collector_ then retry.
  * @param {Object} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
+ * @param {number} bufferGoal
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
 export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T> & {
     inventoryInfos: IInsertedChunkInfos;
-}, cancellationSignal: CancellationSignal): Promise<void>;
+}, bufferGoal: IReadOnlySharedReference<number>, cancellationSignal: CancellationSignal): Promise<IRange[]>;

package/dist/commonjs/core/stream/representation/utils/append_segment_to_buffer.js

@@ -55,60 +55,77 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * This file allows any Stream to push data to a SegmentBuffer.
  */
 var errors_1 = require("../../../../errors");
+var log_1 = require("../../../../log");
+var manifest_1 = require("../../../../manifest");
+var sleep_1 = require("../../../../utils/sleep");
 var task_canceller_1 = require("../../../../utils/task_canceller");
-var force_garbage_collection_1 = require("./force_garbage_collection");
 /**
  * Append a segment to the given segmentBuffer.
- * If it leads to a QuotaExceededError, try to run our custom range
+ * If it leads to an Error due to a full buffer, try to run our custom range
  * _garbage collector_ then retry.
  * @param {Object} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
+ * @param {number} bufferGoal
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
-function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, cancellationSignal) {
+function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, bufferGoal, cancellationSignal) {
     return __awaiter(this, void 0, void 0, function () {
-        var appendError_1, reason, position, currentPos, err2_1, reason;
+        var appendError_1, reason, position, currentPos, start, end, err2_1, reason;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    _a.trys.push([0, 2, , 8]);
-                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
-                case 1:
-                    _a.sent();
-                    return [3 /*break*/, 8];
+                    _a.trys.push([0, 2, , 10]);
+                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos)];
+                case 1: return [2 /*return*/, _a.sent()];
                 case 2:
                     appendError_1 = _a.sent();
                     if (cancellationSignal.isCancelled() && appendError_1 instanceof task_canceller_1.CancellationError) {
                         throw appendError_1;
                     }
-                    else if (!(appendError_1 instanceof Error) ||
-                        appendError_1.name !== "QuotaExceededError") {
+                    else if (!(appendError_1 instanceof errors_1.SourceBufferError) || !appendError_1.isBufferFull) {
                         reason = appendError_1 instanceof Error ?
                             appendError_1.toString() :
                             "An unknown error happened when pushing content";
-                        throw new errors_1.MediaError("BUFFER_APPEND_ERROR", reason, { adaptations: [dataInfos.inventoryInfos.adaptation] });
+                        throw new errors_1.MediaError("BUFFER_APPEND_ERROR", reason, {
+                            tracks: [(0, manifest_1.toTaggedTrack)(dataInfos.inventoryInfos.adaptation)],
+                        });
                     }
                     position = playbackObserver.getReference().getValue().position;
                     currentPos = position.getWanted();
                     _a.label = 3;
                 case 3:
-                    _a.trys.push([3, 6, , 7]);
-                    return [4 /*yield*/, (0, force_garbage_collection_1.default)(currentPos, segmentBuffer, cancellationSignal)];
+                    _a.trys.push([3, 8, , 9]);
+                    log_1.default.warn("Stream: Running garbage collector");
+                    start = Math.max(currentPos - 5, 0);
+                    end = currentPos + bufferGoal.getValue() + 12;
+                    return [4 /*yield*/, segmentBuffer.removeBuffer(0, start)];
                 case 4:
                     _a.sent();
-                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
+                    return [4 /*yield*/, segmentBuffer.removeBuffer(end, Number.MAX_VALUE)];
                 case 5:
                     _a.sent();
-                    return [3 /*break*/, 7];
+                    return [4 /*yield*/, (0, sleep_1.default)(200)];
                 case 6:
+                    _a.sent();
+                    if (cancellationSignal.cancellationError !== null) {
+                        throw cancellationSignal.cancellationError;
+                    }
+                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos)];
+                case 7: return [2 /*return*/, _a.sent()];
+                case 8:
                     err2_1 = _a.sent();
+                    if (err2_1 instanceof task_canceller_1.CancellationError) {
+                        throw err2_1;
+                    }
                     reason = err2_1 instanceof Error ? err2_1.toString() :
                         "Could not clean the buffer";
-                    throw new errors_1.MediaError("BUFFER_FULL_ERROR", reason, { adaptations: [dataInfos.inventoryInfos.adaptation] });
-                case 7: return [3 /*break*/, 8];
-                case 8: return [2 /*return*/];
+                    throw new errors_1.MediaError("BUFFER_FULL_ERROR", reason, {
+                        tracks: [(0, manifest_1.toTaggedTrack)(dataInfos.inventoryInfos.adaptation)],
+                    });
+                case 9: return [3 /*break*/, 10];
+                case 10: return [2 /*return*/];
             }
         });
     });

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.d.ts

@@ -16,7 +16,7 @@
 import Manifest, { Adaptation, Period, Representation } from "../../../../manifest";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import { SegmentBuffer } from "../../../segment_buffers";
-import { IBufferDiscontinuity, IQueuedSegment } from "../types";
+import { IBufferDiscontinuity, IRepresentationStreamPlaybackObservation, IQueuedSegment } from "../types";
 /** Analysis of the current buffer's status. */
 export interface IBufferStatus {
     /**
@@ -69,4 +69,4 @@ export default function getBufferStatus(content: {
     manifest: Manifest;
     period: Period;
     representation: Representation;
-}, initialWantedTime: number, playbackObserver: IReadOnlyPlaybackObserver<unknown>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentBuffer: SegmentBuffer): IBufferStatus;
+}, initialWantedTime: number, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentBuffer: SegmentBuffer): IBufferStatus;

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.js

@@ -63,30 +63,39 @@ var get_segment_priority_1 = require("./get_segment_priority");
  * @returns {Object}
  */
 function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
-    segmentBuffer.synchronizeInventory();
+    var _a, _b, _c;
     var representation = content.representation;
-    var askedStart = playbackObserver.getIsPaused() ||
-        playbackObserver.getPlaybackRate() <= 0 ?
-        initialWantedTime - 0.1 :
-        initialWantedTime;
+    var isPaused = (_b = (_a = playbackObserver.getIsPaused()) !== null && _a !== void 0 ? _a : playbackObserver.getReference().getValue().paused.pending) !== null && _b !== void 0 ? _b : playbackObserver.getReference().getValue().paused.last;
+    var playbackRate = (_c = playbackObserver.getPlaybackRate()) !== null && _c !== void 0 ? _c : playbackObserver.getReference().getValue().speed;
+    var askedStart = initialWantedTime;
+    if (isPaused === undefined ||
+        playbackRate === undefined ||
+        (isPaused || playbackRate <= 0)) {
+        askedStart -= 0.1;
+    }
     var neededRange = getRangeOfNeededSegments(content, askedStart, bufferGoal);
     var shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start, neededRange.end);
     /**
-     * Every segment awaiting an "EndOfSegment" operation, which indicates that a
-     * completely-loaded segment is still being pushed to the SegmentBuffer.
+     * Every segment awaiting an "SignalSegmentComplete" operation, which
+     * indicates that a completely-loaded segment is still being pushed to the
+     * SegmentBuffer.
      */
     var segmentsBeingPushed = segmentBuffer.getPendingOperations()
         .filter(function (operation) {
-        return operation.type === segment_buffers_1.SegmentBufferOperation.EndOfSegment;
+        return operation.type === segment_buffers_1.SegmentBufferOperation.SignalSegmentComplete;
     }).map(function (operation) { return operation.value; });
     /** Data on every segments buffered around `neededRange`. */
     var bufferedSegments = getPlayableBufferedSegments({ start: Math.max(neededRange.start - 0.5, 0),
-        end: neededRange.end + 0.5 }, segmentBuffer.getInventory());
+        end: neededRange.end + 0.5 }, segmentBuffer.getLastKnownInventory());
     var currentPlaybackTime = playbackObserver.getCurrentTime();
+    if (currentPlaybackTime === undefined) {
+        // We're in a WebWorker, just consider the last known position
+        currentPlaybackTime = playbackObserver.getReference().getValue().position.getWanted();
+    }
     /** Callback allowing to retrieve a segment's history in the buffer. */
     var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
     /** List of segments we will need to download. */
-    var _a = (0, get_needed_segments_1.default)({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _a.segmentsToLoad, segmentsOnHold = _a.segmentsOnHold, isBufferFull = _a.isBufferFull;
+    var _d = (0, get_needed_segments_1.default)({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _d.segmentsToLoad, segmentsOnHold = _d.segmentsOnHold, isBufferFull = _d.isBufferFull;
     var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
         priority: (0, get_segment_priority_1.default)(segment.time, askedStart),
         segment: segment,
@@ -191,7 +200,8 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
  */
 function isPeriodTheCurrentAndLastOne(manifest, period, time) {
     var _a;
-    return period.containsTime(time) &&
+    var nextPeriod = manifest.getPeriodAfter(period);
+    return period.containsTime(time, nextPeriod) &&
         manifest.isLastPeriodKnown &&
         period.id === ((_a = manifest.periods[manifest.periods.length - 1]) === null || _a === void 0 ? void 0 : _a.id);
 }
@@ -214,7 +224,7 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
         var representation = eltInventory.infos.representation;
         if (eltInventory.status === 1 /* ChunkStatus.Complete */ &&
             representation.decipherable !== false &&
-            representation.isSupported) {
+            representation.isSupported !== false) {
             var inventorySegment = eltInventory.infos.segment;
             var eltInventoryStart = inventorySegment.time /
                 inventorySegment.timescale;

package/dist/commonjs/core/stream/representation/utils/get_needed_segments.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
-import { IBufferedChunk, IEndOfSegmentInfos } from "../../../segment_buffers";
+import { IBufferedChunk, ICompleteSegmentInfo } from "../../../segment_buffers";
 import { IBufferedHistoryEntry, IChunkContext } from "../../../segment_buffers/inventory";
 interface IContentContext {
     adaptation: Adaptation;
@@ -47,7 +47,7 @@ export interface IGetNeededSegmentsArguments {
         end: number;
     };
     /** The list of segments that are already in the process of being pushed. */
-    segmentsBeingPushed: IEndOfSegmentInfos[];
+    segmentsBeingPushed: ICompleteSegmentInfo[];
     /**
      * Information on the segments already in the buffer, in chronological order.
      *

package/dist/commonjs/core/stream/representation/utils/get_needed_segments.js

@@ -283,9 +283,7 @@ function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastS
 function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
     var MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config_1.default.getCurrent().MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT;
     if (currentSeg.bufferedStart === undefined) {
-        log_1.default.warn("Stream: Start of a segment unknown. " +
-            "Assuming it is garbage collected by default.", currentSeg.start);
-        return true;
+        return false;
     }
     if (prevSeg !== null && prevSeg.bufferedEnd !== undefined &&
         (currentSeg.bufferedStart - prevSeg.bufferedEnd < 0.1)) {
@@ -314,9 +312,7 @@ function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
 function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     var MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config_1.default.getCurrent().MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT;
     if (currentSeg.bufferedEnd === undefined) {
-        log_1.default.warn("Stream: End of a segment unknown. " +
-            "Assuming it is garbage collected by default.", currentSeg.end);
-        return true;
+        return false;
     }
     if (nextSeg !== null && nextSeg.bufferedStart !== undefined &&
         (nextSeg.bufferedStart - currentSeg.bufferedEnd < 0.1)) {

package/dist/commonjs/core/stream/representation/utils/push_init_segment.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
+import { IReadOnlySharedReference } from "../../../../utils/reference";
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import { SegmentBuffer } from "../../../segment_buffers";
@@ -24,7 +25,7 @@ import { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPaylo
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function pushInitSegment<T>({ playbackObserver, content, initSegmentUniqueId, segment, segmentBuffer, }: {
+export default function pushInitSegment<T>({ playbackObserver, content, initSegmentUniqueId, segment, segmentBuffer, bufferGoal, }: {
     playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
     content: {
         adaptation: Adaptation;
@@ -36,4 +37,5 @@ export default function pushInitSegment<T>({ playbackObserver, content, initSegm
     segmentData: T;
     segment: ISegment;
     segmentBuffer: SegmentBuffer;
+    bufferGoal: IReadOnlySharedReference<number>;
 }, cancelSignal: CancellationSignal): Promise<IStreamEventAddedSegmentPayload | null>;

package/dist/commonjs/core/stream/representation/utils/push_init_segment.js

@@ -60,7 +60,7 @@ var append_segment_to_buffer_1 = require("./append_segment_to_buffer");
  * @returns {Promise}
  */
 function pushInitSegment(_a, cancelSignal) {
-    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentUniqueId = _a.initSegmentUniqueId, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
+    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentUniqueId = _a.initSegmentUniqueId, segment = _a.segment, segmentBuffer = _a.segmentBuffer, bufferGoal = _a.bufferGoal;
     return __awaiter(this, void 0, void 0, function () {
         var codec, data, inventoryInfos, buffered;
         return __generator(this, function (_b) {
@@ -76,10 +76,9 @@ function pushInitSegment(_a, cancelSignal) {
                     inventoryInfos = (0, object_assign_1.default)({ segment: segment, chunkSize: undefined,
                         start: 0,
                         end: 0 }, content);
-                    return [4 /*yield*/, (0, append_segment_to_buffer_1.default)(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }, cancelSignal)];
+                    return [4 /*yield*/, (0, append_segment_to_buffer_1.default)(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }, bufferGoal, cancelSignal)];
                 case 1:
-                    _b.sent();
-                    buffered = segmentBuffer.getBufferedRanges();
+                    buffered = _b.sent();
                     return [2 /*return*/, { content: content, segment: segment, buffered: buffered }];
             }
         });

package/dist/commonjs/core/stream/representation/utils/push_media_segment.d.ts

@@ -15,6 +15,7 @@
  */
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
 import { ISegmentParserParsedMediaChunk } from "../../../../transports";
+import { IReadOnlySharedReference } from "../../../../utils/reference";
 import { CancellationSignal } from "../../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import { SegmentBuffer } from "../../../segment_buffers";
@@ -25,7 +26,7 @@ import { IRepresentationStreamPlaybackObservation, IStreamEventAddedSegmentPaylo
  * @param {Object} cancelSignal
  * @returns {Promise}
  */
-export default function pushMediaSegment<T>({ playbackObserver, content, initSegmentUniqueId, parsedSegment, segment, segmentBuffer }: {
+export default function pushMediaSegment<T>({ playbackObserver, bufferGoal, content, initSegmentUniqueId, parsedSegment, segment, segmentBuffer }: {
     playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
     content: {
         adaptation: Adaptation;
@@ -33,6 +34,7 @@ export default function pushMediaSegment<T>({ playbackObserver, content, initSeg
         period: Period;
         representation: Representation;
     };
+    bufferGoal: IReadOnlySharedReference<number>;
     initSegmentUniqueId: string | null;
     parsedSegment: ISegmentParserParsedMediaChunk<T>;
     segment: ISegment;

package/dist/commonjs/core/stream/representation/utils/push_media_segment.js

@@ -62,7 +62,7 @@ var append_segment_to_buffer_1 = require("./append_segment_to_buffer");
  */
 function pushMediaSegment(_a, cancelSignal) {
     var _b, _c;
-    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentUniqueId = _a.initSegmentUniqueId, parsedSegment = _a.parsedSegment, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
+    var playbackObserver = _a.playbackObserver, bufferGoal = _a.bufferGoal, content = _a.content, initSegmentUniqueId = _a.initSegmentUniqueId, parsedSegment = _a.parsedSegment, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
     return __awaiter(this, void 0, void 0, function () {
         var chunkData, chunkInfos, chunkOffset, chunkSize, appendWindow, codec, APPEND_WINDOW_SECURITIES, safeAppendWindow, data, estimatedStart, estimatedDuration, estimatedEnd, inventoryInfos, buffered;
         return __generator(this, function (_d) {
@@ -99,10 +99,9 @@ function pushMediaSegment(_a, cancelSignal) {
                     }
                     inventoryInfos = (0, object_assign_1.default)({ segment: segment, chunkSize: chunkSize, start: estimatedStart,
                         end: estimatedEnd }, content);
-                    return [4 /*yield*/, (0, append_segment_to_buffer_1.default)(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }, cancelSignal)];
+                    return [4 /*yield*/, (0, append_segment_to_buffer_1.default)(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }, bufferGoal, cancelSignal)];
                 case 1:
-                    _d.sent();
-                    buffered = segmentBuffer.getBufferedRanges();
+                    buffered = _d.sent();
                     return [2 /*return*/, { content: content, segment: segment, buffered: buffered }];
             }
         });