rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/transports/types.ts

@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
-import {
-  Observable,
-} from "rxjs";
 import { IInbandEvent } from "../core/stream";
 import Manifest, {
   Adaptation,
+  IExposedAdaptation,
+  IExposedManifest,
+  IExposedPeriod,
+  IExposedRepresentation,
+  IExposedSegment,
   IRepresentationFilter,
   ISegment,
   ISupplementaryImageTrack,
@@ -30,6 +32,9 @@ import Manifest, {
 import { IBifThumbnail } from "../parsers/images/bif";
 import { ILocalManifest } from "../parsers/manifest/local";
 import { IMetaPlaylist } from "../parsers/manifest/metaplaylist";
+import TaskCanceller, {
+  CancellationSignal,
+} from "../utils/task_canceller";
 
 /**
  * Interface returned by any transport implementation.
@@ -49,395 +54,662 @@ export interface ITransportPipelines {
   /** Functions allowing to load an parse the Manifest for this transport. */
   manifest : ITransportManifestPipeline;
   /** Functions allowing to load an parse audio segments. */
-  audio : ISegmentPipeline<Uint8Array | ArrayBuffer | null,
-                           Uint8Array | ArrayBuffer | null,
+  audio : ISegmentPipeline<ILoadedAudioVideoSegmentFormat,
                            Uint8Array | ArrayBuffer | null>;
   /** Functions allowing to load an parse video segments. */
-  video : ISegmentPipeline<Uint8Array | ArrayBuffer | null,
-                           Uint8Array | ArrayBuffer | null,
+  video : ISegmentPipeline<ILoadedAudioVideoSegmentFormat,
                            Uint8Array | ArrayBuffer | null>;
   /** Functions allowing to load an parse text (e.g. subtitles) segments. */
-  text : ISegmentPipeline<Uint8Array | ArrayBuffer | string | null,
-                          null,
-                          ITextTrackSegmentData>;
+  text : ISegmentPipeline<ILoadedTextSegmentFormat,
+                          ITextTrackSegmentData | null>;
   /** Functions allowing to load an parse image (e.g. thumbnails) segments. */
-  image : ISegmentPipeline<Uint8Array | ArrayBuffer | null,
-                           null,
-                           IImageTrackSegmentData>;
+  image : ISegmentPipeline<ILoadedImageSegmentFormat,
+                           IImageTrackSegmentData | null>;
 }
 
 /** Functions allowing to load and parse the Manifest. */
-export interface ITransportManifestPipeline { resolver? : IManifestResolverFunction;
-                                              loader : IManifestLoaderFunction;
-                                              parser : IManifestParserFunction; }
-
-/**
- * @deprecated
- * "Resolves the Manifest's URL, to obtain its true URL.
- * This is a deprecated function which corresponds to an old use case at
- * Canal+ where the URL of the Manifest first need to be parsed from a .wsx
- * file.
- * Thankfully this API should not be used anymore, though to not break
- * compatibility, we have to keep it until a v4.x.x release.
- *
- * @param {Object} x - Object containing the URL used to obtain the real URL of
- * the Manifest.
- * @returns {Observable.<Object>}
- */
-export type IManifestResolverFunction =
-  (x : IManifestLoaderArguments) => Observable<IManifestLoaderArguments>;
+export interface ITransportManifestPipeline {
+  /**
+   * "Loader" of the Manifest pipeline, allowing to request a Manifest so it can
+   * later be parsed by the `parseManifest` function.
+   *
+   * @param {string|undefined} url - URL of the Manifest we want to load.
+   * `undefined` if the Manifest doesn't have an URL linked to it, in which case
+   * the Manifest should be loaded through another mean.
+   * @param {CancellationSignal} cancellationSignal - Signal which will allow to
+   * cancel the loading operation if the Manifest is not needed anymore (for
+   * example, if the content has just been stopped).
+   * When cancelled, the promise returned by this function will reject with a
+   * `CancellationError`.
+   * @returns {Promise.<Object>} - Promise emitting the loaded Manifest, that
+   * then can be parsed through the `parseManifest` function.
+   *
+   * Rejects in two cases:
+   *   - The loading operation has been cancelled through the `cancelSignal`
+   *     given in argument.
+   *     In that case, this Promise will reject with a `CancellationError`.
+   *   - The loading operation failed, most likely due to a request error.
+   *     In that case, this Promise will reject with the corresponding Error.
+   */
+  loadManifest : (
+    url : string | undefined,
+    cancelSignal : CancellationSignal,
+  ) => Promise<IRequestedData<ILoadedManifestFormat>>;
 
-/**
- * "Loader" of the Manifest pipeline, allowing to request a Manifest so it can
- * later be parsed by the `parseManifest` function.
- *
- * @param {Object} x - Object containing the URL of the Manifest we want to
- * load.
- * @returns {Observable.<Object>}
- */
-export type IManifestLoaderFunction =
-  (x : IManifestLoaderArguments) => Observable<IManifestLoaderEvent>;
+  /**
+   * "Parser" of the Manifest pipeline, allowing to parse a loaded Manifest so
+   * it can be exploited by the rest of the RxPlayer's logic.
+   *
+   * @param {Object} manifestData - Response obtained from the `loadManifest`
+   * function.
+   * @param {Object} parserOptions - Various options relative to the parsing
+   * operation.
+   * @param {Function} onWarnings - Callbacks called:
+   *   - when minor Manifest parsing errors are found
+   *   - when `scheduleRequest` rejects on requests this function can do
+   *     without.
+   * @param {CancellationSignal} cancelSignal - Cancellation signal which will
+   * allow to abort the parsing operation if you do not want the Manifest
+   * anymore.
+   *
+   * That cancellationSignal can be triggered at any time, such as:
+   *   - after a warning is received
+   *   - while a request scheduled through the `scheduleRequest` argument is
+   *     pending.
+   *
+   * `parseManifest` will interrupt all operations if the signal has been
+   * triggered in one of those scenarios, and will automatically reject with
+   * the corresponding `CancellationError` instance.
+   * @param {Function} scheduleRequest - Allows `parseManifest` to schedule
+   * network requests, for example to fetch sub-parts of the Manifest or
+   * supplementary resources we can only know of at Manifest parsing time.
+   *
+   * All requests scheduled through `scheduleRequest` should abort (and the
+   * corresponding Promise reject a `CancellationError`) when/if `cancelSignal`
+   * is triggered.
+   *
+   * If a request scheduled through `scheduleRequest` rejects with an error:
+   *   - either the error was due to a cancellation, in which case
+   *     `parseManifest` should reject the same error immediately.
+   *   - either the requested resource was mandatory to parse the Manifest
+   *     in which case `parseManifest` will reject with the same error.
+   *   - either the parser can make up for that error, in which case it will
+   *     just be emitted as a warning and `parseManifest` will continue its
+   *     operations.
+   * @returns {Object | Promise.<Object>} - Returns directly the Manifest data
+   * if the parsing can be performed synchronously or through a Promise if it
+   * needs to perform network requests first through the `scheduleRequest`
+   * function.
+   *
+   * Throws if an error happens synchronously and rejects if it happens
+   * asynchronously.
+   *
+   * If this error is due to a failed request performed through the
+   * `scheduleRequest` argument, then the rejected error should be the same one
+   * than the one rejected by `scheduleRequest`.
+   *
+   * If this error is due to a cancellation instead (indicated through the
+   * `cancelSignal` argument), then the rejected error should be the
+   * `CancellationError` instance instead.
+   */
+  parseManifest : (
+    manifestData : IRequestedData<unknown>,
+    parserOptions : IManifestParserOptions,
+    onWarnings : (warnings : Error[]) => void,
+    cancelSignal : CancellationSignal,
+    scheduleRequest : IManifestParserRequestScheduler
+  ) => IManifestParserResult |
+       Promise<IManifestParserResult>;
 
-/**
- * "Parser" of the Manifest pipeline, allowing to parse a loaded Manifest so
- * it can be exploited by the rest of the RxPlayer's logic.
- *
- * @param {Object} x
- * @returns {Observable.<Object>}
- */
-export type IManifestParserFunction = (
-  x : IManifestParserArguments
-) => Observable< IManifestParserResponseEvent |
-                 IManifestParserWarningEvent>;
+  /**
+   * @deprecated
+   * "Resolves the Manifest's URL, to obtain its true URL.
+   * This is a deprecated function which corresponds to an old use case at
+   * Canal+ where the URL of the Manifest first need to be parsed from a .wsx
+   * file.
+   * Thankfully this API should not be used anymore, though to not break
+   * compatibility, we have to keep it until a v4.x.x release.
+   *
+   * @param {string | undefined} url - URL used to obtain the real URL of the
+   * Manifest.
+   * @param {CancellationSignal} cancelSignal - Cancellation signal which will
+   * allow to abort the resolving operation if you do not want the Manifest
+   * anymore.
+   * When cancelled, the promise returned by this function will reject with a
+   * `CancellationError`.
+   * @returns {Promise.<string|undefined>} - Promise emitting the "real" URL of
+   * the Manifest, that should be loaded by the `loadManifest` function.
+   * `undefined` if the URL is either unknown or inexistant.
+   *
+   * Rejects in two cases:
+   *
+   *   1. The resolving operation has been aborted through the `cancelSignal`
+   *      given in argument.
+   *      In that case, this Promise will reject a `CancellationError`.
+   *
+   *   2. The resolving operation failed, most likely due to a request error.
+   *      In that case, this Promise will reject the corresponding Error.
+   */
+  resolveManifestUrl? : (
+    url : string | undefined,
+    cancelSignal : CancellationSignal,
+  ) => Promise<string | undefined>;
+}
 
 /** Functions allowing to load and parse segments of any type. */
 export interface ISegmentPipeline<
-  LoadedFormat,
-  ParsedInitDataFormat,
-  ParsedMediaDataFormat,
+  TLoadedFormat,
+  TParsedSegmentDataFormat,
 > {
-  loader : ISegmentLoader<LoadedFormat>;
-  parser : ISegmentParser<LoadedFormat,
-                          ParsedInitDataFormat,
-                          ParsedMediaDataFormat>;
+  loadSegment : ISegmentLoader<TLoadedFormat>;
+  parseSegment : ISegmentParser<TLoadedFormat,
+                                TParsedSegmentDataFormat>;
 }
 
 /**
  * Segment loader function, allowing to load a segment of any type.
- * @param {Object} x
- * @returns {Observable.<Object>}
+ * @param {stop|null} url - URL at which the segment should be downloaded.
+ * `null` if we do not have an URL (in which case the segment should be loaded
+ * through other means, such as information taken from the segment's content).
+ * @param {Object} content - Content linked to the wanted segment.
+ * @param {CancellationSignal} cancelSignal - Cancellation signal which will
+ * allow to cancel the loading operation if the segment is not needed anymore.
+ *
+ * When cancelled, this loader should stop any pending operation (such as an
+ * HTTP request) and the Promise returned should reject immediately with a
+ * `CancellationError`, generated through this CancellationSignal object.
+ * @param {Object} callbacks - Callbacks called on various loader events.
+ * @returns {Promise.<Object>} - Promise resolving when it has finished loading
+ * the segment.
  */
-export type ISegmentLoader<LoadedFormat> = (
-  x : ISegmentLoaderArguments
-) => Observable<ISegmentLoaderEvent<LoadedFormat>>;
+export type ISegmentLoader<TLoadedFormat> = (
+  url : string | null,
+  content : ISegmentContext,
+  cancelSignal : CancellationSignal,
+  callbacks : ISegmentLoaderCallbacks<TLoadedFormat>
+) => Promise<ISegmentLoaderResultSegmentCreated<TLoadedFormat> |
+             ISegmentLoaderResultSegmentLoaded<TLoadedFormat> |
+             ISegmentLoaderResultChunkedComplete>;
 
 /**
- * Segment parser function, allowing to parse a segment of any type.
- * @param {Object} x
- * @returns {Observable.<Object>}
+ * Segment parser function, allowing to parse a chunk (which may be a sub-part
+ * of a segment) of any type.
+ *
+ * This function will throw if it encounters any error it cannot recover from.
  */
 export type ISegmentParser<
-  LoadedFormat,
-  ParsedInitDataFormat,
-  ParsedMediaDataFormat
+  TLoadedFormat,
+  TParsedSegmentDataFormat
 > = (
-  x : ISegmentParserArguments< LoadedFormat >
-) => Observable<ISegmentParserInitSegment<ParsedInitDataFormat>  |
-                ISegmentParserSegment<ParsedMediaDataFormat>>;
-
-/** Arguments for the loader of the manifest pipeline. */
-export interface IManifestLoaderArguments {
-  /**
-   * URL of the Manifest we want to load.
-   * `undefined` if the Manifest doesn't have an URL linked to it, in which
-   *  case the Manifest should be loaded from another mean.
-   */
-  url : string | undefined;
-}
-
-/** Arguments for the loader of the segment pipelines. */
-export interface ISegmentLoaderArguments {
-  /** Manifest object related to this segment. */
-  manifest : Manifest;
-  /** Period object related to this segment. */
-  period : Period;
-  /** Adaptation object related to this segment. */
-  adaptation : Adaptation;
-  /** Representation Object related to this segment. */
-  representation : Representation;
-  /** Segment we want to load. */
-  segment : ISegment;
+  /** Attributes of the corresponding loader's response. */
+  loadedSegment : {
+    /** The loaded segment data. */
+    data : TLoadedFormat;
+    /**
+     * If `true`,`data` is only a "chunk" of the whole segment (which potentially
+     * will contain multiple chunks).
+     * If `false`, `data` is the data for the whole segment.
+     */
+    isChunked : boolean;
+  },
+  /** Context about the wanted segment. */
+  content : ISegmentContext,
   /**
-   * URL at which the segment should be downloaded.
-   * `null` if we do not have an URL (in which case the segment should be loaded
-   * through an other mean).
+   * "Timescale" obtained from parsing the wanted representation's initialization
+   * segment.
+   *
+   * `undefined` if either no such `timescale` has been parsed yet or if this
+   * value doesn't exist for the wanted segment.
+   *
+   * This value can be useful when parsing the loaded segment's data.
    */
-  url : string | null;
-}
-
-/** Payload of a "data-loaded" event. */
-export interface ILoaderDataLoadedValue<T> {
-  /** The loaded response data. */
-  responseData : T;
-  /** Duration the request took to be performed, in seconds. */
-  duration : number | undefined;
+  initTimescale : number | undefined
+) =>
   /**
-   * "Real" URL (post-redirection) at which the data can be loaded.
+   * The parsed data.
    *
-   * Note that this doesn't always apply e.g. some data might need multiple
-   * URLs to be fetched, some other might need to fetch no URL.
-   * This property should only be set when a unique URL is sufficient to
-   * retrieve the whole data.
+   * Can be of two types:
+   *   - `ISegmentParserParsedInitChunk`: When the parsed chunk was part of an
+   *     initialization segment.
+   *     Such segments only serve to initialize the decoder and do not contain
+   *     any decodable media data.
+   *   - `ISegmentParserParsedMediaChunk`: When the parsed chunk was part of a
+   *     media segment.
+   *     Such segments generally contain decodable media data.
    */
-  url? : string;
+  ISegmentParserParsedInitChunk<TParsedSegmentDataFormat> |
+  ISegmentParserParsedMediaChunk<TParsedSegmentDataFormat>;
+
+export interface IManifestParserOptions {
   /**
-   * Time at which the request began in terms of `performance.now`.
-   * If fetching the corresponding data necessitated to perform multiple
-   * requests, this time corresponds to the first request made.
+   * If set, offset to add to `performance.now()` to obtain the current
+   * server's time.
    */
-  sendingTime? : number;
+  externalClockOffset : number | undefined;
+  /** Original URL used for the full version of the Manifest. */
+  originalUrl : string | undefined;
+  /** The previous value of the Manifest (when updating). */
+  previousManifest : Manifest | null;
   /**
-   * Time at which the request ended in terms of `performance.now`.
-   * If fetching the corresponding data necessitated to perform multiple
-   * requests, this time corresponds to the last request to end.
+   * If set to `true`, the Manifest parser can perform advanced optimizations
+   * to speed-up the parsing process. Those optimizations might lead to a
+   * de-synchronization with what is actually on the server, hence the "unsafe"
+   * part.
+   * To use with moderation and only when needed.
    */
-  receivedTime? : number;
-  /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
-  size : number | undefined;
+  unsafeMode : boolean;
 }
 
-/** Form that can take a loaded Manifest once loaded. */
-export type ILoadedManifest = Document |
-                              ArrayBuffer |
-                              string |
-                              IMetaPlaylist |
-                              ILocalManifest |
-                              Manifest;
-
-/** Event emitted by a Manifest loader when the Manifest is fully available. */
-export interface IManifestLoaderDataLoadedEvent {
-  type : "data-loaded";
-  value : ILoaderDataLoadedValue<ILoadedManifest>;
-}
+export interface IManifestParserCallbacks {
+  onWarning : (warning : Error) => void;
 
-/** Event emitted by a segment loader when the data has been fully loaded. */
-export interface ISegmentLoaderDataLoadedEvent<T> { type : "data-loaded";
-                                                    value : ILoaderDataLoadedValue<T>; }
+  /**
+   * @param {Function} performRequest - Function performing the request
+   * @param {TaskCanceller} canceller - Interface allowing to cancel the request
+   * performed by the `performRequest` argument.
+   * @returns {Promise.<Object>}
+   */
+  scheduleRequest : (
+    performRequest : () => Promise< IRequestedData< Document | string > >,
+    canceller : TaskCanceller
+  ) =>  Promise< IRequestedData< Document | string > >;
+}
 
 /**
- * Event emitted by a segment loader when the data is available without needing
- * to perform any request.
+ * Function allowing a Manifest parser to perform a request needed for the
+ * parsing of the Manifest.
  *
- * Such data are for example directly generated from already-available data,
- * such as properties of a Manifest.
- */
-export interface ISegmentLoaderDataCreatedEvent<T> { type : "data-created";
-                                                     value : { responseData : T }; }
-
-/**
- * Event emitted by a segment loader when new information on a pending request
- * is available.
+ * @param {Function} performRequest - Function performing the wanted request.
+ * Note that this function might be called multiple times depending on the error
+ * obtained at the last call.
+ *
+ * Should resolve with the requested data on success.
  *
- * Note that this event is not mandatory.
- * It will be used to allow to communicate network metrics to the rest of the
- * player, like to adapt the quality of the content depending on the user's
- * bandwidth.
+ * Rejects in two cases:
+ *   - The request has been cancelled through the `canceller` given.
+ *     In that case, this Promise will reject with a `CancellationError`.
+ *
+ *   - The request failed.
+ *     In that case, this Promise will reject with the corresponding Error.
+ *
+ * @param {TaskCanceller} canceller - Interface allowing to cancel the request
+ * performed by the `performRequest` argument.
+ *
+ * When triggered, the request should be aborted and the Promise returned by
+ * `performRequest` should reject the corresponding `CancellationError`.
+ *
+ * The Promise returned by that function should in consequence also reject the
+ * same `CancellationError`.
+ *
+ * @returns {Promise.<Object>} - Promise resolving with the requested data on
+ * success.
+ *
+ * Rejects in two cases:
+ *   - The request has been cancelled through the `canceller` given.
+ *     In that case, this Promise will reject with a `CancellationError`.
+ *
+ *   - All the attempts to perform the request failed.
+ *     In that case, this Promise will reject with the Error corresponding to
+ *     the last performed request.
  */
-export interface ILoaderProgressEvent {
-  type : "progress";
-  value : {
-    /** Time since the beginning of the request so far, in seconds. */
-    duration : number;
-    /** Size of the data already downloaded, in bytes. */
-    size : number;
-    /** Size of whole data to download (data already-loaded included), in bytes. */
-    totalSize? : number;
-  };
-}
-
-/** Event emitted by a segment loader when a chunk of the response is available. */
-export interface ISegmentLoaderDataChunkEvent {
-  type : "data-chunk";
-  value : {
-    /** Loaded chunk, as raw data. */
-    responseData: ArrayBuffer |
-                  Uint8Array;
-  };
+export type IManifestParserRequestScheduler =
+  (
+    performRequest : () => Promise< IRequestedData< ILoadedManifestFormat > >
+  ) =>  Promise< IRequestedData< ILoadedManifestFormat > >;
+
+// Either the Manifest can be parsed directly, in which case a
+// IManifestParserResult is returned, either the Manifest parser needs to
+// perform supplementary requests first
+
+/** Event emitted when a Manifest has been parsed by a Manifest parser. */
+export interface IManifestParserResult {
+  /** The parsed Manifest Object itself. */
+  manifest : Manifest;
+  /**
+   * "Real" URL (post-redirection) at which the Manifest can be refreshed.
+   *
+   * Note that this doesn't always apply e.g. some Manifest might need multiple
+   * URLs to be fetched, some other might need to fetch no URL.
+   * This property should only be set when a unique URL is sufficient to
+   * retrieve the whole data.
+   */
+  url? : string | undefined;
 }
 
 /**
- * Event emitted by segment loaders when all data from a segment has been
- * communicated through `ISegmentLoaderDataChunkEvent` events.
+ * Allow the parser to ask for loading supplementary ressources while still
+ * profiting from the same retries and error management than the loader.
  */
-export interface ISegmentLoaderDataChunkCompleteEvent {
-  type : "data-chunk-complete";
-  value : {
-    /** Duration the request took to be performed, in seconds. */
-    duration : number | undefined;
-    /**
-     * "Real" URL (post-redirection) at which the segment was loaded.
-     *
-     * Note that this doesn't always apply e.g. some segment might need multiple
-     * URLs to be fetched, some other might need to fetch no URL.
-     * This property should only be set when a unique URL is sufficient to
-     * retrieve the whole data.
-     */
-    url? : string;
-    /**
-     * Time at which the request began in terms of `performance.now`.
-     * If fetching the corresponding data necessitated to perform multiple
-     * requests, this time corresponds to the first request made.
-     */
-    sendingTime? : number;
-    /**
-     * Time at which the request ended in terms of `performance.now`.
-     * If fetching the corresponding data necessitated to perform multiple
-     * requests, this time corresponds to the last request to end.
-     */
-    receivedTime? : number;
-    /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
-    size : number | undefined;
-  };
+export interface IManifestParserRequestNeeded {
+  resultType : "request-needed";
+  performRequest : IManifestParserRequest;
 }
 
 /**
- * Event sent by a segment loader when the corresponding segment is available
- * chunk per chunk.
+ * Time information for a single segment.
+ * Those variables expose the best guess we have on the effective duration and
+ * starting time that the corresponding segment should have at decoding time.
  */
-export type ISegmentLoaderChunkEvent = ISegmentLoaderDataChunkEvent |
-                                       ISegmentLoaderDataChunkCompleteEvent;
-
-/** Event emitted by a Manifest loader. */
-export type IManifestLoaderEvent = IManifestLoaderDataLoadedEvent;
-
-/** Event emitted by a segment loader. */
-export type ISegmentLoaderEvent<T> = ILoaderProgressEvent |
-                                     ISegmentLoaderChunkEvent |
-                                     ISegmentLoaderDataLoadedEvent<T> |
-                                     ISegmentLoaderDataCreatedEvent<T>;
-
-/** Arguments given to the `parser` function of the Manifest pipeline. */
-export interface IManifestParserArguments {
-  /** Response obtained from the loader. */
-  response : ILoaderDataLoadedValue<unknown>;
-  /** Original URL used for the full version of the Manifest. */
-  url? : string;
-  /**
-   * If set, offset to add to `performance.now()` to obtain the current
-   * server's time.
-   */
-  externalClockOffset? : number;
-  /** The previous value of the Manifest (when updating). */
-  previousManifest : Manifest | null;
+export interface IChunkTimeInfo {
   /**
-   * Allow the parser to ask for loading supplementary ressources while still
-   * profiting from the same retries and error management than the loader.
+   * Difference between the latest and the earliest presentation time
+   * available in that chunk, in seconds.
+   *
+   * If multiple chunks are present in a single segment (e.g. low-latency CMAF
+   * chunks, this is only the duration of the current chunk).
+   *
+   * Either `undefined` or set to `0` for an initialization segment.
    */
-  scheduleRequest : (request : () =>
-    Observable< ILoaderDataLoadedValue< string | Document | ArrayBuffer > >) =>
-    Observable< ILoaderDataLoadedValue< string | Document | ArrayBuffer > >;
+  duration : number | undefined;
+  /** Earliest presentation time available in that segment, in seconds. */
+  time : number;
+}
+
+/** Text track segment data, once parsed. */
+export interface ITextTrackSegmentData {
+  /** The text track data, in the format indicated in `type`. */
+  data : string;
+  /** The format of `data` (examples: "ttml", "srt" or "vtt") */
+  type : string;
   /**
-   * If set to `true`, the Manifest parser can perform advanced optimizations
-   * to speed-up the parsing process. Those optimizations might lead to a
-   * de-synchronization with what is actually on the server, hence the "unsafe"
-   * part.
-   * To use with moderation and only when needed.
+   * Language in which the text track is, as a language code.
+   * This is mostly needed for "sami" subtitles, to know which cues can / should
+   * be parsed.
    */
-  unsafeMode : boolean;
+  language? : string | undefined;
+  /** start time from which the segment apply, in seconds. */
+  start? : number | undefined;
+  /** end time until which the segment apply, in seconds. */
+  end? : number | undefined;
 }
 
-/** Arguments given to the `parser` function of the segment pipeline. */
-export interface ISegmentParserArguments<T> {
-  /** Attributes of the corresponding loader's response. */
-  response : {
-    /** The loaded data. */
-    data: T;
+/** Format under which image data is decodable by the RxPlayer. */
+export interface IImageTrackSegmentData {
+  data : IBifThumbnail[]; // image track data, in the given type
+  end : number; // end time time until which the segment apply
+  start : number; // start time from which the segment apply
+  timescale : number; // timescale to convert the start and end into seconds
+  type : string; // the type of the data (example: "bif")
+}
+
+export type IManifestParserRequest1 = (
+  (
     /**
-     * If `true`,`data` is only a "chunk" of the whole segment (which potentially
-     * will contain multiple chunks).
-     * If `false`, `data` is the data for the whole segment.
+     * Cancellation signal which will allow to cancel the request if the
+     * Manifest is not needed anymore.
+     *
+     * When cancelled, this parser should stop any pending operation (such as an
+     * HTTP request) and the Promise returned should reject immediately after with
+     * a `CancellationError`.
      */
-    isChunked : boolean;
-  };
+    cancelSignal : CancellationSignal,
+  ) => Promise< IRequestedData< Document | string > >
+);
+export type IManifestParserRequest = (
   /**
-   * "Timescale" obtained from parsing the wanted representation's initialization
+   * Cancellation signal which will allow to cancel the request if the
+   * Manifest is not needed anymore.
+   *
+   * When cancelled, this parser should stop any pending operation (such as an
+   * HTTP request) and the Promise returned should reject immediately after with
+   * a `CancellationError`.
+   */
+  cancelSignal : CancellationSignal,
+) => Promise< IManifestParserResult |
+              IManifestParserRequestNeeded >;
+
+export interface ITransportAudioVideoSegmentPipeline {
+  loadSegment : ISegmentLoader<ILoadedAudioVideoSegmentFormat>;
+  parseSegment : ISegmentParser<ILoadedAudioVideoSegmentFormat,
+                                Uint8Array | ArrayBuffer | null>;
+}
+
+export interface ITransportTextSegmentPipeline {
+  loadSegment : ISegmentLoader<ILoadedTextSegmentFormat>;
+  parseSegment : ISegmentParser<ILoadedTextSegmentFormat,
+                                ITextTrackSegmentData | null>;
+}
+
+export interface ITransportImageSegmentPipeline {
+  loadSegment : ISegmentLoader<ILoadedImageSegmentFormat>;
+  parseSegment : ISegmentParser<ILoadedImageSegmentFormat,
+                                IImageTrackSegmentData | null>;
+}
+
+export type ITransportSegmentPipeline = ITransportAudioVideoSegmentPipeline |
+                                        ITransportTextSegmentPipeline |
+                                        ITransportImageSegmentPipeline;
+
+export type ITransportPipeline = ITransportManifestPipeline |
+                                 ITransportSegmentPipeline;
+
+interface IServerSyncInfos { serverTimestamp : number;
+                             clientTime : number; }
+
+export interface ITransportOptions {
+  aggressiveMode? : boolean | undefined;
+  checkMediaSegmentIntegrity? : boolean | undefined;
+  lowLatencyMode : boolean;
+  manifestLoader?: ICustomManifestLoader | undefined;
+  manifestUpdateUrl? : string | undefined;
+  referenceDateTime? : number | undefined;
+  representationFilter? : IRepresentationFilter | undefined;
+  segmentLoader? : ICustomSegmentLoader | undefined;
+  serverSyncInfos? : IServerSyncInfos | undefined;
+  /* eslint-disable import/no-deprecated */
+  supplementaryImageTracks? : ISupplementaryImageTrack[] | undefined;
+  supplementaryTextTracks? : ISupplementaryTextTrack[] | undefined;
+  /* eslint-enable import/no-deprecated */
+
+  __priv_patchLastSegmentInSidx? : boolean | undefined;
+}
+
+export type ICustomSegmentLoader = (
+  // first argument: infos on the segment
+  infos : { url : string;
+            manifest : IExposedManifest;
+            period : IExposedPeriod;
+            adaptation : IExposedAdaptation;
+            representation : IExposedRepresentation;
+            segment : IExposedSegment; },
+
+  // second argument: callbacks
+  callbacks : { resolve : (rArgs : { data : ArrayBuffer | Uint8Array;
+                                     sendingTime? : number | undefined;
+                                     receivingTime? : number | undefined;
+                                     size? : number | undefined;
+                                     duration? : number | undefined; }) => void;
+
+                 reject : (err? : unknown) => void;
+                 fallback : () => void;
+                 progress : (
+                   info : { duration : number;
+                            size : number;
+                            totalSize? : number | undefined; }
+                 ) => void;
+  }
+) =>
+  // returns either the aborting callback or nothing
+  (() => void)|void;
+
+export type ICustomManifestLoader = (
+  // first argument: url of the manifest
+  url : string | undefined,
+
+  // second argument: callbacks
+  callbacks : { resolve : (args : { data : ILoadedManifestFormat;
+                                    url? : string | undefined;
+                                    sendingTime? : number | undefined;
+                                    receivingTime? : number | undefined;
+                                    size? : number | undefined;
+                                    duration? : number | undefined; })
+                          => void;
+
+                 reject : (err? : Error) => void;
+                 fallback : () => void; }
+) =>
+  // returns either the aborting callback or nothing
+  (() => void)|void;
+
+export interface ISegmentContext {
+  /** Manifest object related to this segment. */
+  manifest : Manifest;
+  /** Period object related to this segment. */
+  period : Period;
+  /** Adaptation object related to this segment. */
+  adaptation : Adaptation;
+  /** Representation Object related to this segment. */
+  representation : Representation;
+  /** Segment we want to load. */
+  segment : ISegment;
+}
+
+export interface ISegmentLoaderCallbacks<T> {
+  /**
+   * Callback called when new progress information on a segment request is
+   * available.
+   * The information emitted though this callback can be used to gather
+   * metrics on a current, un-terminated, request.
+   */
+  onProgress : (info : ISegmentLoadingProgressInformation) => void;
+  /**
+   * Callback called when a decodable sub-part of the segment is available.
+   *
+   * Note that this callback is only called if the loader decides to load the
+   * wanted segment in a "chunk" mode, that is, when the segment is loaded
+   * decodable chunk by decodable chunk, each being a subpart of this same
    * segment.
    *
-   * `undefined` if either no such `timescale` has been parsed yet or if this
-   * value doesn't exist for the wanted segment.
+   * In that case, this callback might be called multiple times for subsequent
+   * decodable chunks until the Promise resolves.
    *
-   * This value can be useful when parsing the loaded segment's data.
+   * Not all segments are loaded in a "chunk" mode.
+   * The alternatives to this mode are:
+   *
+   *   - when the segment is created locally without needing to perform any
+   *     request.
+   *
+   *   - when the segment is loaded as a whole.
+   *
+   * In both of those other cases, the segment data can be retrieved in the
+   * Promise returned by the segment loader instead.
    */
-  initTimescale? : number;
-  /** Context about the wanted segment. */
-  content : {
-    /** Manifest object related to this segment. */
-    manifest : Manifest;
-    /** Period object related to this segment. */
-    period : Period;
-    /** Adaptation object related to this segment. */
-    adaptation : Adaptation;
-    /** Representation Object related to this segment. */
-    representation : Representation;
-    /** Segment we want to parse. */
-    segment : ISegment;
-  };
+  onNewChunk : (data : T) => void;
 }
 
-/** Event emitted when a Manifest object has been parsed. */
-export interface IManifestParserResponseEvent {
-  type : "parsed";
-  value: {
-    /** The parsed Manifest Object itself. */
-    manifest : Manifest;
-    /**
-     * "Real" URL (post-redirection) at which the Manifest can be refreshed.
-     *
-     * Note that this doesn't always apply e.g. some Manifest might need multiple
-     * URLs to be fetched, some other might need to fetch no URL.
-     * This property should only be set when a unique URL is sufficient to
-     * retrieve the whole data.
-     */
-    url? : string;
-  };
+/** Information related to a pending Segment request progressing. */
+export interface ISegmentLoadingProgressInformation {
+  /** Time since the beginning of the request so far, in seconds. */
+  duration : number;
+  /** Size of the data already downloaded, in bytes. */
+  size : number;
+  /** Size of whole data to download (data already-loaded included), in bytes. */
+  totalSize? : number | undefined;
 }
 
-/** Event emitted when a minor error was encountered when parsing the Manifest. */
-export interface IManifestParserWarningEvent {
-  type : "warning";
-  /** Error describing the minor parsing error encountered. */
-  value : Error;
+/**
+ * Result returned by a segment loader when a segment has been loaded in a
+ * "chunk" mode.
+ * In that mode, the segment has been divided into multiple decodable chunks
+ * each sent in order through the `onNewChunk` callback of the corresponding
+ * loader.
+ */
+export interface ISegmentLoaderResultChunkedComplete {
+  resultType : "chunk-complete";
+  /** Information on the request performed. */
+  resultData : IChunkCompleteInformation;
 }
 
 /**
- * Time information for a single segment.
- * Those variables expose the best guess we have on the effective duration and
- * starting time that the corresponding segment should have at decoding time.
+ * Result returned by a segment loader when a segment has been loaded
+ * by performing a request.
  */
-export interface IChunkTimeInfo {
+export interface ISegmentLoaderResultSegmentLoaded<T> {
+  resultType : "segment-loaded";
+  /** Segment data and information on the request. */
+  resultData : IRequestedData<T>;
+}
+
+/**
+ * Result returned by a segment loader when a segment has been fully
+ * created locally and thus did not depend on a request.
+ * TODO merge with ISegmentLoaderResultSegmentLoaded?
+ */
+export interface ISegmentLoaderResultSegmentCreated<T> {
+  resultType : "segment-created";
+  /** The data iself. */
+  resultData : T;
+}
+
+/** Data emitted in a `ISegmentLoaderResultChunkedComplete`. */
+export interface IChunkCompleteInformation {
+  /** Duration the request took to be performed, in seconds. */
+  requestDuration : number | undefined;
   /**
-   * Difference between the latest and the earliest presentation time
-   * available in that segment, in seconds.
+   * "Real" URL (post-redirection) at which the segment was loaded.
    *
-   * Either `undefined` or set to `0` for an initialization segment.
+   * Note that this doesn't always apply e.g. some segment might need multiple
+   * URLs to be fetched, some other might need to fetch no URL.
+   * This property should only be set when a unique URL is sufficient to
+   * retrieve the whole data.
    */
-  duration : number | undefined;
-  /** Earliest presentation time available in that segment, in seconds. */
-  time : number;
+  url? : string | undefined;
+  /**
+   * Time at which the request began in terms of `performance.now`.
+   * If fetching the corresponding data necessitated to perform multiple
+   * requests, this time corresponds to the first request made.
+   */
+  sendingTime? : number | undefined;
+  /**
+   * Time at which the request ended in terms of `performance.now`.
+   * If fetching the corresponding data necessitated to perform multiple
+   * requests, this time corresponds to the last request to end.
+   */
+  receivedTime? : number | undefined;
+  /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
+  size : number | undefined;
 }
 
-/** Payload sent when an initialization segment has been parsed. */
-export interface ISegmentParserParsedInitSegment<T> {
+/** Format of a loaded Manifest before parsing. */
+export type ILoadedManifestFormat = Document |
+                                    string |
+                                    ArrayBuffer |
+                                    IMetaPlaylist |
+                                    ILocalManifest |
+                                    Manifest;
+
+/** Format of a loaded audio and video segment before parsing. */
+export type ILoadedAudioVideoSegmentFormat = Uint8Array |
+                                             ArrayBuffer |
+                                             null;
+
+/** Format of a loaded text segment before parsing. */
+export type ILoadedTextSegmentFormat = Uint8Array |
+                                       ArrayBuffer |
+                                       string |
+                                       null;
+
+/** Format of a loaded image segment before parsing. */
+export type ILoadedImageSegmentFormat = Uint8Array |
+                                        ArrayBuffer |
+                                        null;
+
+/**
+ * Result returned by a segment parser when it parsed a chunk from an init
+ * segment (which does not contain media data).
+ */
+export interface ISegmentParserParsedInitChunk<DataType> {
+  segmentType : "init";
   /**
    * Initialization segment that can be directly pushed to the corresponding
    * buffer.
    */
-  initializationData : T | null;
+  initializationData : DataType | null;
   /**
    * Timescale metadata found inside this initialization segment.
    * That timescale might be useful when parsing further merdia segments.
    */
-  initTimescale? : number;
+  initTimescale? : number | undefined;
   /**
    * If set to `true`, some protection information has been found in this
    * initialization segment and lead the corresponding `Representation`
@@ -452,34 +724,51 @@ export interface ISegmentParserParsedInitSegment<T> {
   protectionDataUpdate : boolean;
 }
 
-/** Payload sent when an media segment has been parsed. */
-export interface ISegmentParserParsedSegment<T> {
-  /** Data to decode. */
-  chunkData : T | null;
-  /** Time information about the segment. */
+/**
+ * Result returned by a segment parser when it parsed a chunk from a media
+ * segment (which contains media data, unlike an initialization segment).
+ */
+export interface ISegmentParserParsedMediaChunk<DataType> {
+  segmentType : "media";
+  /**
+   * Parsed chunk of data that can be decoded.
+   * `null` if no data was parsed.
+   */
+  chunkData : DataType | null;
+  /**
+   * Time information on this parsed chunk.
+   * `null` if unknown.
+   */
   chunkInfos : IChunkTimeInfo | null;
   /**
-   * Time offset, in seconds, to add to the absolute timed data defined in
+   * time offset, in seconds, to add to the absolute timed data defined in
    * `chunkData` to obtain the "real" wanted effective time.
    *
    * For example:
-   *   If `chunkData` announce that the segment begins at 32 seconds, and
-   *   `chunkOffset` equals to `4`, then the segment should really begin at 36
-   *   seconds (32 + 4).
+   *   If `chunkData` announces (when parsed by the demuxer or decoder) that the
+   *   segment begins at 32 seconds, and `chunkOffset` equals to `4`, then the
+   *   segment should really begin at 36 seconds (32 + 4).
    *
    * Note that `chunkInfos` needs not to be offseted as it should already
    * contain the correct time information.
    */
   chunkOffset : number;
   /**
-   * Start and end windows at which this segment applies (part of the segment
-   * respectively before and after that time will be ignored).
+   * start and end windows for the segment (part of the chunk respectively
+   * before and after that time will be ignored).
+   * `undefined` when their is no such limitation.
    */
   appendWindow : [ number | undefined,
                    number | undefined ];
-  /** Inband events parsed from segment data. */
-  inbandEvents? : IInbandEvent[];
-  /** Tells if the result of the parsing shows that the manifest should be refreshed */
+  /**
+   * If set and not empty, then "events" have been encountered in this parsed
+   * chunks.
+   */
+  inbandEvents? : IInbandEvent[] | undefined;
+  /**
+   * If set to `true`, then parsing this chunk revealed that the current
+   * Manifest instance needs to be refreshed.
+   */
   needsManifestRefresh?: boolean;
   /**
    * If set to `true`, some protection information has been found in this
@@ -495,122 +784,33 @@ export interface ISegmentParserParsedSegment<T> {
   protectionDataUpdate : boolean;
 }
 
-/**
- * What a segment parser returns when parsing an initialization segment.
- *
- * Those types of segment contain no decodable data and are only there for
- * initialization purposes, such as giving initial infos to the decoder on
- * subsequent media segments that will be pushed.
- */
-export interface ISegmentParserInitSegment<T> {
-  type : "parsed-init-segment";
-  value : ISegmentParserParsedInitSegment<T>;
-}
-
-/**
- * What a segment parser returns when parsing a media segment.
- * Those types of segment contain decodable data.
- */
-export interface ISegmentParserSegment<T> {
-  type : "parsed-segment";
-  value : ISegmentParserParsedSegment<T>;
-}
-
-// format under which audio / video data / initialization data is decodable
-/** Text track segment data, once parsed. */
-export interface ITextTrackSegmentData {
-  /** The text track data, in the format indicated in `type`. */
-  data : string;
-  /** The format of `data` (examples: "ttml", "srt" or "vtt") */
-  type : string;
+/** Describe data loaded through a request. */
+export interface IRequestedData<T> {
+  /** The loaded response data. */
+  responseData : T;
+  /** Duration the request took to be performed, in seconds. */
+  requestDuration : number | undefined;
   /**
-   * Language in which the text track is, as a language code.
-   * This is mostly needed for "sami" subtitles, to know which cues can / should
-   * be parsed.
+   * "Real" URL (post-redirection) at which the data can be loaded.
+   *
+   * Note that this doesn't always apply e.g. some data might need multiple
+   * URLs to be fetched, some other might need to fetch no URL.
+   * This property should only be set when a unique URL is sufficient to
+   * retrieve the whole data.
    */
-  language? : string;
-  /** start time from which the segment apply, in seconds. */
-  start? : number;
-  /** end time until which the segment apply, in seconds. */
-  end? : number;
-}
-
-/** Format under which image data is decodable by the RxPlayer. */
-export interface IImageTrackSegmentData {
-  /** Exploitable image track data. */
-  data : IBifThumbnail[];
-  /** End time time until which the segment apply, in the timescale given. */
-  end : number;
-  /** Start time time from which the segment apply, in the timescale given. */
-  start : number;
-  /** Timescale to convert the `start` and `end` properties into seconds. */
-  timescale : number;
-  /** The format the data is in (example: "bif"). */
-  type : "bif";
-}
-
-interface IServerSyncInfos { serverTimestamp : number;
-                             clientTime : number; }
-
-export interface ITransportOptions {
-  aggressiveMode? : boolean;
-  checkMediaSegmentIntegrity? : boolean;
-  lowLatencyMode : boolean;
-  manifestLoader?: CustomManifestLoader;
-  manifestUpdateUrl? : string;
-  referenceDateTime? : number;
-  representationFilter? : IRepresentationFilter;
-  segmentLoader? : CustomSegmentLoader;
-  serverSyncInfos? : IServerSyncInfos;
-  /* eslint-disable import/no-deprecated */
-  supplementaryImageTracks? : ISupplementaryImageTrack[];
-  supplementaryTextTracks? : ISupplementaryTextTrack[];
-  /* eslint-enable import/no-deprecated */
-
-  __priv_patchLastSegmentInSidx? : boolean;
+  url? : string | undefined;
+  /**
+   * Time at which the request began in terms of `performance.now`.
+   * If fetching the corresponding data necessitated to perform multiple
+   * requests, this time corresponds to the first request made.
+   */
+  sendingTime? : number | undefined;
+  /**
+   * Time at which the request ended in terms of `performance.now`.
+   * If fetching the corresponding data necessitated to perform multiple
+   * requests, this time corresponds to the last request to end.
+   */
+  receivedTime? : number | undefined;
+  /** Size in bytes of the loaded data.  `undefined` if we don't know.  */
+  size : number | undefined;
 }
-
-export type CustomSegmentLoader = (
-  // first argument: infos on the segment
-  args : { adaptation : Adaptation;
-           representation : Representation;
-           segment : ISegment;
-           transport : string;
-           url : string;
-           manifest : Manifest; },
-
-  // second argument: callbacks
-  callbacks : { resolve : (rArgs : { data : ArrayBuffer | Uint8Array;
-                                     sendingTime? : number;
-                                     receivingTime? : number;
-                                     size? : number;
-                                     duration? : number; })
-                          => void;
-
-                progress : (pArgs : { duration : number;
-                                      size : number;
-                                      totalSize? : number; })
-                           => void;
-                reject : (err? : Error) => void;
-                fallback? : () => void; }
-) =>
-  // returns either the aborting callback or nothing
-  (() => void)|void;
-
-export type CustomManifestLoader = (
-  // first argument: url of the manifest
-  url : string | undefined,
-
-  // second argument: callbacks
-  callbacks : { resolve : (args : { data : ILoadedManifest;
-                                    sendingTime? : number;
-                                    receivingTime? : number;
-                                    size? : number;
-                                    duration? : number; })
-                          => void;
-
-                 reject : (err? : Error) => void;
-                 fallback? : () => void; }
-) =>
-  // returns either the aborting callback or nothing
-  (() => void)|void;