rx-player 3.27.0 → 3.27.1-dev.2022041500

package/dist/_esm5.processed/core/init/get_initial_time.js

@@ -15,6 +15,7 @@
  */
 import config from "../../config";
 import log from "../../log";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
 /**
  * Returns the calculated initial time for the content described by the given
  * Manifest:
@@ -29,34 +30,40 @@ import log from "../../log";
  * @returns {Number}
  */
 export default function getInitialTime(manifest, lowLatencyMode, startAt) {
-    if (startAt != null) {
-        var min = manifest.getMinimumPosition();
-        var max = manifest.getMaximumPosition();
-        if (startAt.position != null) {
+    if (!isNullOrUndefined(startAt)) {
+        var min = manifest.getMinimumSafePosition();
+        var max = void 0;
+        if (manifest.isLive) {
+            max = manifest.getLivePosition();
+        }
+        if (max === undefined) {
+            max = manifest.getMaximumSafePosition();
+        }
+        if (!isNullOrUndefined(startAt.position)) {
             log.debug("Init: using startAt.minimumPosition");
             return Math.max(Math.min(startAt.position, max), min);
         }
-        else if (startAt.wallClockTime != null) {
+        else if (!isNullOrUndefined(startAt.wallClockTime)) {
             log.debug("Init: using startAt.wallClockTime");
-            var ast = manifest.availabilityStartTime == null ?
+            var ast = manifest.availabilityStartTime === undefined ?
                 0 :
                 manifest.availabilityStartTime;
             var position = startAt.wallClockTime - ast;
             return Math.max(Math.min(position, max), min);
         }
-        else if (startAt.fromFirstPosition != null) {
+        else if (!isNullOrUndefined(startAt.fromFirstPosition)) {
             log.debug("Init: using startAt.fromFirstPosition");
             var fromFirstPosition = startAt.fromFirstPosition;
             return fromFirstPosition <= 0 ? min :
                 Math.min(max, min + fromFirstPosition);
         }
-        else if (startAt.fromLastPosition != null) {
+        else if (!isNullOrUndefined(startAt.fromLastPosition)) {
             log.debug("Init: using startAt.fromLastPosition");
             var fromLastPosition = startAt.fromLastPosition;
             return fromLastPosition >= 0 ? max :
                 Math.max(min, max + fromLastPosition);
         }
-        else if (startAt.percentage != null) {
+        else if (!isNullOrUndefined(startAt.percentage)) {
             log.debug("Init: using startAt.percentage");
             var percentage = startAt.percentage;
             if (percentage > 100) {
@@ -70,13 +77,13 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
             return min + extent * ratio;
         }
     }
-    var minimumPosition = manifest.getMinimumPosition();
+    var minimumPosition = manifest.getMinimumSafePosition();
     if (manifest.isLive) {
         var suggestedPresentationDelay = manifest.suggestedPresentationDelay, clockOffset = manifest.clockOffset;
-        var maximumPosition = manifest.getMaximumPosition();
+        var maximumPosition = manifest.getMaximumSafePosition();
         var liveTime = void 0;
         var DEFAULT_LIVE_GAP = config.getCurrent().DEFAULT_LIVE_GAP;
-        if (clockOffset == null) {
+        if (clockOffset === undefined) {
             log.info("Init: no clock offset found for a live content, " +
                 "starting close to maximum available position");
             liveTime = maximumPosition;
@@ -84,7 +91,7 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
         else {
             log.info("Init: clock offset found for a live content, " +
                 "checking if we can start close to it");
-            var ast = manifest.availabilityStartTime == null ?
+            var ast = manifest.availabilityStartTime === undefined ?
                 0 :
                 manifest.availabilityStartTime;
             var clockRelativeLiveTime = (performance.now() + clockOffset) / 1000 - ast;

package/dist/_esm5.processed/core/init/load_on_media_source.js

@@ -18,11 +18,12 @@ import { MediaError } from "../../errors";
 import log from "../../log";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator from "../stream";
+import ContentTimeBoundariesObserver from "./content_time_boundaries_observer";
 import createStreamPlaybackObserver from "./create_stream_playback_observer";
-import DurationUpdater from "./duration_updater";
 import emitLoadedEvent from "./emit_loaded_event";
 import { maintainEndOfStream } from "./end_of_stream";
 import initialSeekAndPlay from "./initial_seek_and_play";
+import MediaDurationUpdater from "./media_duration_updater";
 import StallAvoider from "./stall_avoider";
 import streamEventsEmitter from "./stream_events_emitter";
 import updatePlaybackRate from "./update_playback_rate";
@@ -43,7 +44,7 @@ export default function createMediaSourceLoader(_a) {
     return function loadContentOnMediaSource(mediaSource, initialTime, autoPlay) {
         var _a;
         /** Maintains the MediaSource's duration up-to-date with the Manifest */
-        var durationUpdater$ = DurationUpdater(manifest, mediaSource);
+        var mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
         var initialPeriod = (_a = manifest.getPeriodForTime(initialTime)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(initialTime);
         if (initialPeriod === undefined) {
             var error_1 = new MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
@@ -83,6 +84,17 @@ export default function createMediaSourceLoader(_a) {
                     return observableOf(evt);
             }
         }));
+        var contentTimeObserver = ContentTimeBoundariesObserver(manifest, streams$, streamObserver)
+            .pipe(mergeMap(function (evt) {
+            switch (evt.type) {
+                case "contentDurationUpdate":
+                    log.debug("Init: Duration has to be updated.", evt.value);
+                    mediaDurationUpdater.updateKnownDuration(evt.value);
+                    return EMPTY;
+                default:
+                    return observableOf(evt);
+            }
+        }));
         /**
          * On subscription, keep the playback speed synchronized to the speed set by
          * the user on the media element and force a speed of `0` when the buffer is
@@ -105,7 +117,8 @@ export default function createMediaSourceLoader(_a) {
                 observableOf(evt) :
                 emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, false);
         }));
-        return observableMerge(durationUpdater$, loadingEvts$, playbackRate$, stallAvoider$, streams$, streamEvents$).pipe(finalize(function () {
+        return observableMerge(loadingEvts$, playbackRate$, stallAvoider$, streams$, contentTimeObserver, streamEvents$).pipe(finalize(function () {
+            mediaDurationUpdater.stop();
             // clean-up every created SegmentBuffers
             segmentBuffersStore.disposeAll();
         }));

package/dist/_esm5.processed/core/init/media_duration_updater.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import Manifest from "../../manifest";
+/**
+ * Keep the MediaSource's duration up-to-date with what is being played.
+ * @class MediaDurationUpdater
+ */
+export default class MediaDurationUpdater {
+    private _subscription;
+    /**
+     * The last known audio Adaptation (i.e. track) chosen for the last Period.
+     * Useful to determinate the duration of the current content.
+     * `undefined` if the audio track for the last Period has never been known yet.
+     * `null` if there are no chosen audio Adaptation.
+     */
+    private _lastKnownDuration;
+    /**
+     * Create a new `MediaDurationUpdater` that will keep the given MediaSource's
+     * duration as soon as possible.
+     * This duration will be updated until the `stop` method is called.
+     * @param {Object} manifest - The Manifest currently played.
+     * For another content, you will have to create another `MediaDurationUpdater`.
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * pushed.
+     */
+    constructor(manifest: Manifest, mediaSource: MediaSource);
+    /**
+     * By default, the `MediaDurationUpdater` only set a safe estimate for the
+     * MediaSource's duration.
+     * A more precize duration can be set by communicating to it a more precize
+     * media duration through `updateKnownDuration`.
+     * If the duration becomes unknown, `undefined` can be given to it so the
+     * `MediaDurationUpdater` goes back to a safe estimate.
+     * @param {number | undefined} newDuration
+     */
+    updateKnownDuration(newDuration: number | undefined): void;
+    /**
+     * Stop the `MediaDurationUpdater` from updating and free its resources.
+     * Once stopped, it is not possible to start it again, beside creating another
+     * `MediaDurationUpdater`.
+     */
+    stop(): void;
+}

package/dist/_esm5.processed/core/init/media_duration_updater.js

@@ -0,0 +1,188 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { combineLatest as observableCombineLatest, distinctUntilChanged, EMPTY, fromEvent as observableFromEvent, interval as observableInterval, map, merge as observableMerge, mergeMap, of as observableOf, startWith, switchMap, timer, } from "rxjs";
+import { onSourceOpen$, onSourceClose$, onSourceEnded$, } from "../../compat/event_listeners";
+import log from "../../log";
+import { fromEvent } from "../../utils/event_emitter";
+import createSharedReference from "../../utils/reference";
+/** Number of seconds in a regular year. */
+var YEAR_IN_SECONDS = 365 * 24 * 3600;
+/**
+ * Keep the MediaSource's duration up-to-date with what is being played.
+ * @class MediaDurationUpdater
+ */
+var MediaDurationUpdater = /** @class */ (function () {
+    /**
+     * Create a new `MediaDurationUpdater` that will keep the given MediaSource's
+     * duration as soon as possible.
+     * This duration will be updated until the `stop` method is called.
+     * @param {Object} manifest - The Manifest currently played.
+     * For another content, you will have to create another `MediaDurationUpdater`.
+     * @param {MediaSource} mediaSource - The MediaSource on which the content is
+     * pushed.
+     */
+    function MediaDurationUpdater(manifest, mediaSource) {
+        var _this = this;
+        this._lastKnownDuration = createSharedReference(undefined);
+        this._subscription = isMediaSourceOpened$(mediaSource).pipe(switchMap(function (canUpdate) {
+            return canUpdate ? observableCombineLatest([_this._lastKnownDuration.asObservable(),
+                fromEvent(manifest, "manifestUpdate")
+                    .pipe(startWith(null))]) :
+                EMPTY;
+        }), switchMap(function (_a) {
+            var lastKnownDuration = _a[0];
+            return areSourceBuffersUpdating$(mediaSource.sourceBuffers).pipe(switchMap(function (areSBUpdating) {
+                return areSBUpdating ? EMPTY :
+                    recursivelyTryUpdatingDuration();
+                function recursivelyTryUpdatingDuration() {
+                    var res = setMediaSourceDuration(mediaSource, manifest, lastKnownDuration);
+                    if (res === "success" /* Success */) {
+                        return EMPTY;
+                    }
+                    return timer(2000)
+                        .pipe(mergeMap(function () { return recursivelyTryUpdatingDuration(); }));
+                }
+            }));
+        })).subscribe();
+    }
+    /**
+     * By default, the `MediaDurationUpdater` only set a safe estimate for the
+     * MediaSource's duration.
+     * A more precize duration can be set by communicating to it a more precize
+     * media duration through `updateKnownDuration`.
+     * If the duration becomes unknown, `undefined` can be given to it so the
+     * `MediaDurationUpdater` goes back to a safe estimate.
+     * @param {number | undefined} newDuration
+     */
+    MediaDurationUpdater.prototype.updateKnownDuration = function (newDuration) {
+        this._lastKnownDuration.setValue(newDuration);
+    };
+    /**
+     * Stop the `MediaDurationUpdater` from updating and free its resources.
+     * Once stopped, it is not possible to start it again, beside creating another
+     * `MediaDurationUpdater`.
+     */
+    MediaDurationUpdater.prototype.stop = function () {
+        this._subscription.unsubscribe();
+    };
+    return MediaDurationUpdater;
+}());
+export default MediaDurationUpdater;
+/**
+ * Checks that duration can be updated on the MediaSource, and then
+ * sets it.
+ *
+ * Returns either:
+ *   - the new duration it has been updated to if it has
+ *   - `null` if it hasn'nt been updated
+ *
+ * @param {MediaSource} mediaSource
+ * @param {Object} manifest
+ * @returns {string}
+ */
+function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
+    var _a;
+    var newDuration = knownDuration;
+    if (newDuration === undefined) {
+        if (manifest.isDynamic) {
+            var maxPotentialPos = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : manifest.getMaximumSafePosition();
+            // Some targets poorly support setting a very high number for durations.
+            // Yet, in dynamic contents, we would prefer setting a value as high as possible
+            // to still be able to seek anywhere we want to (even ahead of the Manifest if
+            // we want to). As such, we put it at a safe default value of 2^32 excepted
+            // when the maximum position is already relatively close to that value, where
+            // we authorize exceptionally going over it.
+            newDuration = Math.max(Math.pow(2, 32), maxPotentialPos + YEAR_IN_SECONDS);
+        }
+        else {
+            newDuration = manifest.getMaximumSafePosition();
+        }
+    }
+    var maxBufferedEnd = 0;
+    for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
+        var sourceBuffer = mediaSource.sourceBuffers[i];
+        var sbBufferedLen = sourceBuffer.buffered.length;
+        if (sbBufferedLen > 0) {
+            maxBufferedEnd = Math.max(sourceBuffer.buffered.end(sbBufferedLen - 1));
+        }
+    }
+    if (newDuration === mediaSource.duration) {
+        return "success" /* Success */;
+    }
+    else if (maxBufferedEnd > newDuration) {
+        // We already buffered further than the duration we want to set.
+        // Keep the duration that was set at that time as a security.
+        if (maxBufferedEnd < mediaSource.duration) {
+            try {
+                log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
+                mediaSource.duration = newDuration;
+            }
+            catch (err) {
+                log.warn("Duration Updater: Can't update duration on the MediaSource.", err);
+                return "failed" /* Failed */;
+            }
+        }
+        return "partial" /* Partial */;
+    }
+    else {
+        var oldDuration = mediaSource.duration;
+        try {
+            log.info("Init: Updating duration", newDuration);
+            mediaSource.duration = newDuration;
+        }
+        catch (err) {
+            log.warn("Duration Updater: Can't update duration on the MediaSource.", err);
+            return "failed" /* Failed */;
+        }
+        var deltaToExpected = Math.abs(mediaSource.duration - newDuration);
+        if (deltaToExpected >= 0.1) {
+            var deltaToBefore = Math.abs(mediaSource.duration - oldDuration);
+            return deltaToExpected < deltaToBefore ? "partial" /* Partial */ :
+                "failed" /* Failed */;
+        }
+        return "success" /* Success */;
+    }
+}
+/**
+ * Returns an Observable which will emit only when all the SourceBuffers ended
+ * all pending updates.
+ * @param {SourceBufferList} sourceBuffers
+ * @returns {Observable}
+ */
+function areSourceBuffersUpdating$(sourceBuffers) {
+    if (sourceBuffers.length === 0) {
+        return observableOf(false);
+    }
+    var sourceBufferUpdatingStatuses = [];
+    var _loop_1 = function (i) {
+        var sourceBuffer = sourceBuffers[i];
+        sourceBufferUpdatingStatuses.push(observableMerge(observableFromEvent(sourceBuffer, "updatestart").pipe(map(function () { return true; })), observableFromEvent(sourceBuffer, "update").pipe(map(function () { return false; })), observableInterval(500).pipe(map(function () { return sourceBuffer.updating; }))).pipe(startWith(sourceBuffer.updating), distinctUntilChanged()));
+    };
+    for (var i = 0; i < sourceBuffers.length; i++) {
+        _loop_1(i);
+    }
+    return observableCombineLatest(sourceBufferUpdatingStatuses).pipe(map(function (areUpdating) {
+        return areUpdating.some(function (isUpdating) { return isUpdating; });
+    }), distinctUntilChanged());
+}
+/**
+ * Emit a boolean that tells if the media source is opened or not.
+ * @param {MediaSource} mediaSource
+ * @returns {Object}
+ */
+function isMediaSourceOpened$(mediaSource) {
+    return observableMerge(onSourceOpen$(mediaSource).pipe(map(function () { return true; })), onSourceEnded$(mediaSource).pipe(map(function () { return false; })), onSourceClose$(mediaSource).pipe(map(function () { return false; }))).pipe(startWith(mediaSource.readyState === "open"), distinctUntilChanged());
+}

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.d.ts

@@ -44,11 +44,8 @@ export interface IAdaptationStreamPlaybackObservation extends IRepresentationStr
     isPaused: boolean;
     /** Last "playback rate" asked by the user. */
     speed: number;
-    /**
-     * Only set for live contents.
-     * Difference between the live edge and the current position, in seconds.
-     */
-    liveGap: number | undefined;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition: number;
 }
 /** Arguments given when creating a new `AdaptationStream`. */
 export interface IAdaptationStreamArguments {

package/dist/_esm5.processed/core/stream/adaptation/create_representation_estimator.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Observable, Subject } from "rxjs";
-import Manifest, { Adaptation } from "../../../manifest";
+import Manifest, { Adaptation, Period } from "../../../manifest";
 import ABRManager, { IABREstimate, IABRManagerPlaybackObservation, IABRStreamEvents } from "../../abr";
 /**
  * Create an "estimator$" Observable which will emit which Representation (from
@@ -33,8 +33,9 @@ import ABRManager, { IABREstimate, IABRManagerPlaybackObservation, IABRStreamEve
  * @param {Observable} observation$
  * @returns {Object}
  */
-export default function createRepresentationEstimator({ manifest, adaptation }: {
+export default function createRepresentationEstimator(content: {
     manifest: Manifest;
+    period: Period;
     adaptation: Adaptation;
 }, abrManager: ABRManager, observation$: Observable<IABRManagerPlaybackObservation>): {
     estimator$: Observable<IABREstimate>;

package/dist/_esm5.processed/core/stream/adaptation/create_representation_estimator.js

@@ -33,8 +33,8 @@ import { fromEvent } from "../../../utils/event_emitter";
  * @param {Observable} observation$
  * @returns {Object}
  */
-export default function createRepresentationEstimator(_a, abrManager, observation$) {
-    var manifest = _a.manifest, adaptation = _a.adaptation;
+export default function createRepresentationEstimator(content, abrManager, observation$) {
+    var manifest = content.manifest, adaptation = content.adaptation;
     var abrFeedbacks$ = new Subject();
     var estimator$ = observableMerge(
     // subscribe "first" (hack as it is a merge here) to event
@@ -60,7 +60,7 @@ export default function createRepresentationEstimator(_a, abrManager, observatio
         }
         return true;
     }), switchMap(function (playableRepresentations) {
-        return abrManager.get$(adaptation.type, playableRepresentations, observation$, abrFeedbacks$);
+        return abrManager.get$(content, playableRepresentations, observation$, abrFeedbacks$);
     }));
     return { estimator$: estimator$, abrFeedbacks$: abrFeedbacks$ };
 }

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -84,26 +84,8 @@ export default function StreamOrchestrator(content, playbackObserver, abrManager
             maxBufferAhead$: maxBufferAhead.asObservable().pipe(map(function (val) { return Math.min(val, defaultMaxAhead); })),
         });
     });
-    // trigger warnings when the wanted time is before or after the manifest's
-    // segments
-    var outOfManifest$ = playbackObserver.observe(true).pipe(filterMap(function (_a) {
-        var position = _a.position, wantedTimeOffset = _a.wantedTimeOffset;
-        var offsetedPosition = wantedTimeOffset + position;
-        if (offsetedPosition < manifest.getMinimumPosition()) {
-            var warning = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", "The current position is behind the " +
-                "earliest time announced in the Manifest.");
-            return EVENTS.warning(warning);
-        }
-        else if (offsetedPosition > manifest.getMaximumPosition()) {
-            var warning = new MediaError("MEDIA_TIME_AFTER_MANIFEST", "The current position is after the latest " +
-                "time announced in the Manifest.");
-            return EVENTS.warning(warning);
-        }
-        return null;
-    }, null));
-    var bufferTypes = segmentBuffersStore.getBufferTypes();
     // Every PeriodStreams for every possible types
-    var streamsArray = bufferTypes.map(function (bufferType) {
+    var streamsArray = segmentBuffersStore.getBufferTypes().map(function (bufferType) {
         return manageEveryStreams(bufferType, initialPeriod)
             .pipe(deferSubscriptions(), share());
     });
@@ -122,9 +104,7 @@ export default function StreamOrchestrator(content, playbackObserver, abrManager
     }), distinctUntilChanged(), map(function (emitEndOfStream) {
         return emitEndOfStream ? EVENTS.endOfStream() : EVENTS.resumeStream();
     }));
-    return observableMerge.apply(void 0, __spreadArray(__spreadArray([], streamsArray, false), [activePeriodChanged$,
-        endOfStream$,
-        outOfManifest$], false));
+    return observableMerge.apply(void 0, __spreadArray(__spreadArray([], streamsArray, false), [activePeriodChanged$, endOfStream$], false));
     /**
      * Manage creation and removal of Streams for every Periods for a given type.
      *

package/dist/_esm5.processed/core/stream/period/period_stream.d.ts

@@ -41,11 +41,8 @@ export interface IPeriodStreamPlaybackObservation {
      * which we actually want to download segments for.
      */
     wantedTimeOffset: number;
-    /**
-     * Only set for live contents.
-     * Difference between the live edge and the current position, in seconds.
-     */
-    liveGap: number | undefined;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition: number;
 }
 /** Arguments required by the `PeriodStream`. */
 export interface IPeriodStreamArguments {

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -15,7 +15,7 @@
  */
 import { catchError, concat as observableConcat, defer as observableDefer, EMPTY, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, startWith, switchMap, } from "rxjs";
 import config from "../../../config";
-import { formatError } from "../../../errors";
+import { formatError, MediaError, } from "../../../errors";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
@@ -166,9 +166,11 @@ function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation,
  * @returns {string}
  */
 function getFirstDeclaredMimeType(adaptation) {
-    var representations = adaptation.representations;
-    if (representations[0] == null) {
-        return "";
+    var representations = adaptation.getPlayableRepresentations();
+    if (representations.length === 0) {
+        var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
+            adaptation.type + " Adaptation can be played");
+        throw noRepErr;
     }
     return representations[0].getMimeTypeString();
 }

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

@@ -56,9 +56,11 @@ export interface IBufferStatus {
  * be filled by any segment, even in the future.
  *
  * @param {Object} content
- * @param {Object} playbackInfo
+ * @param {number} initialWantedTime
+ * @param {Object} playbackObserver
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
+ * @param {number} maxBufferSize
  * @param {Object} segmentBuffer
  * @returns {Object}
  */
@@ -67,4 +69,4 @@ export default function getBufferStatus(content: {
     manifest: Manifest;
     period: Period;
     representation: Representation;
-}, wantedStartPosition: number, playbackObserver: IReadOnlyPlaybackObserver<unknown>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentBuffer: SegmentBuffer): IBufferStatus;
+}, initialWantedTime: number, playbackObserver: IReadOnlyPlaybackObserver<unknown>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentBuffer: SegmentBuffer): IBufferStatus;