rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/abr/last_estimate_storage.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+/** Stores the last estimate made by the `RepresentationEstimator`. */
+var LastEstimateStorage = /** @class */ (function () {
+    function LastEstimateStorage() {
+        this.bandwidth = undefined;
+        this.representation = null;
+        this.algorithmType = 3 /* None */;
+    }
+    /**
+     * Update this `LastEstimateStorage` with new values.
+     * @param {Object} representation - Estimated Representation.
+     * @param {number|undefined} bandwidth - Estimated bandwidth.
+     * @param {boolean} wasGuessed - If `true`, this estimate was a guess made by
+     * the `GuessingEstimator`.
+     */
+    LastEstimateStorage.prototype.update = function (representation, bandwidth, algorithmType) {
+        this.representation = representation;
+        this.bandwidth = bandwidth;
+        this.algorithmType = algorithmType;
+    };
+    return LastEstimateStorage;
+}());
+export default LastEstimateStorage;

package/dist/_esm5.processed/core/abr/network_analyzer.d.ts

@@ -33,12 +33,21 @@ interface IPlaybackConditionsInfo {
     /** `duration` property of the HTMLMediaElement on which the content plays. */
     duration: number;
 }
+/**
+ * Estimate the __VERY__ recent bandwidth based on a single unfinished request.
+ * Useful when the current bandwidth seemed to have fallen quickly.
+ *
+ * @param {Object} request
+ * @returns {number|undefined}
+ */
+export declare function estimateRequestBandwidth(request: IRequestInfo): number | undefined;
 /**
  * Analyze the current network conditions and give a bandwidth estimate as well
  * as a maximum bitrate a Representation should be.
  * @class NetworkAnalyzer
  */
 export default class NetworkAnalyzer {
+    private _lowLatencyMode;
     private _inStarvationMode;
     private _initialBitrate;
     private _config;
@@ -47,21 +56,30 @@ export default class NetworkAnalyzer {
      * Gives an estimate of the current bandwidth and of the bitrate that should
      * be considered for chosing a `representation`.
      * This estimate is only based on network metrics.
-     * @param {Object} playbackInfo - Gives current information about playback
-     * @param {Object} bandwidthEstimator
-     * @param {Object|null} currentRepresentation
-     * @param {Array.<Object>} currentRequests
-     * @param {number|undefined} lastEstimatedBitrate
+     * @param {Object} playbackInfo - Gives current information about playback.
+     * @param {Object} bandwidthEstimator - `BandwidthEstimator` allowing to
+     * produce network bandwidth estimates.
+     * @param {Object|null} currentRepresentation - The Representation currently
+     * chosen.
+     * `null` if no Representation has been chosen yet.
+     * @param {Array.<Object>} currentRequests - All segment requests by segment's
+     * start chronological order
+     * @param {number|undefined} lastEstimatedBitrate - Bitrate emitted during the
+     * last estimate.
      * @returns {Object}
      */
     getBandwidthEstimate(playbackInfo: IPlaybackConditionsInfo, bandwidthEstimator: BandwidthEstimator, currentRepresentation: Representation | null, currentRequests: IRequestInfo[], lastEstimatedBitrate: number | undefined): {
-        bandwidthEstimate?: number;
+        bandwidthEstimate?: number | undefined;
         bitrateChosen: number;
     };
     /**
      * For a given wanted bitrate, tells if should switch urgently.
-     * @param {number} bitrate
-     * @param {Object} playbackInfo
+     * @param {number} bitrate - The new estimated bitrate.
+     * @param {Object|null} currentRepresentation - The Representation being
+     * presently being loaded.
+     * @param {Array.<Object>} currentRequests - All segment requests by segment's
+     * start chronological order
+     * @param {Object} playbackInfo - Information on the current playback.
      * @returns {boolean}
      */
     isUrgent(bitrate: number, currentRepresentation: Representation | null, currentRequests: IRequestInfo[], playbackInfo: IPlaybackConditionsInfo): boolean;

package/dist/_esm5.processed/core/abr/network_analyzer.js

@@ -16,34 +16,44 @@
 import config from "../../config";
 import log from "../../log";
 import arrayFind from "../../utils/array_find";
-import arrayFindIndex from "../../utils/array_find_index";
-import EWMA from "./ewma";
+import EWMA from "./utils/ewma";
 var ABR_REGULAR_FACTOR = config.ABR_REGULAR_FACTOR, ABR_STARVATION_DURATION_DELTA = config.ABR_STARVATION_DURATION_DELTA, ABR_STARVATION_FACTOR = config.ABR_STARVATION_FACTOR, ABR_STARVATION_GAP = config.ABR_STARVATION_GAP, OUT_OF_STARVATION_GAP = config.OUT_OF_STARVATION_GAP;
 /**
  * Get pending segment request(s) starting with the asked segment position.
- * @param {Object} requests
+ * @param {Object} requests - Every requests pending, in a chronological
+ * order in terms of segment time.
  * @param {number} position
  * @returns {Array.<Object>}
  */
 function getConcernedRequests(requests, neededPosition) {
     /** Index of the request for the next needed segment, in `requests`. */
-    var nextSegmentIndex = arrayFindIndex(requests, function (request) {
-        if (request.duration <= 0) {
-            return false;
+    var nextSegmentIndex = -1;
+    for (var i = 0; i < requests.length; i++) {
+        var segment = requests[i].content.segment;
+        if (segment.duration <= 0) {
+            continue;
         }
-        var segmentEnd = request.time + request.duration;
-        return segmentEnd > neededPosition &&
-            neededPosition - request.time > -1.2;
-    });
+        var segmentEnd = segment.time + segment.duration;
+        if (!segment.complete) {
+            if (i === requests.length - 1 && neededPosition - segment.time > -1.2) {
+                nextSegmentIndex = i;
+                break;
+            }
+        }
+        if (segmentEnd > neededPosition && neededPosition - segment.time > -1.2) {
+            nextSegmentIndex = i;
+            break;
+        }
+    }
     if (nextSegmentIndex < 0) { // Not found
         return [];
     }
     var nextRequest = requests[nextSegmentIndex];
-    var segmentTime = nextRequest.time;
+    var segmentTime = nextRequest.content.segment.time;
     var filteredRequests = [nextRequest];
     // Get the possibly multiple requests for that segment's position
     for (var i = nextSegmentIndex + 1; i < requests.length; i++) {
-        if (requests[i].time === segmentTime) {
+        if (requests[i].content.segment.time === segmentTime) {
             filteredRequests.push(requests[i]);
         }
         else {
@@ -59,7 +69,7 @@ function getConcernedRequests(requests, neededPosition) {
  * @param {Object} request
  * @returns {number|undefined}
  */
-function estimateRequestBandwidth(request) {
+export function estimateRequestBandwidth(request) {
     if (request.progress.length < 5) { // threshold from which we can consider
         // progress events reliably
         return undefined;
@@ -90,14 +100,22 @@ function estimateRemainingTime(lastProgressEvent, bandwidthEstimate) {
  * Check if the request for the most needed segment is too slow.
  * If that's the case, re-calculate the bandwidth urgently based on
  * this single request.
- * @param {Object} pendingRequests - Current pending requests.
+ * @param {Object} pendingRequests - Every requests pending, in a chronological
+ * order in terms of segment time.
  * @param {Object} playbackInfo - Information on the current playback.
  * @param {Object|null} currentRepresentation - The Representation being
  * presently being loaded.
+ * @param {boolean} lowLatencyMode - If `true`, we're playing the content as a
+ * low latency content - where requests might be pending when the segment is
+ * still encoded.
  * @param {Number} lastEstimatedBitrate - Last bitrate estimate emitted.
  * @returns {Number|undefined}
  */
-function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRepresentation, lastEstimatedBitrate) {
+function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRepresentation, lowLatencyMode, lastEstimatedBitrate) {
+    if (lowLatencyMode) {
+        // TODO Skip only for newer segments?
+        return undefined;
+    }
     var bufferGap = playbackInfo.bufferGap, speed = playbackInfo.speed, position = playbackInfo.position;
     var realBufferGap = isFinite(bufferGap) ? bufferGap :
         0;
@@ -108,7 +126,6 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
         return undefined;
     }
     var concernedRequest = concernedRequests[0];
-    var chunkDuration = concernedRequest.duration;
     var now = performance.now();
     var lastProgressEvent = concernedRequest.progress.length > 0 ?
         concernedRequest.progress[concernedRequest.progress.length - 1] :
@@ -127,6 +144,10 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
             }
         }
     }
+    if (!concernedRequest.content.segment.complete) {
+        return undefined;
+    }
+    var chunkDuration = concernedRequest.content.segment.duration;
     var requestElapsedTime = (now - concernedRequest.requestTimestamp) / 1000;
     var reasonableElapsedTime = requestElapsedTime <=
         ((chunkDuration * 1.5 + 2) / speed);
@@ -146,19 +167,25 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
  * switch immediately if a lower bitrate is more adapted.
  * Returns false if it estimates that you have time before switching to a lower
  * bitrate.
- * @param {Object} playbackInfo
+ * @param {Object} playbackInfo - Information on the current playback.
  * @param {Object} requests - Every requests pending, in a chronological
  * order in terms of segment time.
- * @param {number} abrStarvationGap - "Buffer gap" from which we enter a
- * "starvation mode".
+ * @param {boolean} lowLatencyMode - If `true`, we're playing the content as a
+ * low latency content, as close to the live edge as possible.
  * @returns {boolean}
  */
-function shouldDirectlySwitchToLowBitrate(playbackInfo, requests) {
+function shouldDirectlySwitchToLowBitrate(playbackInfo, requests, lowLatencyMode) {
+    if (lowLatencyMode) {
+        // TODO only when playing close to the live edge?
+        return true;
+    }
     var realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap :
         0;
     var nextNeededPosition = playbackInfo.position + realBufferGap;
-    var nextRequest = arrayFind(requests, function (r) {
-        return r.duration > 0 && (r.time + r.duration) > nextNeededPosition;
+    var nextRequest = arrayFind(requests, function (_a) {
+        var content = _a.content;
+        return content.segment.duration > 0 &&
+            (content.segment.time + content.segment.duration) > nextNeededPosition;
     });
     if (nextRequest === undefined) {
         return true;
@@ -189,6 +216,7 @@ var NetworkAnalyzer = /** @class */ (function () {
     function NetworkAnalyzer(initialBitrate, lowLatencyMode) {
         this._initialBitrate = initialBitrate;
         this._inStarvationMode = false;
+        this._lowLatencyMode = lowLatencyMode;
         if (lowLatencyMode) {
             this._config = { starvationGap: ABR_STARVATION_GAP.LOW_LATENCY,
                 outOfStarvationGap: OUT_OF_STARVATION_GAP.LOW_LATENCY,
@@ -206,11 +234,16 @@ var NetworkAnalyzer = /** @class */ (function () {
      * Gives an estimate of the current bandwidth and of the bitrate that should
      * be considered for chosing a `representation`.
      * This estimate is only based on network metrics.
-     * @param {Object} playbackInfo - Gives current information about playback
-     * @param {Object} bandwidthEstimator
-     * @param {Object|null} currentRepresentation
-     * @param {Array.<Object>} currentRequests
-     * @param {number|undefined} lastEstimatedBitrate
+     * @param {Object} playbackInfo - Gives current information about playback.
+     * @param {Object} bandwidthEstimator - `BandwidthEstimator` allowing to
+     * produce network bandwidth estimates.
+     * @param {Object|null} currentRepresentation - The Representation currently
+     * chosen.
+     * `null` if no Representation has been chosen yet.
+     * @param {Array.<Object>} currentRequests - All segment requests by segment's
+     * start chronological order
+     * @param {number|undefined} lastEstimatedBitrate - Bitrate emitted during the
+     * last estimate.
      * @returns {Object}
      */
     NetworkAnalyzer.prototype.getBandwidthEstimate = function (playbackInfo, bandwidthEstimator, currentRepresentation, currentRequests, lastEstimatedBitrate) {
@@ -241,7 +274,7 @@ var NetworkAnalyzer = /** @class */ (function () {
         // from the last requests.
         // If so, cancel previous estimates and replace it by the new one
         if (this._inStarvationMode) {
-            bandwidthEstimate = estimateStarvationModeBitrate(currentRequests, playbackInfo, currentRepresentation, lastEstimatedBitrate);
+            bandwidthEstimate = estimateStarvationModeBitrate(currentRequests, playbackInfo, currentRepresentation, this._lowLatencyMode, lastEstimatedBitrate);
             if (bandwidthEstimate != null) {
                 log.info("ABR: starvation mode emergency estimate:", bandwidthEstimate);
                 bandwidthEstimator.reset();
@@ -274,8 +307,12 @@ var NetworkAnalyzer = /** @class */ (function () {
     };
     /**
      * For a given wanted bitrate, tells if should switch urgently.
-     * @param {number} bitrate
-     * @param {Object} playbackInfo
+     * @param {number} bitrate - The new estimated bitrate.
+     * @param {Object|null} currentRepresentation - The Representation being
+     * presently being loaded.
+     * @param {Array.<Object>} currentRequests - All segment requests by segment's
+     * start chronological order
+     * @param {Object} playbackInfo - Information on the current playback.
      * @returns {boolean}
      */
     NetworkAnalyzer.prototype.isUrgent = function (bitrate, currentRepresentation, currentRequests, playbackInfo) {
@@ -288,7 +325,7 @@ var NetworkAnalyzer = /** @class */ (function () {
         else if (bitrate > currentRepresentation.bitrate) {
             return !this._inStarvationMode;
         }
-        return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests);
+        return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests, this._lowLatencyMode);
     };
     return NetworkAnalyzer;
 }());

package/dist/_esm5.processed/core/abr/pending_requests_store.d.ts

@@ -13,32 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export interface IProgressEventValue {
-    duration: number;
-    id: string | number;
-    size: number;
-    timestamp: number;
-    totalSize: number;
-}
-export interface IBeginRequestValue {
-    id: string | number;
-    time: number;
-    duration: number;
-    requestTimestamp: number;
-}
-export interface IRequestInfo {
-    duration: number;
-    progress: IProgressEventValue[];
-    requestTimestamp: number;
-    time: number;
-}
-export interface IProgressEventValue {
-    duration: number;
-    id: string | number;
-    size: number;
-    timestamp: number;
-    totalSize: number;
-}
+import Manifest, { Adaptation, ISegment, Period, Representation } from "../../manifest";
 /**
  * Store information about pending requests, like information about:
  *   - for which segments they are
@@ -53,12 +28,12 @@ export default class PendingRequestsStore {
      * @param {string} id
      * @param {Object} payload
      */
-    add(payload: IBeginRequestValue): void;
+    add(payload: IPendingRequestStoreBegin): void;
     /**
      * Notify of the progress of a currently pending request.
      * @param {Object} progress
      */
-    addProgress(progress: IProgressEventValue): void;
+    addProgress(progress: IPendingRequestStoreProgress): void;
     /**
      * Remove a request previously set as pending.
      * @param {string} id
@@ -71,3 +46,56 @@ export default class PendingRequestsStore {
      */
     getRequests(): IRequestInfo[];
 }
+/**
+ * Payload needed to add progress information for a request to the
+ * PendingRequestsStore.
+ */
+export interface IPendingRequestStoreProgress {
+    /** Amount of time since the request has started, in seconds. */
+    duration: number;
+    /**
+     * Same `id` value used to identify that request at the time the corresponding
+     * `IABRRequestBeginEventValue` was sent.
+     */
+    id: string;
+    /** Current downloaded size, in bytes. */
+    size: number;
+    /** Value of `performance.now` at the time this progression report was available. */
+    timestamp: number;
+    /**
+     * Total size of the segment to download (including already-loaded data),
+     * in bytes.
+     */
+    totalSize: number;
+}
+/** Payload needed to add a request to the PendingRequestsStore. */
+export interface IPendingRequestStoreBegin {
+    /**
+     * String identifying this request.
+     *
+     * Only one request communicated to the current `RepresentationEstimator`
+     * should have this `id` at the same time.
+     */
+    id: string;
+    /** Value of `performance.now` at the time the request began.  */
+    requestTimestamp: number;
+    /** Context associated to the segment. */
+    content: IRequestInfoContent;
+}
+/** Information linked to a segment request, stored in the PendingRequestsStore. */
+export interface IRequestInfo {
+    /** Information on the current progress made by this request. */
+    progress: IPendingRequestStoreProgress[];
+    /** `Performance.now()` corresponding to the time at which the request began. */
+    requestTimestamp: number;
+    /** Context associated to the segment. */
+    content: IRequestInfoContent;
+}
+/** Content linked to a segment request. */
+export interface IRequestInfoContent {
+    manifest: Manifest;
+    period: Period;
+    adaptation: Adaptation;
+    representation: Representation;
+    segment: ISegment;
+}

package/dist/_esm5.processed/core/abr/pending_requests_store.js

@@ -31,11 +31,8 @@ var PendingRequestsStore = /** @class */ (function () {
      * @param {Object} payload
      */
     PendingRequestsStore.prototype.add = function (payload) {
-        var id = payload.id, time = payload.time, duration = payload.duration, requestTimestamp = payload.requestTimestamp;
-        this._currentRequests[id] = { time: time,
-            duration: duration,
-            requestTimestamp: requestTimestamp,
-            progress: [] };
+        var id = payload.id, requestTimestamp = payload.requestTimestamp, content = payload.content;
+        this._currentRequests[id] = { requestTimestamp: requestTimestamp, progress: [], content: content };
     };
     /**
      * Notify of the progress of a currently pending request.
@@ -44,7 +41,7 @@ var PendingRequestsStore = /** @class */ (function () {
     PendingRequestsStore.prototype.addProgress = function (progress) {
         var request = this._currentRequests[progress.id];
         if (request == null) {
-            if (false) {
+            if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
                 throw new Error("ABR: progress for a request not added");
             }
             log.warn("ABR: progress for a request not added");
@@ -58,7 +55,7 @@ var PendingRequestsStore = /** @class */ (function () {
      */
     PendingRequestsStore.prototype.remove = function (id) {
         if (this._currentRequests[id] == null) {
-            if (false) {
+            if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
                 throw new Error("ABR: can't remove unknown request");
             }
             log.warn("ABR: can't remove unknown request");
@@ -73,7 +70,7 @@ var PendingRequestsStore = /** @class */ (function () {
     PendingRequestsStore.prototype.getRequests = function () {
         return objectValues(this._currentRequests)
             .filter(function (x) { return x != null; })
-            .sort(function (reqA, reqB) { return reqA.time - reqB.time; });
+            .sort(function (reqA, reqB) { return reqA.content.segment.time - reqB.content.segment.time; });
     };
     return PendingRequestsStore;
 }());

package/dist/_esm5.processed/core/abr/representation_estimator.d.ts

@@ -16,6 +16,7 @@
 import { Observable } from "rxjs";
 import { Adaptation, ISegment, Representation } from "../../manifest";
 import BandwidthEstimator from "./bandwidth_estimator";
+import { IPendingRequestStoreBegin, IPendingRequestStoreProgress } from "./pending_requests_store";
 /**
  * Adaptive BitRate estimate object.
  *
@@ -78,16 +79,19 @@ export interface IABREstimate {
      * have, you will most likely only want to do it when the Representation is
      * known to be maintaninable.
      */
-    knownStableBitrate?: number;
+    knownStableBitrate?: number | undefined;
 }
-/** Properties the `RepresentationEstimator` will need at each "clock tick". */
-export interface IRepresentationEstimatorClockTick {
+/** Media properties the `RepresentationEstimator` will need to keep track of. */
+export interface IRepresentationEstimatorPlaybackObservation {
     /**
      * For the concerned media buffer, difference in seconds between the next
      * position where no segment data is available and the current position.
      */
     bufferGap: number;
-    /** The position, in seconds, the media element was in at the time of the tick. */
+    /**
+     * The position, in seconds, the media element was in at the time of the
+     * observation.
+     */
     position: number;
     /**
      * Last "playback rate" set by the user. This is the ideal "playback rate" at
@@ -96,13 +100,21 @@ export interface IRepresentationEstimatorClockTick {
     speed: number;
     /** `duration` property of the HTMLMediaElement on which the content plays. */
     duration: number;
+    /**
+     * For live contents only, difference between the maximum playable position
+     * and the current position.
+     * `undefined` for non-live contents.
+     */
+    liveGap: number | undefined;
 }
 /** Content of the `IABRMetricsEvent` event's payload. */
-interface IABRMetricsEventValue {
+export interface IABRMetricsEventValue {
     /** Time the request took to perform the request, in milliseconds. */
-    duration: number;
+    requestDuration: number;
     /** Amount of bytes downloaded with this request. */
     size: number;
+    /** Duration of the loaded segment, in seconds. */
+    segmentDuration: number | undefined;
     /** Context about the segment downloaded. */
     content: {
         representation: Representation;
@@ -141,24 +153,7 @@ export interface IABRRepresentationChangeEvent {
  */
 export interface IABRRequestBeginEvent {
     type: "requestBegin";
-    value: {
-        /**
-         * String identifying this request.
-         *
-         * Only one request communicated to the current `RepresentationEstimator`
-         * should have this `id` at the same time.
-         */
-        id: string;
-        /** Presentation time at which the corresponding segment begins, in seconds. */
-        time: number;
-        /**
-         * Difference between the presentation end time and start time of the
-         * corresponding segment, in seconds.
-         */
-        duration: number;
-        /** Value of `performance.now` at the time the request began.  */
-        requestTimestamp: number;
-    };
+    value: IABRRequestBeginEventValue;
 }
 /**
  * Event emitted when progression information is available on a segment request.
@@ -168,24 +163,7 @@ export interface IABRRequestBeginEvent {
  */
 export interface IABRRequestProgressEvent {
     type: "progress";
-    value: {
-        /** Amount of time since the request has started, in seconds. */
-        duration: number;
-        /**
-         * Same `id` value used to identify that request at the time the corresponding
-         * `IABRRequestBeginEvent` event was sent.
-         */
-        id: string;
-        /** Current downloaded size, in bytes. */
-        size: number;
-        /** Value of `performance.now` at the time this progression report was available. */
-        timestamp: number;
-        /**
-         * Total size of the segment to download (including already-loaded data),
-         * in bytes.
-         */
-        totalSize: number;
-    };
+    value: IABRRequestProgressEventValue;
 }
 /**
  * Event emitted when a segment request ends.
@@ -195,13 +173,19 @@ export interface IABRRequestProgressEvent {
  */
 export interface IABRRequestEndEvent {
     type: "requestEnd";
-    value: {
-        /**
-         * Same `id` value used to identify that request at the time the corresponding
-         * `IABRRequestBeginEvent` event was sent.
-         */
-        id: string;
-    };
+    value: IABRRequestEndEventValue;
+}
+/** Value associated with a `IABRRequestBeginEvent`. */
+export declare type IABRRequestBeginEventValue = IPendingRequestStoreBegin;
+/** Value associated with a `IABRRequestProgressEvent`. */
+export declare type IABRRequestProgressEventValue = IPendingRequestStoreProgress;
+/** Value associated with a `IABRRequestEndEvent`. */
+export interface IABRRequestEndEventValue {
+    /**
+     * Same `id` value used to identify that request at the time the corresponding
+     * `IABRRequestBeginEvent` event was sent.
+     */
+    id: string;
 }
 /** Object allowing to filter some Representations out based on different attributes. */
 export interface IABRFiltersObject {
@@ -257,7 +241,7 @@ export interface IRepresentationEstimatorArguments {
     /** Events indicating current playback and network conditions. */
     streamEvents$: Observable<IABRStreamEvents>;
     /** Observable emitting regularly the current playback situation. */
-    clock$: Observable<IRepresentationEstimatorClockTick>;
+    observation$: Observable<IRepresentationEstimatorPlaybackObservation>;
     /** Observable allows to filter out Representation in our estimations. */
     filters$: Observable<IABRFiltersObject>;
     /**
@@ -333,5 +317,4 @@ export interface IRepresentationEstimatorArguments {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function RepresentationEstimator({ bandwidthEstimator, clock$, filters$, initialBitrate, lowLatencyMode, manualBitrate$, minAutoBitrate$, maxAutoBitrate$, representations, streamEvents$, }: IRepresentationEstimatorArguments): Observable<IABREstimate>;
-export {};
+export default function RepresentationEstimator({ bandwidthEstimator, observation$, filters$, initialBitrate, lowLatencyMode, manualBitrate$, minAutoBitrate$, maxAutoBitrate$, representations, streamEvents$, }: IRepresentationEstimatorArguments): Observable<IABREstimate>;