rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import Manifest, { Adaptation, Period, Representation } from "../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
 import { IBufferDiscontinuity, IQueuedSegment } from "../types";
 /** Analysis of the current buffer's status. */
@@ -50,7 +51,7 @@ export interface IBufferStatus {
  * be filled by any segment, even in the future.
  *
  * @param {Object} content
- * @param {Object} tick
+ * @param {Object} playbackInfo
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
  * @param {Object} segmentBuffer
@@ -61,9 +62,4 @@ export default function getBufferStatus(content: {
     manifest: Manifest;
     period: Period;
     representation: Representation;
-}, tick: {
-    position: number;
-    wantedTimeOffset: number;
-    liveGap?: number;
-    getCurrentTime(): number;
-}, fastSwitchThreshold: number | undefined, bufferGoal: number, segmentBuffer: SegmentBuffer<unknown>): IBufferStatus;
+}, wantedStartPosition: number, playbackObserver: IReadOnlyPlaybackObserver<unknown>, fastSwitchThreshold: number | undefined, bufferGoal: number, segmentBuffer: SegmentBuffer): IBufferStatus;

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.js

@@ -27,17 +27,16 @@ var MINIMUM_SEGMENT_SIZE = config.MINIMUM_SEGMENT_SIZE;
  * be filled by any segment, even in the future.
  *
  * @param {Object} content
- * @param {Object} tick
+ * @param {Object} playbackInfo
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
  * @param {Object} segmentBuffer
  * @returns {Object}
  */
-export default function getBufferStatus(content, tick, fastSwitchThreshold, bufferGoal, segmentBuffer) {
+export default function getBufferStatus(content, wantedStartPosition, playbackObserver, fastSwitchThreshold, bufferGoal, segmentBuffer) {
     var _a;
     var period = content.period, representation = content.representation;
     segmentBuffer.synchronizeInventory();
-    var wantedStartPosition = tick.position + tick.wantedTimeOffset;
     var wantedEndPosition = wantedStartPosition + bufferGoal;
     var neededRange = { start: Math.max(wantedStartPosition, period.start),
         end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity) };
@@ -53,15 +52,12 @@ export default function getBufferStatus(content, tick, fastSwitchThreshold, buff
     /** 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());
+    var currentPlaybackTime = playbackObserver.getCurrentTime();
+    /** 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 neededSegments = getNeededSegments({ content: content,
-        currentPlaybackTime: tick.getCurrentTime(),
-        fastSwitchThreshold: fastSwitchThreshold,
-        neededRange: neededRange,
-        bufferedSegments: bufferedSegments,
-        segmentsBeingPushed: segmentsBeingPushed })
-        .map(function (segment) { return ({ priority: getSegmentPriority(segment.time, tick),
-        segment: segment }); });
+    var neededSegments = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed })
+        .map(function (segment) { return ({ priority: getSegmentPriority(segment.time, wantedStartPosition), segment: segment }); });
     /**
      * `true` if the current `RepresentationStream` has loaded all the
      * needed segments for this Representation until the end of the Period.
@@ -121,10 +117,7 @@ export default function getBufferStatus(content, tick, fastSwitchThreshold, buff
         }
         imminentDiscontinuity = checkForDiscontinuity(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
     }
-    return { imminentDiscontinuity: imminentDiscontinuity,
-        hasFinishedLoading: hasFinishedLoading,
-        neededSegments: neededSegments,
-        shouldRefreshManifest: shouldRefreshManifest };
+    return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: neededSegments, shouldRefreshManifest: shouldRefreshManifest };
 }
 /**
  * From the given SegmentInventory, filters the "playable" (in a supported codec
@@ -148,10 +141,9 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
             var inventorySegment = eltInventory.infos.segment;
             var eltInventoryStart = inventorySegment.time /
                 inventorySegment.timescale;
-            var eltInventoryEnd = inventorySegment.duration == null ?
+            var eltInventoryEnd = !inventorySegment.complete ?
                 eltInventory.end :
-                eltInventoryStart + inventorySegment.duration /
-                    inventorySegment.timescale;
+                eltInventoryStart + inventorySegment.duration / inventorySegment.timescale;
             if ((eltInventoryEnd > minEnd && eltInventoryStart < maxStart) ||
                 (eltInventory.end > minEnd && eltInventory.start < maxStart)) {
                 overlappingChunks.unshift(eltInventory);

package/dist/_esm5.processed/core/stream/representation/get_needed_segments.d.ts

@@ -15,6 +15,7 @@
  */
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
 import { IBufferedChunk } from "../../segment_buffers";
+import { IBufferedHistoryEntry, IChunkContext } from "../../segment_buffers/inventory";
 /** Arguments for `getNeededSegments`. */
 export interface IGetNeededSegmentsArguments {
     /** The content we want to load segments for */
@@ -61,6 +62,7 @@ export interface IGetNeededSegmentsArguments {
      * re-requested.
      */
     bufferedSegments: IBufferedChunk[];
+    getBufferedHistory: (context: IChunkContext) => IBufferedHistoryEntry[];
 }
 /**
  * Return the list of segments that can currently be downloaded to fill holes
@@ -72,4 +74,4 @@ export interface IGetNeededSegmentsArguments {
  * @param {Object} args
  * @returns {Array.<Object>}
  */
-export default function getNeededSegments({ content, currentPlaybackTime, fastSwitchThreshold, neededRange, segmentsBeingPushed, bufferedSegments, }: IGetNeededSegmentsArguments): ISegment[];
+export default function getNeededSegments({ bufferedSegments, content, currentPlaybackTime, fastSwitchThreshold, getBufferedHistory, neededRange, segmentsBeingPushed, }: IGetNeededSegmentsArguments): ISegment[];

package/dist/_esm5.processed/core/stream/representation/get_needed_segments.js

@@ -35,7 +35,7 @@ var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
  * @returns {Array.<Object>}
  */
 export default function getNeededSegments(_a) {
-    var content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed, bufferedSegments = _a.bufferedSegments;
+    var bufferedSegments = _a.bufferedSegments, content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, getBufferedHistory = _a.getBufferedHistory, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed;
     var representation = content.representation;
     var availableSegmentsForRange = representation.index
         .getSegments(neededRange.start, neededRange.end - neededRange.start);
@@ -49,8 +49,22 @@ export default function getNeededSegments(_a) {
             consideredSegments[i - 1];
         var nextSeg = i >= consideredSegments.length - 1 ? null :
             consideredSegments[i + 1];
-        return !isStartGarbageCollected(currentSeg, prevSeg, neededRange.start) &&
-            !isEndGarbageCollected(currentSeg, nextSeg, neededRange.end);
+        var lazySegmentHistory = null;
+        if (doesStartSeemGarbageCollected(currentSeg, prevSeg, neededRange.start)) {
+            lazySegmentHistory = getBufferedHistory(currentSeg.infos);
+            if (shouldReloadSegmentGCedAtTheStart(lazySegmentHistory, currentSeg.bufferedStart)) {
+                return false;
+            }
+            log.debug("Stream: skipping segment gc-ed at the start", currentSeg);
+        }
+        if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.start)) {
+            lazySegmentHistory = lazySegmentHistory !== null && lazySegmentHistory !== void 0 ? lazySegmentHistory : getBufferedHistory(currentSeg.infos);
+            if (shouldReloadSegmentGCedAtTheEnd(lazySegmentHistory, currentSeg.bufferedEnd)) {
+                return false;
+            }
+            log.debug("Stream: skipping segment gc-ed at the end", currentSeg);
+        }
+        return true;
     });
     var segmentsToDownload = availableSegmentsForRange.filter(function (segment) {
         var contentObject = objectAssign({ segment: segment }, content);
@@ -66,7 +80,7 @@ export default function getNeededSegments(_a) {
         if (segment.isInit) {
             return true; // never skip initialization segments
         }
-        if (duration < MINIMUM_SEGMENT_SIZE) {
+        if (segment.complete && duration < MINIMUM_SEGMENT_SIZE) {
             return false; // too small, don't download
         }
         // Check if the same segment from another Representation is not already
@@ -192,7 +206,7 @@ function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastS
  * If `currentSeg` has only been garbage collected for some data which is before
  * that time, we will return `false`.
  */
-function isStartGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
+function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
     if (currentSeg.bufferedStart === undefined) {
         log.warn("Stream: Start of a segment unknown. " +
             "Assuming it is garbage collected by default.", currentSeg);
@@ -222,7 +236,7 @@ function isStartGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
  * If `currentSeg` has only been garbage collected for some data which is after
  * that time, we will return `false`.
  */
-function isEndGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
+function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     if (currentSeg.bufferedEnd === undefined) {
         log.warn("Stream: End of a segment unknown. " +
             "Assuming it is garbage collected by default.", currentSeg);
@@ -239,3 +253,91 @@ function isEndGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     }
     return false;
 }
+/**
+ * Returns `true` if a segment that has been garbage-collected at the start
+ * might profit from being re-loaded.
+ *
+ * Returns `false` if we have a high chance of staying in the same situation
+ * after re-loading the segment.
+ *
+ * This function takes in argument the entries of a SegmentBuffer's history
+ * related to the corresponding segment and check if the segment appeared
+ * garbage-collected at the start directly after the last few times it was
+ * pushed, indicating that the issue might be sourced at a browser issue instead
+ * of classical garbage collection.
+ *
+ * @param {Array.<Object>} segmentEntries
+ * @param {number|undefined} currentBufferedStart
+ * @returns {boolean}
+ */
+function shouldReloadSegmentGCedAtTheStart(segmentEntries, currentBufferedStart) {
+    if (segmentEntries.length < 2) {
+        return true;
+    }
+    var lastEntry = segmentEntries[segmentEntries.length - 1];
+    var lastBufferedStart = lastEntry.bufferedStart;
+    // If the current segment's buffered start is much higher than what it
+    // initially was when we pushed it, the segment has a very high chance of
+    // having been truly garbage-collected.
+    if (currentBufferedStart !== undefined &&
+        currentBufferedStart - lastBufferedStart > 0.05) {
+        return true;
+    }
+    var prevEntry = segmentEntries[segmentEntries.length - 2];
+    var prevBufferedStart = prevEntry.bufferedStart;
+    // Compare `bufferedStart` from the last time this segment was pushed
+    // (`entry.bufferedStart`) to the previous time it was pushed
+    // (`prevSegEntry.bufferedStart`).
+    //
+    // If in both cases, we notice that their initial `bufferedStart` are close,
+    // it means that in recent history the same segment has been accused to be
+    // garbage collected two times at roughly the same positions just after being
+    // pushed.
+    // This is very unlikely and might be linked to either a content or browser
+    // issue. In that case, don't try to reload.
+    return Math.abs(prevBufferedStart - lastBufferedStart) > 0.01;
+}
+/**
+ * Returns `true` if a segment that has been garbage-collected at the end
+ * might profit from being re-loaded.
+ *
+ * Returns `false` if we have a high chance of staying in the same situation
+ * after re-loading the segment.
+ *
+ * This function takes in argument the entries of a SegmentBuffer's history
+ * related to the corresponding segment and check if the segment appeared
+ * garbage-collected at the end directly after the last few times it was
+ * pushed, indicating that the issue might be sourced at a browser issue instead
+ * of classical garbage collection.
+ *
+ * @param {Array.<Object>} segmentEntries
+ * @param {number|undefined} currentBufferedStart
+ * @returns {boolean}
+ */
+function shouldReloadSegmentGCedAtTheEnd(segmentEntries, currentBufferedEnd) {
+    if (segmentEntries.length < 2) {
+        return true;
+    }
+    var lastEntry = segmentEntries[segmentEntries.length - 1];
+    var lastBufferedEnd = lastEntry.bufferedEnd;
+    // If the current segment's buffered end is much lower than what it
+    // initially was when we pushed it, the segment has a very high chance of
+    // having been truly garbage-collected.
+    if (currentBufferedEnd !== undefined &&
+        lastBufferedEnd - currentBufferedEnd > 0.05) {
+        return true;
+    }
+    var prevEntry = segmentEntries[segmentEntries.length - 2];
+    var prevBufferedEnd = prevEntry.bufferedEnd;
+    // Compare `bufferedEnd` from the last time this segment was pushed
+    // (`entry.bufferedEnd`) to the previous time it was pushed
+    // (`prevSegEntry.bufferedEnd`).
+    //
+    // If in both cases, we notice that their initial `bufferedEnd` are close,
+    // it means that in recent history the same segment has been accused to be
+    // garbage collected two times at roughly the same positions just after being
+    // pushed.
+    // This is very unlikely and might be linked to either a content or browser
+    // issue. In that case, don't try to reload.
+    return Math.abs(prevBufferedEnd - lastBufferedEnd) > 0.01;
+}

package/dist/_esm5.processed/core/stream/representation/get_segment_priority.d.ts

@@ -14,18 +14,15 @@
  * limitations under the License.
  */
 /**
- * Calculate the priority number for a given time, in function of the distance
- * with the current time.
+ * Calculate the priority number for a given segment start time, in function of
+ * the distance with the wanted starting timestamp.
  *
  * The lower is this number, the higher should be the priority of the request.
  *
- * Note that a `timeWanted` given behind the current time will always have the
+ * Note that a `segmentTime` given behind the current time will always have the
  * highest priority.
- * @param {number} timeWanted
- * @param {Object} clockTick
+ * @param {number} segmentTime
+ * @param {Object} wantedStartTimestamp
  * @returns {number}
  */
-export default function getSegmentPriority(timeWanted: number, clockTick: {
-    position: number;
-    wantedTimeOffset: number;
-}): number;
+export default function getSegmentPriority(segmentTime: number, wantedStartTimestamp: number): number;

package/dist/_esm5.processed/core/stream/representation/get_segment_priority.js

@@ -16,20 +16,19 @@
 import config from "../../../config";
 var SEGMENT_PRIORITIES_STEPS = config.SEGMENT_PRIORITIES_STEPS;
 /**
- * Calculate the priority number for a given time, in function of the distance
- * with the current time.
+ * Calculate the priority number for a given segment start time, in function of
+ * the distance with the wanted starting timestamp.
  *
  * The lower is this number, the higher should be the priority of the request.
  *
- * Note that a `timeWanted` given behind the current time will always have the
+ * Note that a `segmentTime` given behind the current time will always have the
  * highest priority.
- * @param {number} timeWanted
- * @param {Object} clockTick
+ * @param {number} segmentTime
+ * @param {Object} wantedStartTimestamp
  * @returns {number}
  */
-export default function getSegmentPriority(timeWanted, clockTick) {
-    var currentTime = clockTick.position + clockTick.wantedTimeOffset;
-    var distance = timeWanted - currentTime;
+export default function getSegmentPriority(segmentTime, wantedStartTimestamp) {
+    var distance = segmentTime - wantedStartTimestamp;
     for (var priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
         if (distance < SEGMENT_PRIORITIES_STEPS[priority]) {
             return priority;

package/dist/_esm5.processed/core/stream/representation/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import RepresentationStream, { IRepresentationStreamArguments, IRepresentationStreamClockTick, ITerminationOrder } from "./representation_stream";
+import RepresentationStream, { IRepresentationStreamArguments, IRepresentationStreamPlaybackObservation, ITerminationOrder } from "./representation_stream";
 export default RepresentationStream;
-export { IRepresentationStreamArguments, IRepresentationStreamClockTick, ITerminationOrder, };
+export { IRepresentationStreamArguments, IRepresentationStreamPlaybackObservation, ITerminationOrder, };

package/dist/_esm5.processed/core/stream/representation/push_init_segment.d.ts

@@ -15,6 +15,7 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
 import { IStreamEventAddedSegment } from "../types";
 /**
@@ -25,9 +26,10 @@ import { IStreamEventAddedSegment } from "../types";
  * @param {Object} args
  * @returns {Observable}
  */
-export default function pushInitSegment<T>({ clock$, content, segment, segmentData, segmentBuffer }: {
-    clock$: Observable<{
+export default function pushInitSegment<T>({ playbackObserver, content, segment, segmentData, segmentBuffer }: {
+    playbackObserver: IReadOnlyPlaybackObserver<{
         position: number;
+        wantedTimeOffset: number;
     }>;
     content: {
         adaptation: Adaptation;
@@ -37,5 +39,5 @@ export default function pushInitSegment<T>({ clock$, content, segment, segmentDa
     };
     segmentData: T | null;
     segment: ISegment;
-    segmentBuffer: SegmentBuffer<T>;
+    segmentBuffer: SegmentBuffer;
 }): Observable<IStreamEventAddedSegment<T>>;

package/dist/_esm5.processed/core/stream/representation/push_init_segment.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, EMPTY, } from "rxjs";
-import { map } from "rxjs/operators";
+import { defer as observableDefer, EMPTY, map, } from "rxjs";
 import EVENTS from "../events_generators";
 import appendSegmentToBuffer from "./append_segment_to_buffer";
 /**
@@ -26,7 +25,7 @@ import appendSegmentToBuffer from "./append_segment_to_buffer";
  * @returns {Observable}
  */
 export default function pushInitSegment(_a) {
-    var clock$ = _a.clock$, content = _a.content, segment = _a.segment, segmentData = _a.segmentData, segmentBuffer = _a.segmentBuffer;
+    var playbackObserver = _a.playbackObserver, content = _a.content, segment = _a.segment, segmentData = _a.segmentData, segmentBuffer = _a.segmentBuffer;
     return observableDefer(function () {
         if (segmentData === null) {
             return EMPTY;
@@ -35,11 +34,8 @@ export default function pushInitSegment(_a) {
         var data = { initSegment: segmentData,
             chunk: null,
             timestampOffset: 0,
-            appendWindow: [undefined, undefined],
-            codec: codec };
-        return appendSegmentToBuffer(clock$, segmentBuffer, { data: data,
-            inventoryInfos: null })
-            .pipe(map(function () {
+            appendWindow: [undefined, undefined], codec: codec };
+        return appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: null }).pipe(map(function () {
             var buffered = segmentBuffer.getBufferedRanges();
             return EVENTS.addedSegment(content, segment, buffered, segmentData);
         }));

package/dist/_esm5.processed/core/stream/representation/push_media_segment.d.ts

@@ -15,7 +15,8 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { ISegmentParserParsedSegment } from "../../../transports";
+import { ISegmentParserParsedMediaChunk } from "../../../transports";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentBuffer } from "../../segment_buffers";
 import { IStreamEventAddedSegment } from "../types";
 /**
@@ -26,9 +27,10 @@ import { IStreamEventAddedSegment } from "../types";
  * @param {Object} args
  * @returns {Observable}
  */
-export default function pushMediaSegment<T>({ clock$, content, initSegmentData, parsedSegment, segment, segmentBuffer }: {
-    clock$: Observable<{
+export default function pushMediaSegment<T>({ playbackObserver, content, initSegmentData, parsedSegment, segment, segmentBuffer }: {
+    playbackObserver: IReadOnlyPlaybackObserver<{
         position: number;
+        wantedTimeOffset: number;
     }>;
     content: {
         adaptation: Adaptation;
@@ -37,7 +39,7 @@ export default function pushMediaSegment<T>({ clock$, content, initSegmentData,
         representation: Representation;
     };
     initSegmentData: T | null;
-    parsedSegment: ISegmentParserParsedSegment<T>;
+    parsedSegment: ISegmentParserParsedMediaChunk<T>;
     segment: ISegment;
-    segmentBuffer: SegmentBuffer<T>;
+    segmentBuffer: SegmentBuffer;
 }): Observable<IStreamEventAddedSegment<T>>;

package/dist/_esm5.processed/core/stream/representation/push_media_segment.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, EMPTY, } from "rxjs";
-import { map } from "rxjs/operators";
+import { defer as observableDefer, EMPTY, map, } from "rxjs";
 import config from "../../../config";
 import objectAssign from "../../../utils/object_assign";
 import EVENTS from "../events_generators";
@@ -29,7 +28,7 @@ var APPEND_WINDOW_SECURITIES = config.APPEND_WINDOW_SECURITIES;
  * @returns {Observable}
  */
 export default function pushMediaSegment(_a) {
-    var clock$ = _a.clock$, content = _a.content, initSegmentData = _a.initSegmentData, parsedSegment = _a.parsedSegment, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
+    var playbackObserver = _a.playbackObserver, content = _a.content, initSegmentData = _a.initSegmentData, parsedSegment = _a.parsedSegment, segment = _a.segment, segmentBuffer = _a.segmentBuffer;
     return observableDefer(function () {
         var _a, _b;
         if (parsedSegment.chunkData === null) {
@@ -51,8 +50,7 @@ export default function pushMediaSegment(_a) {
         var data = { initSegment: initSegmentData,
             chunk: chunkData,
             timestampOffset: chunkOffset,
-            appendWindow: safeAppendWindow,
-            codec: codec };
+            appendWindow: safeAppendWindow, codec: codec };
         var estimatedStart = (_a = chunkInfos === null || chunkInfos === void 0 ? void 0 : chunkInfos.time) !== null && _a !== void 0 ? _a : segment.time;
         var estimatedDuration = (_b = chunkInfos === null || chunkInfos === void 0 ? void 0 : chunkInfos.duration) !== null && _b !== void 0 ? _b : segment.duration;
         var estimatedEnd = estimatedStart + estimatedDuration;
@@ -62,11 +60,9 @@ export default function pushMediaSegment(_a) {
         if (safeAppendWindow[1] !== undefined) {
             estimatedEnd = Math.min(estimatedEnd, safeAppendWindow[1]);
         }
-        var inventoryInfos = objectAssign({ segment: segment,
-            start: estimatedStart,
+        var inventoryInfos = objectAssign({ segment: segment, start: estimatedStart,
             end: estimatedEnd }, content);
-        return appendSegmentToBuffer(clock$, segmentBuffer, { data: data, inventoryInfos: inventoryInfos })
-            .pipe(map(function () {
+        return appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }).pipe(map(function () {
             var buffered = segmentBuffer.getBufferedRanges();
             return EVENTS.addedSegment(content, segment, buffered, chunkData);
         }));

package/dist/_esm5.processed/core/stream/representation/representation_stream.d.ts

@@ -15,21 +15,17 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Adaptation, Period, Representation } from "../../../manifest";
-import { IStalledStatus } from "../../api";
+import { IReadOnlyPlaybackObserver } from "../../api";
 import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { SegmentBuffer } from "../../segment_buffers";
 import { IRepresentationStreamEvent } from "../types";
-/** Object emitted by the Stream's clock$ at each tick. */
-export interface IRepresentationStreamClockTick {
-    /** The position, in seconds, the media element was in at the time of the tick. */
-    position: number;
+/** Object that should be emitted by the given `IReadOnlyPlaybackObserver`. */
+export interface IRepresentationStreamPlaybackObservation {
     /**
-     * Gap between the current position and the edge of a live content.
-     * Not set for non-live contents.
+     * The position, in seconds, the media element was in at the time of the
+     * playback observation.
      */
-    liveGap?: number;
-    /** If set, the player is currently stalled (blocked). */
-    stalled: IStalledStatus | null;
+    position: number;
     /**
      * Offset in seconds to add to the time to obtain the position we
      * actually want to download from.
@@ -38,17 +34,13 @@ export interface IRepresentationStreamClockTick {
      * starting position different from `0`.
      */
     wantedTimeOffset: number;
-    /** Fetch the precize position currently in the HTMLMediaElement. */
-    getCurrentTime(): number;
 }
 /** Item emitted by the `terminate$` Observable given to a RepresentationStream. */
 export interface ITerminationOrder {
     urgent: boolean;
 }
 /** Arguments to give to the RepresentationStream. */
-export interface IRepresentationStreamArguments<T> {
-    /** Periodically emits the current playback conditions. */
-    clock$: Observable<IRepresentationStreamClockTick>;
+export interface IRepresentationStreamArguments<TSegmentDataType> {
     /** The context of the Representation you want to load. */
     content: {
         adaptation: Adaptation;
@@ -57,9 +49,9 @@ export interface IRepresentationStreamArguments<T> {
         representation: Representation;
     };
     /** The `SegmentBuffer` on which segments will be pushed. */
-    segmentBuffer: SegmentBuffer<T>;
+    segmentBuffer: SegmentBuffer;
     /** Interface used to load new segments. */
-    segmentFetcher: IPrioritizedSegmentFetcher<T>;
+    segmentFetcher: IPrioritizedSegmentFetcher<TSegmentDataType>;
     /**
      * Observable emitting when the RepresentationStream should "terminate".
      *
@@ -71,6 +63,8 @@ export interface IRepresentationStreamArguments<T> {
      * Observable once the corresponding segments have been pushed).
      */
     terminate$: Observable<ITerminationOrder>;
+    /** Periodically emits the current playback conditions. */
+    playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>;
     /** Supplementary arguments which configure the RepresentationStream's behavior. */
     options: IRepresentationStreamOptions;
 }
@@ -128,4 +122,4 @@ export interface IRepresentationStreamOptions {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function RepresentationStream<T>({ clock$, content, segmentBuffer, segmentFetcher, terminate$, options, }: IRepresentationStreamArguments<T>): Observable<IRepresentationStreamEvent<T>>;
+export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate$, }: IRepresentationStreamArguments<TSegmentDataType>): Observable<IRepresentationStreamEvent>;