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

package/src/core/init/utils/stream_events_emitter/stream_events_emitter.ts

@@ -20,6 +20,7 @@ import EventEmitter from "../../../../utils/event_emitter";
 import SharedReference from "../../../../utils/reference";
 import TaskCanceller, { CancellationSignal } from "../../../../utils/task_canceller";
 import { IPlaybackObservation, IReadOnlyPlaybackObserver } from "../../../api";
+import { SeekingState } from "../../../api/playback_observer";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
 import {
   INonFiniteStreamEventPayload,
@@ -127,8 +128,10 @@ export default class StreamEventsEmitter extends EventEmitter<IStreamEventsEmitt
       });
 
       function constructObservation() {
-        const isSeeking = playbackObserver.getReference().getValue().seeking;
-        return { currentTime: mediaElement.currentTime,
+        const lastObservation = playbackObserver.getReference().getValue();
+        const currentTime = mediaElement.currentTime;
+        const isSeeking = lastObservation.seeking !== SeekingState.None;
+        return { currentTime,
                  isSeeking };
       }
     }, { emitCurrentValue: true, clearSignal: cancelSignal });

package/src/core/segment_buffers/garbage_collector.ts

@@ -54,7 +54,7 @@ export default function BufferGarbageCollector(
 ) : void {
   let lastPosition : number;
   playbackObserver.listen((o) => {
-    lastPosition = o.position.pending ?? o.position.last;
+    lastPosition = o.position.getWanted();
     clean();
   }, { includeLastObservation: true, clearSignal: cancellationSignal });
   function clean() {

package/src/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.ts

@@ -376,7 +376,15 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
                       err :
                       new Error("An unknown error occured when doing operations " +
                                 "on the SourceBuffer");
-      this._pendingTask.reject(error);
+      const task = this._pendingTask;
+      if (task.type === SegmentBufferOperation.Push &&
+          task.data.length === 0 &&
+          task.inventoryData !== null)
+      {
+        this._segmentInventory.insertChunk(task.inventoryData, false);
+      }
+      this._pendingTask = null;
+      task.reject(error);
     }
   }
 
@@ -429,7 +437,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
         switch (task.type) {
           case SegmentBufferOperation.Push:
             if (task.inventoryData !== null) {
-              this._segmentInventory.insertChunk(task.inventoryData);
+              this._segmentInventory.insertChunk(task.inventoryData, true);
             }
             break;
           case SegmentBufferOperation.EndOfSegment:

package/src/core/segment_buffers/implementations/text/html/html_text_segment_buffer.ts

@@ -302,7 +302,7 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
     }
 
     if (infos.inventoryInfos !== null) {
-      this._segmentInventory.insertChunk(infos.inventoryInfos);
+      this._segmentInventory.insertChunk(infos.inventoryInfos, true);
     }
     this._buffer.insert(cues, start, end);
     this._buffered.insert(start, end);

package/src/core/segment_buffers/implementations/text/native/native_text_segment_buffer.ts

@@ -182,7 +182,7 @@ export default class NativeTextSegmentBuffer extends SegmentBuffer {
       }
       this._buffered.insert(start, end);
       if (infos.inventoryInfos !== null) {
-        this._segmentInventory.insertChunk(infos.inventoryInfos);
+        this._segmentInventory.insertChunk(infos.inventoryInfos, true);
       }
     } catch (err) {
       return Promise.reject(err);

package/src/core/segment_buffers/index.ts

@@ -28,6 +28,7 @@ import {
   SegmentBufferOperation,
 } from "./implementations";
 import {
+  ChunkStatus,
   IBufferedChunk,
   IChunkContext,
   IInsertedChunkInfos,
@@ -42,6 +43,7 @@ import SegmentBuffersStore, {
 export default SegmentBuffersStore;
 export {
   BufferGarbageCollector,
+  ChunkStatus,
 
   ISegmentBufferOptions,
   ITextTrackSegmentBufferOptions,

package/src/core/segment_buffers/inventory/index.ts

@@ -15,12 +15,14 @@
  */
 
 import SegmentInventory, {
+  ChunkStatus,
   IBufferedChunk,
   IInsertedChunkInfos,
 } from "./segment_inventory";
 
 export default SegmentInventory;
 export {
+  ChunkStatus,
   IBufferedChunk,
   IInsertedChunkInfos,
 };

package/src/core/segment_buffers/inventory/segment_inventory.ts

@@ -28,6 +28,27 @@ import BufferedHistory, {
 } from "./buffered_history";
 import { IChunkContext } from "./types";
 
+/** Categorization of a given chunk in the `SegmentInventory`. */
+export const enum ChunkStatus {
+  /**
+   * This chunk is only a part of a partially-pushed segment for now, meaning
+   * that it is only a sub-part of a requested segment that was not yet
+   * fully-loaded and pushed.
+   *
+   * Once and if the corresponding segment is fully-pushed, its `ChunkStatus`
+   * switches to `Complete`.
+   */
+  PartiallyPushed = 0,
+  /** This chunk corresponds to a fully-loaded segment. */
+  Complete = 1,
+  /**
+   * This chunk's push operation failed, in this scenario there is no certitude
+   * about the presence of that chunk in the buffer: it may not be present,
+   * partially-present, or fully-present depending on why that push operation
+   * failed, which is generally only known by the lower-level code.
+   */
+  Failed = 2,
+}
 
 /** Information stored on a single chunk by the SegmentInventory. */
 export interface IBufferedChunk {
@@ -82,14 +103,10 @@ export interface IBufferedChunk {
   /** Information on what that chunk actually contains. */
   infos : IChunkContext;
   /**
-   * If `true`, this chunk is only a partial chunk of a whole segment.
-   *
-   * Inversely, if `false`, this chunk is a whole segment whose inner chunks
-   * have all been fully pushed.
-   * In that condition, the `start` and `end` properties refer to that fully
-   * pushed segment.
+   * Status of this chunk.
+   * @see ChunkStatus
    */
-  partiallyPushed : boolean;
+  status : ChunkStatus;
   /**
    * If `true`, the segment as a whole is divided into multiple parts in the
    * buffer, with other segment(s) between them.
@@ -244,7 +261,11 @@ export default class SegmentInventory {
         log.debug(`SI: ${numberOfSegmentToDelete} segments GCed.`, bufferType);
         const removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
         for (const seg of removed) {
-          if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+          if (
+            seg.bufferedStart === undefined &&
+            seg.bufferedEnd === undefined &&
+            seg.status !== ChunkStatus.Failed
+          ) {
             this._bufferedHistory.addBufferedSegment(seg.infos, null);
           }
         }
@@ -318,7 +339,11 @@ export default class SegmentInventory {
                 bufferType, inventoryIndex, inventory.length);
       const removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
       for (const seg of removed) {
-        if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
+        if (
+          seg.bufferedStart === undefined &&
+          seg.bufferedEnd === undefined &&
+          seg.status !== ChunkStatus.Failed
+        ) {
           this._bufferedHistory.addBufferedSegment(seg.infos, null);
         }
       }
@@ -343,7 +368,8 @@ export default class SegmentInventory {
       segment,
       chunkSize,
       start,
-      end } : IInsertedChunkInfos
+      end } : IInsertedChunkInfos,
+    succeed: boolean
   ) : void {
     if (segment.isInit) {
       return;
@@ -357,7 +383,8 @@ export default class SegmentInventory {
     }
 
     const inventory = this._inventory;
-    const newSegment = { partiallyPushed: true,
+    const newSegment = { status: succeed ? ChunkStatus.PartiallyPushed :
+                                           ChunkStatus.Failed,
                          chunkSize,
                          splitted: false,
                          start,
@@ -565,7 +592,7 @@ export default class SegmentInventory {
               //  ===>         : |--|====|-|
               log.warn("SI: Segment pushed is contained in a previous one",
                        bufferType, start, end, segmentI.start, segmentI.end);
-              const nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+              const nextSegment = { status: segmentI.status,
                                     /**
                                      * Note: this sadly means we're doing as if
                                      * that chunk is present two times.
@@ -743,7 +770,9 @@ export default class SegmentInventory {
           this._inventory.splice(firstI + 1, length);
           i -= length;
         }
-        this._inventory[firstI].partiallyPushed = false;
+        if (this._inventory[firstI].status === ChunkStatus.PartiallyPushed) {
+          this._inventory[firstI].status = ChunkStatus.Complete;
+        }
         this._inventory[firstI].chunkSize = segmentSize;
         this._inventory[firstI].end = lastEnd;
         this._inventory[firstI].bufferedEnd = lastBufferedEnd;
@@ -760,8 +789,11 @@ export default class SegmentInventory {
       this.synchronizeBuffered(newBuffered);
       for (const seg of resSegments) {
         if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
-          this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
-                                                                end: seg.bufferedEnd });
+          if (seg.status !== ChunkStatus.Failed) {
+            this._bufferedHistory.addBufferedSegment(seg.infos,
+                                                     { start: seg.bufferedStart,
+                                                       end: seg.bufferedEnd });
+          }
         } else {
           log.debug("SI: buffered range not known after sync. Skipping history.",
                     seg.start,
@@ -810,7 +842,7 @@ function bufferedStartLooksCoherent(
   thisSegment : IBufferedChunk
 ) : boolean {
   if (thisSegment.bufferedStart === undefined ||
-      thisSegment.partiallyPushed)
+      thisSegment.status !== ChunkStatus.Complete)
   {
     return false;
   }
@@ -837,7 +869,7 @@ function bufferedEndLooksCoherent(
   thisSegment : IBufferedChunk
 ) : boolean {
   if (thisSegment.bufferedEnd === undefined ||
-      thisSegment.partiallyPushed)
+      thisSegment.status !== ChunkStatus.Complete)
   {
     return false;
   }

package/src/core/stream/adaptation/get_representations_switch_strategy.ts

@@ -35,14 +35,17 @@ import {
   IBufferedChunk,
   SegmentBuffer,
 } from "../../segment_buffers";
-import { IRepresentationsChoice } from "../representation";
+import {
+  IRepresentationStreamPlaybackObservation,
+  IRepresentationsChoice,
+} from "../representation";
 
 export default function getRepresentationsSwitchingStrategy(
   period : Period,
   adaptation : Adaptation,
   settings : IRepresentationsChoice,
   segmentBuffer : SegmentBuffer,
-  playbackObserver : IReadOnlyPlaybackObserver<unknown>
+  playbackObserver : IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>
 ) : IRepresentationSwitchStrategy {
   if (settings.switchingMode === "lazy") {
     return { type: "continue", value: undefined };
@@ -81,17 +84,22 @@ export default function getRepresentationsSwitchingStrategy(
     return { type: "continue", value: undefined };
   }
 
-  const currentTime = playbackObserver.getCurrentTime();
   const readyState = playbackObserver.getReadyState();
-  if (settings.switchingMode === "reload" &&
-      // We're playing the current Period
-      isTimeInRange({ start, end }, currentTime) &&
-      // There is data for the current position
-      readyState > 1 &&
-      // We're not playing the current wanted video Adaptation
-      !isTimeInRanges(rangesWithReps, currentTime))
-  {
-    return { type: "needs-reload", value: undefined };
+  if (settings.switchingMode === "reload" && readyState > 1) {
+    const 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 {
+      const currentTime = playbackObserver.getCurrentTime();
+      if (isTimeInRange({ start, end }, currentTime) &&
+          // We're not playing the current wanted video Adaptation
+          !isTimeInRanges(rangesWithReps, currentTime))
+      {
+        return { type: "needs-reload", value: undefined };
+      }
+    }
   }
 
   // From here, clean-up data from the previous Adaptation, if one
@@ -128,6 +136,7 @@ export default function getRepresentationsSwitchingStrategy(
     if (paddingAfter == null) {
       paddingAfter = 0;
     }
+    const currentTime = playbackObserver.getCurrentTime();
     rangesToExclude.push({ start: currentTime - paddingBefore,
                            end: currentTime + paddingAfter });
   }

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -108,7 +108,8 @@ export default function StreamOrchestrator(
           wantedBufferAhead,
           maxVideoBufferSize } = options;
 
-  const { MAXIMUM_MAX_BUFFER_AHEAD,
+  const { MINIMUM_MAX_BUFFER_AHEAD,
+          MAXIMUM_MAX_BUFFER_AHEAD,
           MAXIMUM_MAX_BUFFER_BEHIND } = config.getCurrent();
 
   // Keep track of a unique BufferGarbageCollector created per
@@ -116,12 +117,8 @@ export default function StreamOrchestrator(
   const garbageCollectors =
     new WeakMapMemory((segmentBuffer : SegmentBuffer) => {
       const { bufferType } = segmentBuffer;
-      const defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
-                                 MAXIMUM_MAX_BUFFER_BEHIND[bufferType] as number :
-                                 Infinity;
-      const defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
-                                MAXIMUM_MAX_BUFFER_AHEAD[bufferType] as number :
-                                Infinity;
+      const defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] ?? Infinity;
+      const maxAheadHigherBound = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] ?? Infinity;
       return (gcCancelSignal : CancellationSignal) => {
         BufferGarbageCollector(
           { segmentBuffer,
@@ -130,10 +127,11 @@ export default function StreamOrchestrator(
                                                    (val) =>
                                                      Math.min(val, defaultMaxBehind),
                                                    gcCancelSignal),
-            maxBufferAhead: createMappedReference(maxBufferAhead,
-                                                  (val) =>
-                                                    Math.min(val, defaultMaxAhead),
-                                                  gcCancelSignal) },
+            maxBufferAhead: createMappedReference(maxBufferAhead, (val) => {
+              const lowerBound = Math.max(val,
+                                          MINIMUM_MAX_BUFFER_AHEAD[bufferType] ?? 0);
+              return Math.min(lowerBound, maxAheadHigherBound);
+            }, gcCancelSignal) },
           gcCancelSignal
         );
       };
@@ -173,7 +171,7 @@ export default function StreamOrchestrator(
     // Restart the current Stream when the wanted time is in another period
     // than the ones already considered
     playbackObserver.listen(({ position }) => {
-      const time = position.pending ?? position.last;
+      const time = position.getWanted();
       if (!enableOutOfBoundsCheck || !isOutOfPeriodList(time)) {
         return ;
       }
@@ -370,8 +368,7 @@ export default function StreamOrchestrator(
           }
         }
 
-        const lastPosition = observation.position.pending ??
-                             observation.position.last;
+        const lastPosition = observation.position.getWanted();
         const newInitialPeriod = manifest.getPeriodForTime(lastPosition);
         if (newInitialPeriod == null) {
           callbacks.error(
@@ -444,13 +441,11 @@ export default function StreamOrchestrator(
     // Stop current PeriodStream when the current position goes over the end of
     // that Period.
     playbackObserver.listen(({ position }, stopListeningObservations) => {
-      if (basePeriod.end !== undefined &&
-          (position.pending ?? position.last) >= basePeriod.end)
-      {
+      if (basePeriod.end !== undefined && position.getWanted() >= basePeriod.end) {
         log.info("Stream: Destroying PeriodStream as the current playhead moved above it",
                  bufferType,
                  basePeriod.start,
-                 position.pending ?? position.last,
+                 position.getWanted(),
                  basePeriod.end);
         stopListeningObservations();
         consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
@@ -719,7 +714,7 @@ function needsFlushingAfterClean(
   if (cleanedRanges.length === 0) {
     return false;
   }
-  const curPos = observation.position.last;
+  const curPos = observation.position.getPolled();
 
   // Based on the playback direction, we just check whether we may encounter
   // the corresponding ranges, without seeking or re-switching playback

package/src/core/stream/period/period_stream.ts

@@ -221,18 +221,15 @@ export default function PeriodStream(
         return; // Previous call has provoken cancellation by side-effect
       }
 
-      const readyState = playbackObserver.getReadyState();
       const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore,
                                                        bufferType,
                                                        adaptation,
                                                        options);
-      const playbackInfos = { currentTime: playbackObserver.getCurrentTime(),
-                              readyState };
       const strategy = getAdaptationSwitchStrategy(segmentBuffer,
                                                    period,
                                                    adaptation,
                                                    choice.switchingMode,
-                                                   playbackInfos,
+                                                   playbackObserver,
                                                    options);
       if (strategy.type === "needs-reload") {
         return askForMediaSourceReload(relativePosAfterSwitch,
@@ -444,8 +441,10 @@ function createAdaptationStreamPlaybackObserver(
     ) : IAdaptationStreamPlaybackObservation {
       const baseObservation = observationRef.getValue();
       const buffered = segmentBuffer.getBufferedRanges();
-      const bufferGap = getLeftSizeOfBufferedTimeRange(buffered,
-                                                       baseObservation.position.last);
+      const bufferGap = getLeftSizeOfBufferedTimeRange(
+        buffered,
+        baseObservation.position.getWanted()
+      );
       return objectAssign({}, baseObservation, { bufferGap });
     }
 
@@ -486,15 +485,15 @@ function createEmptyAdaptationStream(
   function sendStatus() : void {
     const observation = playbackObserver.getReference().getValue();
     const wba = wantedBufferAhead.getValue();
-    const position = observation.position.last;
+    const position = observation.position.getWanted();
     if (period.end !== undefined && position + wba >= period.end) {
       log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
       hasFinishedLoading = true;
     }
     callbacks.streamStatusUpdate({ period,
                                    bufferType,
-                                   position,
                                    imminentDiscontinuity: null,
+                                   position,
                                    isEmptyStream: true,
                                    hasFinishedLoading,
                                    neededSegments: [] });

package/src/core/stream/period/types.ts

@@ -8,7 +8,7 @@ import SharedReference, {
 import { CancellationSignal } from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
-import { IReadOnlyPlaybackObserver } from "../../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { SegmentFetcherCreator } from "../../fetchers";
 import SegmentBuffersStore, {
   IBufferType,
@@ -21,7 +21,6 @@ import {
   IAdaptationStreamOptions,
   IPausedPlaybackObservation,
 } from "../adaptation";
-import { IPositionPlaybackObservation } from "../representation";
 
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IPeriodStreamCallbacks extends
@@ -86,7 +85,7 @@ export interface IPeriodStreamPlaybackObservation {
    * Information on the current media position in seconds at the time of the
    * Observation.
    */
-  position : IPositionPlaybackObservation;
+  position : IObservationPosition;
   /** `duration` property of the HTMLMediaElement. */
   duration : number;
   /** `readyState` property of the HTMLMediaElement. */

package/src/core/stream/period/utils/get_adaptation_switch_strategy.ts

@@ -28,6 +28,7 @@ import {
   isTimeInRanges,
   keepRangeIntersection,
 } from "../../../../utils/ranges";
+import { IReadOnlyPlaybackObserver } from "../../../api";
 import {
   getFirstSegmentAfterPeriod,
   getLastSegmentBeforePeriod,
@@ -35,6 +36,7 @@ import {
   SegmentBuffer,
 } from "../../../segment_buffers";
 import { ITrackSwitchingMode } from "../../adaptation";
+import { IPeriodStreamPlaybackObservation } from "../types";
 
 export type IAdaptationSwitchStrategy =
   /** Do nothing special. */
@@ -63,7 +65,7 @@ export interface IAdaptationSwitchOptions {
  * @param {Object} segmentBuffer
  * @param {Object} period
  * @param {Object} adaptation
- * @param {Object} playbackInfo
+ * @param {Object} playbackObserver
  * @returns {Object}
  */
 export default function getAdaptationSwitchStrategy(
@@ -71,7 +73,9 @@ export default function getAdaptationSwitchStrategy(
   period : Period,
   adaptation : Adaptation,
   switchingMode : ITrackSwitchingMode,
-  playbackInfo : { currentTime : number; readyState : number },
+  playbackObserver : IReadOnlyPlaybackObserver<
+    IPeriodStreamPlaybackObservation
+  >,
   options : IAdaptationSwitchOptions
 ) : IAdaptationSwitchStrategy {
   if (segmentBuffer.codec !== undefined &&
@@ -119,18 +123,20 @@ export default function getAdaptationSwitchStrategy(
     return { type: "continue", value: undefined };
   }
 
-  const { currentTime } = playbackInfo;
-  if (switchingMode === "reload" &&
-      // We're playing the current Period
-      isTimeInRange({ start, end }, currentTime) &&
-      // There is data for the current position or the codecs are differents
-      (playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations()
-        .some(rep =>
-          areCodecsCompatible(rep.getMimeTypeString(), segmentBuffer.codec ?? ""))) &&
-      // We're not playing the current wanted video Adaptation
-      !isTimeInRanges(adaptationInBuffer, currentTime))
-  {
-    return { type: "needs-reload", value: undefined };
+  const currentTime = playbackObserver.getCurrentTime();
+  const readyState = playbackObserver.getReadyState();
+  if (switchingMode === "reload" && readyState > 1) {
+    const 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 (isTimeInRange({ start, end }, currentTime) &&
+               // We're not playing the current wanted video Adaptation
+               !isTimeInRanges(adaptationInBuffer, currentTime))
+    {
+      return { type: "needs-reload", value: undefined };
+    }
   }
 
   // From here, clean-up data from the previous Adaptation, if one
@@ -216,7 +222,7 @@ function hasCompatibleCodec(
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
  * in the SegmentBuffer.
- * @param {Object} segmentBuffer
+ * @param {Array.<Object>} inventory
  * @param {Object} period
  * @param {Object} adaptation
  * @returns {Array.<Object>}

package/src/core/stream/representation/representation_stream.ts

@@ -230,8 +230,7 @@ export default function RepresentationStream<TSegmentDataType>(
       return ; // Stop all buffer status checking if load operations are stopped
     }
     const observation = playbackObserver.getReference().getValue();
-    const initialWantedTime = observation.position.pending ??
-                              observation.position.last;
+    const initialWantedTime = observation.position.getWanted();
     const status = getBufferStatus(content,
                                    initialWantedTime,
                                    playbackObserver,
@@ -251,8 +250,7 @@ export default function RepresentationStream<TSegmentDataType>(
         log.warn("Stream: Uninitialized index with an already loaded " +
                  "initialization segment");
       } else {
-        const wantedStart = observation.position.pending ??
-                            observation.position.last;
+        const wantedStart = observation.position.getWanted();
         neededInitSegment = { segment: initSegmentState.segment,
                               priority: getSegmentPriority(period.start,
                                                            wantedStart) };
@@ -307,7 +305,7 @@ export default function RepresentationStream<TSegmentDataType>(
     }
 
     callbacks.streamStatusUpdate({ period,
-                                   position: observation.position.last,
+                                   position: observation.position.getWanted(),
                                    bufferType,
                                    imminentDiscontinuity: status.imminentDiscontinuity,
                                    isEmptyStream: false,

package/src/core/stream/representation/types.ts

@@ -11,7 +11,7 @@ import {
   IVideoRepresentationsSwitchingMode,
 } from "../../../public_types";
 import { IReadOnlySharedReference } from "../../../utils/reference";
-import { IReadOnlyPlaybackObserver } from "../../api";
+import { IObservationPosition, IReadOnlyPlaybackObserver } from "../../api";
 import { IContentProtection } from "../../decrypt";
 import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import {
@@ -180,7 +180,7 @@ export interface IRepresentationStreamPlaybackObservation {
    * Information on the current media position in seconds at the time of a
    * Playback Observation.
    */
-  position : IPositionPlaybackObservation;
+  position : IObservationPosition;
 }
 
 /** Position-related information linked to an emitted Playback observation. */

package/src/core/stream/representation/utils/append_segment_to_buffer.ts

@@ -61,7 +61,7 @@ export default async function appendSegmentToBuffer<T>(
                            { adaptations: [dataInfos.inventoryInfos.adaptation] });
     }
     const { position } = playbackObserver.getReference().getValue();
-    const currentPos = position.pending ?? position.last;
+    const currentPos = position.getWanted();
     try {
       await forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal);
       await segmentBuffer.pushChunk(dataInfos, cancellationSignal);

package/src/core/stream/representation/utils/get_buffer_status.ts

@@ -23,6 +23,7 @@ import Manifest, {
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import SegmentBuffersStore, {
+  ChunkStatus,
   IBufferedChunk,
   IEndOfSegmentOperation,
   SegmentBuffer,
@@ -153,7 +154,7 @@ export default function getBufferStatus(
    * needed segments for this Representation until the end of the Period.
    */
   const hasFinishedLoading = representation.index.isInitialized() &&
-                             representation.index.isFinished() &&
+                             !representation.index.isStillAwaitingFutureSegments() &&
                              neededRange.hasReachedPeriodEnd &&
                              prioritizedNeededSegments.length === 0 &&
                              segmentsOnHold.length === 0;
@@ -221,7 +222,7 @@ function getRangeOfNeededSegments(
       SegmentBuffersStore.isNative(content.adaptation.type) &&
       initialWantedTime >= lastIndexPosition &&
       representationIndex.isInitialized() &&
-      representationIndex.isFinished() &&
+      !representationIndex.isStillAwaitingFutureSegments() &&
       isPeriodTheCurrentAndLastOne(manifest, period, initialWantedTime))
   {
     wantedStartPosition = lastIndexPosition - 1;
@@ -233,7 +234,7 @@ function getRangeOfNeededSegments(
 
   let hasReachedPeriodEnd;
   if (!representation.index.isInitialized() ||
-      !representation.index.isFinished() ||
+      representation.index.isStillAwaitingFutureSegments() ||
       period.end === undefined)
   {
     hasReachedPeriodEnd = false;
@@ -299,7 +300,7 @@ function getPlayableBufferedSegments(
     const eltInventory = segmentInventory[i];
 
     const { representation } = eltInventory.infos;
-    if (!eltInventory.partiallyPushed &&
+    if (eltInventory.status === ChunkStatus.Complete &&
         representation.decipherable !== false &&
         representation.isSupported)
     {