rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -13,25 +13,47 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable, Subject } from "rxjs";
-import { ISegmentParserInitSegment, ISegmentParserSegment, ITransportPipelines } from "../../../transports";
-import { IABRMetricsEvent, IABRRequestBeginEvent, IABRRequestEndEvent, IABRRequestProgressEvent } from "../../abr";
+import { Observable } from "rxjs";
+import { ICustomError } from "../../../errors";
+import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ISegmentPipeline } from "../../../transports";
+import { IABRMetricsEventValue, IABRRequestBeginEventValue, IABRRequestEndEventValue, IABRRequestProgressEventValue } from "../../abr";
 import { IBufferType } from "../../segment_buffers";
-import { IBackoffOptions } from "../utils/try_urls_with_backoff";
-import { ISegmentLoaderContent, ISegmentLoaderWarning } from "./create_segment_loader";
 /**
- * Event sent when the segment request needs to be renewed (e.g. due to an HTTP
- * error).
+ * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
+ * segments.
+ * An `ISegmentFetcher` also implements a retry mechanism, based on the given
+ * `options` argument, which may retry a segment request when it fails.
+ *
+ * @param {string} bufferType
+ * @param {Object} transport
+ * @param {Object} callbacks
+ * @param {Object} options
+ * @returns {Function}
  */
-export declare type ISegmentFetcherWarning = ISegmentLoaderWarning;
+export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, callbacks: ISegmentFetcherCreatorCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
+export declare type ISegmentFetcher<TSegmentDataType> = (content: ISegmentLoaderContent) => Observable<ISegmentFetcherEvent<TSegmentDataType>>;
+/** Event sent by the SegmentFetcher when fetching a segment. */
+export declare type ISegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherChunkEvent<TSegmentDataType> | ISegmentFetcherChunkCompleteEvent | ISegmentFetcherRetry;
 /**
  * Event sent when a new "chunk" of the segment is available.
  * A segment can contain n chunk(s) for n >= 0.
  */
-export interface ISegmentFetcherChunkEvent<T> {
+export interface ISegmentFetcherChunkEvent<TSegmentDataType> {
     type: "chunk";
     /** Parse the downloaded chunk. */
-    parse: (initTimescale?: number) => Observable<ISegmentParserInitSegment<T> | ISegmentParserSegment<T>>;
+    /**
+     * Parse the downloaded chunk.
+     *
+     * Take in argument the timescale value that might have been obtained by
+     * parsing an initialization segment from the same Representation.
+     * Can be left to `undefined` if unknown or inexistant, segment parsers should
+     * be resilient and still work without that information.
+     *
+     * @param {number} initTimescale
+     * @returns {Object}
+     */
+    parse(initTimescale?: number): ISegmentParserParsedInitChunk<TSegmentDataType> | ISegmentParserParsedMediaChunk<TSegmentDataType>;
 }
 /**
  * Event sent when all "chunk" of the segments have been communicated through
@@ -40,15 +62,75 @@ export interface ISegmentFetcherChunkEvent<T> {
 export interface ISegmentFetcherChunkCompleteEvent {
     type: "chunk-complete";
 }
-/** Event sent by the SegmentFetcher when fetching a segment. */
-export declare type ISegmentFetcherEvent<T> = ISegmentFetcherChunkCompleteEvent | ISegmentFetcherChunkEvent<T> | ISegmentFetcherWarning;
-export declare type ISegmentFetcher<T> = (content: ISegmentLoaderContent) => Observable<ISegmentFetcherEvent<T>>;
+/** Content used by the segment loader as a context to load a new segment. */
+export interface ISegmentLoaderContent {
+    manifest: Manifest;
+    period: Period;
+    adaptation: Adaptation;
+    representation: Representation;
+    segment: ISegment;
+}
+/**
+ * An Error happened while loading which led to a retry.
+ * The request is retried from scratch.
+ */
+export interface ISegmentFetcherRetry {
+    type: "retry";
+    value: ICustomError;
+}
+/**
+ * Callbacks that can be bound when creating an `ISegmentFetcher`.
+ * Those allows to be notified of an `ISegmentFetcher` various lifecycles and of
+ * network information.
+ */
+export interface ISegmentFetcherCreatorCallbacks {
+    /** Called when a segment request begins. */
+    onRequestBegin?: (arg: IABRRequestBeginEventValue) => void;
+    /** Called when progress information is available on a pending segment request. */
+    onProgress?: (arg: IABRRequestProgressEventValue) => void;
+    /**
+     * Called when a segment request ends (either because it completed, it failed
+     * or was canceled).
+     */
+    onRequestEnd?: (arg: IABRRequestEndEventValue) => void;
+    /**
+     * Called when network metrics linked to a segment request are available,
+     * once the request has terminated.
+     * This callback may be called before or after the corresponding
+     * `onRequestEnd` callback, you should not rely on the order between the two.
+     */
+    onMetrics?: (arg: IABRMetricsEventValue) => void;
+}
+/** Options allowing to configure an `ISegmentFetcher`'s behavior. */
+export interface ISegmentFetcherOptions {
+    /**
+     * Initial delay to wait if a request fails before making a new request, in
+     * milliseconds.
+     */
+    baseDelay: number;
+    /**
+     * Maximum delay to wait if a request fails before making a new request, in
+     * milliseconds.
+     */
+    maxDelay: number;
+    /**
+     * Maximum number of retries to perform on "regular" errors (e.g. due to HTTP
+     * status, integrity errors, timeouts...).
+     */
+    maxRetryRegular: number;
+    /**
+     * Maximum number of retries to perform when it appears that the user is
+     * currently offline.
+     */
+    maxRetryOffline: number;
+}
 /**
- * Create a function which will fetch and parse segments.
  * @param {string} bufferType
- * @param {Object} transport
- * @param {Subject} requests$
- * @param {Object} options
- * @returns {Function}
+ * @param {Object}
+ * @returns {Object}
  */
-export default function createSegmentFetcher<T>(bufferType: IBufferType, transport: ITransportPipelines, requests$: Subject<IABRMetricsEvent | IABRRequestBeginEvent | IABRRequestProgressEvent | IABRRequestEndEvent>, options: IBackoffOptions): ISegmentFetcher<T>;
+export declare function getSegmentFetcherOptions(bufferType: string, { maxRetryRegular, maxRetryOffline, lowLatencyMode }: {
+    maxRetryRegular?: number | undefined;
+    maxRetryOffline?: number | undefined;
+    lowLatencyMode: boolean;
+}): ISegmentFetcherOptions;

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.js

@@ -13,129 +13,269 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, of as observableOf, } from "rxjs";
-import { catchError, filter, finalize, mergeMap, share, tap, } from "rxjs/operators";
-import { formatError } from "../../../errors";
+import { Observable } from "rxjs";
+import config from "../../../config";
+import { formatError, } from "../../../errors";
+import log from "../../../log";
+import { getLoggableSegmentId, } from "../../../manifest";
 import arrayIncludes from "../../../utils/array_includes";
-import assertUnreachable from "../../../utils/assert_unreachable";
 import idGenerator from "../../../utils/id_generator";
 import InitializationSegmentCache from "../../../utils/initialization_segment_cache";
-import createSegmentLoader from "./create_segment_loader";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import objectAssign from "../../../utils/object_assign";
+import TaskCanceller from "../../../utils/task_canceller";
+import errorSelector from "../utils/error_selector";
+import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
+var DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = config.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = config.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = config.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = config.MAX_BACKOFF_DELAY_BASE;
 var generateRequestID = idGenerator();
 /**
- * Create a function which will fetch and parse segments.
+ * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
+ * segments.
+ * An `ISegmentFetcher` also implements a retry mechanism, based on the given
+ * `options` argument, which may retry a segment request when it fails.
+ *
  * @param {string} bufferType
  * @param {Object} transport
- * @param {Subject} requests$
+ * @param {Object} callbacks
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher(bufferType, transport, requests$, options) {
+export default function createSegmentFetcher(bufferType, pipeline, callbacks, options) {
+    /**
+     * Cache audio and video initialization segments.
+     * This allows to avoid doing too many requests for what are usually very
+     * small files.
+     */
     var cache = arrayIncludes(["audio", "video"], bufferType) ?
         new InitializationSegmentCache() :
         undefined;
-    var segmentLoader = createSegmentLoader(transport[bufferType].loader, cache, options);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    var segmentParser = transport[bufferType].parser; // deal with it
+    var loadSegment = pipeline.loadSegment, parseSegment = pipeline.parseSegment;
     /**
-     * Process the segmentLoader observable to adapt it to the the rest of the
-     * code:
-     *   - use the requests subject for network requests and their progress
-     *   - use the warning$ subject for retries' error messages
-     *   - only emit the data
+     * Fetch a specific segment.
+     *
+     * This function returns an Observable which will fetch segments on
+     * subscription.
+     * If the corresponding request fails, it may retry it based on the given
+     * options.
+     *
+     * This Observable will emit various events during that request lifecycle and
+     * throw if the segment request(s) (including potential retries) fail.
+     * The Observable will automatically complete once no events are left to be
+     * sent.
      * @param {Object} content
      * @returns {Observable}
      */
     return function fetchSegment(content) {
-        var id = generateRequestID();
-        var requestBeginSent = false;
-        return segmentLoader(content).pipe(tap(function (arg) {
-            switch (arg.type) {
-                case "metrics": {
-                    requests$.next(arg);
-                    break;
-                }
-                case "request": {
-                    var value = arg.value;
-                    // format it for ABR Handling
-                    var segment = value.segment;
-                    if (segment === undefined) {
-                        return;
+        var segment = content.segment;
+        // used by logs
+        var segmentIdString = getLoggableSegmentId(content);
+        return new Observable(function (obs) {
+            var _a, _b;
+            var requestId = generateRequestID();
+            var canceller = new TaskCanceller();
+            /**
+             * If the request succeeded, set to the corresponding
+             * `IChunkCompleteInformation` object.
+             * For any other completion cases: if the request either failed, was
+             * cancelled or just if no request was needed, set to `null`.
+             *
+             * Stays to `undefined` when the request is still pending.
+             */
+            var requestInfo;
+            /**
+             * Array containing one entry per loaded chunk, in chronological order.
+             * The boolean indicates if the chunk has been parsed at least once.
+             *
+             * This is used to know when all loaded chunks have been parsed, which
+             * can be useful to e.g. construct metrics about the loaded segment.
+             */
+            var parsedChunks = [];
+            /**
+             * Addition of the duration of each encountered and parsed chunks.
+             * Allows to have an idea of the real duration of the full segment once
+             * all chunks have been parsed.
+             *
+             * `undefined` if at least one of the parsed chunks has unknown duration.
+             */
+            var segmentDurationAcc = 0;
+            /** Set to `true` once network metrics have been sent. */
+            var metricsSent = false;
+            var loaderCallbacks = {
+                /**
+                 * Callback called when the segment loader has progress information on
+                 * the request.
+                 * @param {Object} info
+                 */
+                onProgress: function (info) {
+                    var _a;
+                    if (info.totalSize !== undefined && info.size < info.totalSize) {
+                        (_a = callbacks.onProgress) === null || _a === void 0 ? void 0 : _a.call(callbacks, { duration: info.duration,
+                            size: info.size,
+                            totalSize: info.totalSize,
+                            timestamp: performance.now(),
+                            id: requestId });
                     }
-                    requestBeginSent = true;
-                    requests$.next({ type: "requestBegin",
-                        value: { duration: segment.duration,
-                            time: segment.time,
-                            requestTimestamp: performance.now(),
-                            id: id } });
-                    break;
-                }
-                case "progress": {
-                    var value = arg.value;
-                    if (value.totalSize != null && value.size < value.totalSize) {
-                        requests$.next({ type: "progress",
-                            value: { duration: value.duration,
-                                size: value.size,
-                                totalSize: value.totalSize,
-                                timestamp: performance.now(),
-                                id: id } });
+                },
+                /**
+                 * Callback called when the segment is communicated by the loader
+                 * through decodable sub-segment(s) called chunk(s), with a chunk in
+                 * argument.
+                 * @param {*} chunkData
+                 */
+                onNewChunk: function (chunkData) {
+                    obs.next({ type: "chunk",
+                        parse: generateParserFunction(chunkData, true) });
+                },
+            };
+            // Retrieve from cache if it exists
+            var cached = cache !== undefined ? cache.get(content) :
+                null;
+            if (cached !== null) {
+                log.debug("SF: Found wanted segment in cache", segmentIdString);
+                obs.next({ type: "chunk",
+                    parse: generateParserFunction(cached, false) });
+                obs.next({ type: "chunk-complete" });
+                obs.complete();
+                return undefined;
+            }
+            log.debug("SF: Beginning request", segmentIdString);
+            (_a = callbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(callbacks, { requestTimestamp: performance.now(),
+                id: requestId, content: content });
+            tryURLsWithBackoff((_b = segment.mediaURLs) !== null && _b !== void 0 ? _b : [null], callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), canceller.signal)
+                .then(function (res) {
+                var _a;
+                log.debug("SF: Segment request ended with success", segmentIdString);
+                if (res.resultType === "segment-loaded") {
+                    var loadedData = res.resultData.responseData;
+                    if (cache !== undefined) {
+                        cache.add(content, res.resultData.responseData);
                     }
-                    break;
+                    obs.next({ type: "chunk",
+                        parse: generateParserFunction(loadedData, false) });
                 }
+                else if (res.resultType === "segment-created") {
+                    obs.next({ type: "chunk",
+                        parse: generateParserFunction(res.resultData, false) });
+                }
+                log.debug("SF: Segment request ended with success", segmentIdString);
+                obs.next({ type: "chunk-complete" });
+                if (res.resultType !== "segment-created") {
+                    requestInfo = res.resultData;
+                    sendNetworkMetricsIfAvailable();
+                }
+                else {
+                    requestInfo = null;
+                }
+                if (!canceller.isUsed) {
+                    // The current Observable could have been canceled as a result of one
+                    // of the previous `next` calls. In that case, we don't want to send
+                    // a "requestEnd" again as it has already been sent on cancellation.
+                    //
+                    // Note that we only perform this check for `onRequestEnd` on
+                    // purpose. Observable's events should have been ignored by RxJS if
+                    // the Observable has already been canceled and we don't care if
+                    // `"metrics"` is sent there.
+                    (_a = callbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(callbacks, { id: requestId });
+                }
+                obs.complete();
+            })
+                .catch(function (err) {
+                log.debug("SF: Segment request failed", segmentIdString);
+                requestInfo = null;
+                obs.error(errorSelector(err));
+            });
+            return function () {
+                var _a;
+                if (requestInfo !== undefined) {
+                    return; // Request already terminated
+                }
+                log.debug("SF: Segment request cancelled", segmentIdString);
+                requestInfo = null;
+                canceller.cancel();
+                (_a = callbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(callbacks, { id: requestId });
+            };
+            /**
+             * Call a segment loader for the given URL with the right arguments.
+             * @param {string|null} url
+             * @param {Object} cancellationSignal
+             * @returns {Promise}
+             */
+            function callLoaderWithUrl(url, cancellationSignal) {
+                return loadSegment(url, content, cancellationSignal, loaderCallbacks);
             }
-        }), finalize(function () {
-            if (requestBeginSent) {
-                requests$.next({ type: "requestEnd", value: { id: id } });
-            }
-        }), filter(function (e) {
-            switch (e.type) {
-                case "warning":
-                case "chunk":
-                case "chunk-complete":
-                case "data":
-                    return true;
-                case "progress":
-                case "metrics":
-                case "request":
-                    return false;
-                default:
-                    assertUnreachable(e);
-            }
-        }), mergeMap(function (evt) {
-            if (evt.type === "warning") {
-                return observableOf(evt);
-            }
-            if (evt.type === "chunk-complete") {
-                return observableOf({ type: "chunk-complete" });
-            }
-            var isChunked = evt.type === "chunk";
-            var data = {
-                type: "chunk",
-                /**
-                 * Parse the loaded data.
-                 * @param {Object} [initTimescale]
-                 * @returns {Observable}
-                 */
-                parse: function (initTimescale) {
-                    var response = { data: evt.value.responseData, isChunked: isChunked };
-                    /* eslint-disable @typescript-eslint/no-unsafe-call */
-                    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-                    /* eslint-disable @typescript-eslint/no-unsafe-return */
-                    return segmentParser({ response: response, initTimescale: initTimescale, content: content })
-                        /* eslint-enable @typescript-eslint/no-unsafe-call */
-                        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-                        /* eslint-enable @typescript-eslint/no-unsafe-return */
-                        .pipe(catchError(function (error) {
+            /**
+             * Generate function allowing to parse a loaded segment.
+             * @param {*} data
+             * @param {Boolean} isChunked
+             * @returns {Function}
+             */
+            function generateParserFunction(data, isChunked) {
+                parsedChunks.push(false);
+                var parsedChunkId = parsedChunks.length - 1;
+                return function parse(initTimescale) {
+                    var loaded = { data: data, isChunked: isChunked };
+                    try {
+                        var parsed = parseSegment(loaded, content, initTimescale);
+                        if (!parsedChunks[parsedChunkId]) {
+                            segmentDurationAcc = segmentDurationAcc !== undefined &&
+                                parsed.segmentType === "media" &&
+                                parsed.chunkInfos !== null &&
+                                parsed.chunkInfos.duration !== undefined ?
+                                segmentDurationAcc + parsed.chunkInfos.duration :
+                                undefined;
+                            parsedChunks[parsedChunkId] = true;
+                            sendNetworkMetricsIfAvailable();
+                        }
+                        return parsed;
+                    }
+                    catch (error) {
                         throw formatError(error, { defaultCode: "PIPELINE_PARSE_ERROR",
                             defaultReason: "Unknown parsing error" });
-                    }));
-                },
-            };
-            if (isChunked) {
-                return observableOf(data);
+                    }
+                };
+            }
+            /**
+             * Function called when the function request is retried.
+             * @param {*} err
+             */
+            function onRetry(err) {
+                obs.next({ type: "retry",
+                    value: errorSelector(err) });
+            }
+            /**
+             * Send netork metrics if they haven't yet been sent and if all data to
+             * define them is available.
+             */
+            function sendNetworkMetricsIfAvailable() {
+                var _a;
+                if (metricsSent) {
+                    return;
+                }
+                if (!isNullOrUndefined(requestInfo) &&
+                    requestInfo.size !== undefined &&
+                    requestInfo.requestDuration !== undefined &&
+                    parsedChunks.length > 0 &&
+                    parsedChunks.every(function (isParsed) { return isParsed; })) {
+                    metricsSent = true;
+                    (_a = callbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(callbacks, { size: requestInfo.size,
+                        requestDuration: requestInfo.requestDuration, content: content, segmentDuration: segmentDurationAcc });
+                }
             }
-            return observableConcat(observableOf(data), observableOf({ type: "chunk-complete" }));
-        }), share() // avoid multiple side effects if multiple subs
-        );
+        });
     };
 }
+/**
+ * @param {string} bufferType
+ * @param {Object}
+ * @returns {Object}
+ */
+export function getSegmentFetcherOptions(bufferType, _a) {
+    var maxRetryRegular = _a.maxRetryRegular, maxRetryOffline = _a.maxRetryOffline, lowLatencyMode = _a.lowLatencyMode;
+    return { maxRetryRegular: bufferType === "image" ? 0 :
+            maxRetryRegular !== null && maxRetryRegular !== void 0 ? maxRetryRegular : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
+        maxRetryOffline: maxRetryOffline !== null && maxRetryOffline !== void 0 ? maxRetryOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE,
+        baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
+            INITIAL_BACKOFF_DELAY_BASE.REGULAR,
+        maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
+            MAX_BACKOFF_DELAY_BASE.REGULAR };
+}

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.d.ts

@@ -13,23 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Subject } from "rxjs";
 import { ITransportPipelines } from "../../../transports";
-import { IABRMetricsEvent, IABRRequestBeginEvent, IABRRequestEndEvent, IABRRequestProgressEvent } from "../../abr";
 import { IBufferType } from "../../segment_buffers";
 import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
-/** Options used by the `SegmentFetcherCreator`. */
-export interface ISegmentFetcherCreatorBackoffOptions {
-    /**
-     * Whether the content is played in a low-latency mode.
-     * This has an impact on default backoff delays.
-     */
-    lowLatencyMode: boolean;
-    /** Maximum number of time a request on error will be retried. */
-    maxRetryRegular: number | undefined;
-    /** Maximum number of time a request be retried when the user is offline. */
-    maxRetryOffline: number | undefined;
-}
+import { ISegmentFetcherCreatorCallbacks } from "./segment_fetcher";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
@@ -38,12 +25,15 @@ export interface ISegmentFetcherCreatorBackoffOptions {
  *
  * @example
  * ```js
- * const creator = new SegmentFetcherCreator(transport);
+ * const creator = new SegmentFetcherCreator(transport, {
+ *   lowLatencyMode: false,
+ *   maxRetryRegular: Infinity,
+ *   maxRetryOffline: Infinity,
+ * });
  *
  * // 2 - create a new fetcher with its backoff options
  * const fetcher = creator.createSegmentFetcher("audio", {
- *   maxRetryRegular: Infinity,
- *   maxRetryOffline: Infinity,
+ *   // ... (lifecycle callbacks if wanted)
  * });
  *
  * // 3 - load a segment with a given priority
@@ -57,9 +47,25 @@ export interface ISegmentFetcherCreatorBackoffOptions {
  *   .subscribe((res) => console.log("audio chunk downloaded:", res));
  * ```
  */
-export default class SegmentFetcherCreator<T> {
+export default class SegmentFetcherCreator {
+    /**
+     * Transport pipelines of the currently choosen streaming protocol (e.g. DASH,
+     * Smooth etc.).
+     */
     private readonly _transport;
+    /**
+     * `ObservablePrioritizer` linked to this SegmentFetcherCreator.
+     *
+     * Note: this is typed as `any` because segment loaders / parsers can use
+     * different types depending on the type of buffer. We could maybe be smarter
+     * about it, but typing as any just in select places, like here, looks like
+     * a good compromise.
+     */
     private readonly _prioritizer;
+    /**
+     * Options used by the SegmentFetcherCreator, e.g. to allow configuration on
+     * segment retries (number of retries maximum, default delay and so on).
+     */
     private readonly _backoffOptions;
     /**
      * @param {Object} transport
@@ -69,9 +75,20 @@ export default class SegmentFetcherCreator<T> {
      * Create a segment fetcher, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
      * "video", etc.)
-     * @param {Subject} requests$ - Subject through which request-related events
-     * (such as those needed by the ABRManager) will be sent.
+     * @param {Object} callbacks
      * @returns {Object}
      */
-    createSegmentFetcher(bufferType: IBufferType, requests$: Subject<IABRRequestBeginEvent | IABRRequestProgressEvent | IABRRequestEndEvent | IABRMetricsEvent>): IPrioritizedSegmentFetcher<T>;
+    createSegmentFetcher(bufferType: IBufferType, callbacks: ISegmentFetcherCreatorCallbacks): IPrioritizedSegmentFetcher<unknown>;
+}
+/** Options used by the `SegmentFetcherCreator`. */
+export interface ISegmentFetcherCreatorBackoffOptions {
+    /**
+     * Whether the content is played in a low-latency mode.
+     * This has an impact on default backoff delays.
+     */
+    lowLatencyMode: boolean;
+    /** Maximum number of time a request on error will be retried. */
+    maxRetryRegular: number | undefined;
+    /** Maximum number of time a request be retried when the user is offline. */
+    maxRetryOffline: number | undefined;
 }

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher_creator.js

@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 import config from "../../../config";
-import getSegmentBackoffOptions from "./get_segment_backoff_options";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
 import ObservablePrioritizer from "./prioritizer";
-import createSegmentFetcher from "./segment_fetcher";
+import createSegmentFetcher, { getSegmentFetcherOptions, } from "./segment_fetcher";
 var MIN_CANCELABLE_PRIORITY = config.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = config.MAX_HIGH_PRIORITY_LEVEL;
 /**
  * Interact with the transport pipelines to download segments with the right
@@ -27,12 +26,15 @@ var MIN_CANCELABLE_PRIORITY = config.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_
  *
  * @example
  * ```js
- * const creator = new SegmentFetcherCreator(transport);
+ * const creator = new SegmentFetcherCreator(transport, {
+ *   lowLatencyMode: false,
+ *   maxRetryRegular: Infinity,
+ *   maxRetryOffline: Infinity,
+ * });
  *
  * // 2 - create a new fetcher with its backoff options
  * const fetcher = creator.createSegmentFetcher("audio", {
- *   maxRetryRegular: Infinity,
- *   maxRetryOffline: Infinity,
+ *   // ... (lifecycle callbacks if wanted)
  * });
  *
  * // 3 - load a segment with a given priority
@@ -62,13 +64,14 @@ var SegmentFetcherCreator = /** @class */ (function () {
      * Create a segment fetcher, allowing to easily perform segment requests.
      * @param {string} bufferType - The type of buffer concerned (e.g. "audio",
      * "video", etc.)
-     * @param {Subject} requests$ - Subject through which request-related events
-     * (such as those needed by the ABRManager) will be sent.
+     * @param {Object} callbacks
      * @returns {Object}
      */
-    SegmentFetcherCreator.prototype.createSegmentFetcher = function (bufferType, requests$) {
-        var backoffOptions = getSegmentBackoffOptions(bufferType, this._backoffOptions);
-        var segmentFetcher = createSegmentFetcher(bufferType, this._transport, requests$, backoffOptions);
+    SegmentFetcherCreator.prototype.createSegmentFetcher = function (bufferType, callbacks) {
+        var backoffOptions = getSegmentFetcherOptions(bufferType, this._backoffOptions);
+        var pipelines = this._transport[bufferType];
+        // Types are very complicated here as they are per-type of buffer.
+        var segmentFetcher = createSegmentFetcher(bufferType, pipelines, callbacks, backoffOptions);
         return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
     };
     return SegmentFetcherCreator;