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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -23,6 +23,7 @@ import Manifest, {
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
 import { IReadOnlyPlaybackObserver } from "../../../api";
 import SegmentBuffersStore, {
+  ChunkStatus,
   IBufferedChunk,
   IEndOfSegmentOperation,
   SegmentBuffer,
@@ -299,7 +300,7 @@ function getPlayableBufferedSegments(
     const eltInventory = segmentInventory[i];
 
     const { representation } = eltInventory.infos;
-    if (!eltInventory.partiallyPushed &&
+    if (eltInventory.status === ChunkStatus.Complete &&
         representation.decipherable !== false &&
         representation.isSupported)
     {

package/src/default_config.ts

@@ -163,6 +163,23 @@ const DEFAULT_CONFIG = {
   } as Partial<Record<"audio"|"video"|"text", number>>,
     /* eslint-enable @typescript-eslint/consistent-type-assertions */
 
+  /* eslint-disable @typescript-eslint/consistent-type-assertions */
+  /**
+   * Minimum possible buffer ahead for each type of buffer, to avoid Garbage
+   * Collecting too much data when it would have adverse effects.
+   * Equal to `0` if not defined here.
+   * @type {Object}
+   */
+  MINIMUM_MAX_BUFFER_AHEAD: {
+    // Text segments are both much lighter on resources and might
+    // actually be much larger than other types of segments in terms
+    // of duration. Let's make an exception here by authorizing a
+    // larger text buffer ahead, to avoid unnecesarily reloading the
+    // same text track.
+    text: 2 * 60,
+  } as Partial<Record<"audio"|"video"|"image"|"text", number>>,
+  /* eslint-enable @typescript-eslint/consistent-type-assertions */
+
     /* eslint-disable @typescript-eslint/consistent-type-assertions */
     /**
      * Maximum possible buffer behind for each type of buffer, to avoid too much
@@ -236,23 +253,6 @@ const DEFAULT_CONFIG = {
      */
   BUFFER_DISCONTINUITY_THRESHOLD: 0.2,
 
-    /**
-     * When encountering small discontinuities, the RxPlayer may want, in specific
-     * conditions, ignore those and let the browser seek over them iself (this
-     * allows for example to avoid conflicts when both the browser and the
-     * RxPlayer want to seek at a different position, sometimes leading to a
-     * seeking loop).
-     * In this case, we however still want to seek it ourselves if the browser
-     * doesn't take the opportunity soon enough.
-     *
-     * This value specifies a delay after which a discontinuity ignored by the
-     * RxPlayer is finally considered.
-     * We want to maintain high enough to be sure the browser will not seek yet
-     * small enough so this (arguably rare) situation won't lead to too much
-     * waiting time.
-     */
-  FORCE_DISCONTINUITY_SEEK_DELAY: 5000,
-
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
      * We re-load the given segment if the current one times that ratio is

package/src/manifest/adaptation.ts

@@ -157,7 +157,8 @@ export default class Adaptation {
         const reprObject : IRepresentationFilterRepresentation = {
           id: representation.id,
           bitrate: representation.bitrate,
-          codec: representation.codec,
+          codecs: representation.codec === undefined ? [] :
+                                                       [representation.codec],
           height: representation.height,
           width: representation.width,
           frameRate: representation.frameRate,

package/src/parsers/texttracks/ttml/html/apply_line_height.ts

@@ -27,10 +27,12 @@ export default function applyLineHeight(
   lineHeight : string
 ) : void {
   const trimmedLineHeight = lineHeight.trim();
+  const splittedLineHeight = trimmedLineHeight.split(" ");
+
   if (trimmedLineHeight === "auto") {
     return;
   }
-  const firstLineHeight = REGXP_LENGTH.exec(trimmedLineHeight[0]);
+  const firstLineHeight = REGXP_LENGTH.exec(splittedLineHeight[0]);
   if (firstLineHeight === null) {
     return;
   }

package/src/public_types.ts

@@ -186,8 +186,35 @@ export interface IRepresentationFilterRepresentation {
   /** String identifying the Representation, unique per Adaptation. */
   id : string;
   bitrate? : number | undefined;
-  /** Codec used by the media segments of that Representation. */
-  codec? : string | undefined;
+  /**
+   * Codec(s) relied on by the media segments of that Representation.
+   *
+   * For the great majority of cases, this value will be set to either
+   * `undefined` (meaning the codec is unknown) or to an array with a
+   * single element which will be the actual codec relied on when the
+   * corresponding Representation will be played.
+   *
+   * However in some very rare scenarios, this value might be set to an array
+   * with multiple codecs, itself being a list of its candidate codecs from the
+   * most wanted to the most compatible.
+   * The conditions for this more complex format are very specific:
+   *
+   *   - It can only happen if the `representationFilter` callback is called in
+   *     an environment where it hasn't yet been possible for the RxPlayer to
+   *     check for codec support (mainly when running through the RxPlayer's
+   *     `MULTI_THREAD` feature in a browser without MSE-in-worker
+   *     capabilities).
+   *
+   *   - The corresponding Representation is compatible to a restrictive codec
+   *     yet also retro-compatible to a less restrictive one.
+   *
+   *     The main example being Dolby Vision Representations which are
+   *     retro-compatible to HDR10 HEVC codecs.
+   *     In that very specific case, we could have an array with two elements:
+   *       1. The Dolby Vision codec
+   *       2. The base HDR10 codec
+   */
+  codecs? : string[] | undefined;
   /**
    * This property makes the most sense for video Representations.
    * It defines the height of the video, in pixels.

package/dist/_esm5.processed/core/api/track_management/track_dispatcher.d.ts

@@ -1,84 +0,0 @@
-import Manifest, { Adaptation } from "../../../manifest";
-import EventEmitter from "../../../utils/event_emitter";
-import SharedReference, { IReadOnlySharedReference } from "../../../utils/reference";
-import { IAdaptationChoice, IRepresentationsChoice, ITrackSwitchingMode } from "../../stream";
-/**
- * Class handling track changes and quality locking for a single Period and
- * Adaptation type.
- * @class TrackDispatcher
- */
-export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent> {
-    /**
-     * `Manifest` object linked to the current content handled by the
-     * `TrackDispatcher`.
-     * Needed to subscribe to various events.
-     */
-    private readonly _manifest;
-    /**
-     * Reference through which the wanted track will be emitted.
-     * `null` is emitted if no track for that type is wanted.
-     */
-    private readonly _adaptationRef;
-    /**
-     * Last values emitted through `adaptationRef`.
-     * This value is mutated just before `adaptationRef` is "nexted".
-     *
-     * Storing this information allows to detect if some potential
-     * side-effects already led to the "nexting" of `adaptationRef` with the wanted
-     * settings, preventing the the `TrackDispatcher` from doing it again.
-     */
-    private _lastEmitted;
-    /** Interface allowing to clean-up resources when they are not needed anymore. */
-    private _canceller;
-    /**
-     * Create a new `TrackDispatcher` by giving its Reference and an initial track
-     * setting.
-     * This constructor will update the Reference with the right preferences
-     * synchronously.
-     * @param {Object} manifest
-     * @param {Object} adaptationRef
-     * @param {Object|null} initialTrackInfo
-     */
-    constructor(manifest: Manifest, adaptationRef: SharedReference<IAdaptationChoice | null | undefined>, initialTrackInfo: ITrackSetting | null);
-    /**
-     * Update the wanted track on the Reference linked to this `TrackDispatcher`.
-     * @param {Object|null} newTrackInfo
-     */
-    updateTrack(newTrackInfo: ITrackSetting | null): void;
-    /**
-     * Create a shared reference which will emit the wanted locked Representations
-     * based on the current capabilities and the last user settings.
-     *
-     * @param {Object} trackInfo
-     * @returns {Object}
-     */
-    private _constructLockedRepresentationsReference;
-    /**
-     * Free the resources (e.g. `Manifest` event listeners) linked to this
-     * `TrackDispatcher`.
-     */
-    dispose(): void;
-}
-export interface ITrackDispatcherEvent {
-    /**
-     * Event sent when given locked Representations cannot be respected because
-     * none of them are currently "playable".
-     */
-    noPlayableLockedRepresentation: null;
-}
-/** Define a new Track preference given to the `TrackDispatcher`. */
-export interface ITrackSetting {
-    /** Contains the `Adaptation` wanted by the user. */
-    adaptation: Adaptation;
-    /** "Switching mode" in which the track switch should happen. */
-    switchingMode: ITrackSwitchingMode;
-    /**
-     * Contains the last locked `Representation`s for this `Adaptation` wanted
-     * by the user.
-     * `null` if no Representation is locked.
-     *
-     * Can be updated continuously while the `TrackDispatcher` is in possession
-     * of this shared reference.
-     */
-    lockedRepresentations: IReadOnlySharedReference<IRepresentationsChoice | null>;
-}

package/dist/_esm5.processed/core/api/track_management/track_dispatcher.js

@@ -1,158 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { MediaError } from "../../../errors";
-import EventEmitter from "../../../utils/event_emitter";
-import SharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
-/**
- * Class handling track changes and quality locking for a single Period and
- * Adaptation type.
- * @class TrackDispatcher
- */
-var TrackDispatcher = /** @class */ (function (_super) {
-    __extends(TrackDispatcher, _super);
-    /**
-     * Create a new `TrackDispatcher` by giving its Reference and an initial track
-     * setting.
-     * This constructor will update the Reference with the right preferences
-     * synchronously.
-     * @param {Object} manifest
-     * @param {Object} adaptationRef
-     * @param {Object|null} initialTrackInfo
-     */
-    function TrackDispatcher(manifest, adaptationRef, initialTrackInfo) {
-        var _this = _super.call(this) || this;
-        _this._canceller = new TaskCanceller();
-        _this._manifest = manifest;
-        _this._adaptationRef = adaptationRef;
-        if (initialTrackInfo === null) {
-            _this._lastEmitted = initialTrackInfo;
-            adaptationRef.setValue(null);
-            return _this;
-        }
-        var reference = _this._constructLockedRepresentationsReference(initialTrackInfo);
-        _this._lastEmitted = { adaptation: initialTrackInfo.adaptation,
-            switchingMode: initialTrackInfo.switchingMode,
-            lockedRepresentations: null };
-        adaptationRef.setValue({ adaptation: initialTrackInfo.adaptation,
-            switchingMode: initialTrackInfo.switchingMode,
-            representations: reference });
-        return _this;
-    }
-    /**
-     * Update the wanted track on the Reference linked to this `TrackDispatcher`.
-     * @param {Object|null} newTrackInfo
-     */
-    TrackDispatcher.prototype.updateTrack = function (newTrackInfo) {
-        if (newTrackInfo === null) {
-            if (this._lastEmitted === null) {
-                return;
-            }
-            this._canceller.cancel();
-            // has no point but let's still create one for simplicity sake
-            this._canceller = new TaskCanceller();
-            this._lastEmitted = null;
-            this._adaptationRef.setValue(null);
-            return;
-        }
-        var adaptation = newTrackInfo.adaptation, switchingMode = newTrackInfo.switchingMode;
-        this._canceller.cancel();
-        this._canceller = new TaskCanceller();
-        var reference = this._constructLockedRepresentationsReference(newTrackInfo);
-        this._lastEmitted = { adaptation: adaptation, switchingMode: switchingMode, lockedRepresentations: null };
-        this._adaptationRef.setValue({ adaptation: adaptation, switchingMode: switchingMode, representations: reference });
-    };
-    /**
-     * Create a shared reference which will emit the wanted locked Representations
-     * based on the current capabilities and the last user settings.
-     *
-     * @param {Object} trackInfo
-     * @returns {Object}
-     */
-    TrackDispatcher.prototype._constructLockedRepresentationsReference = function (trackInfo) {
-        var manifest = this._manifest;
-        /* Initialize it. Will be at its true value at the end of the function. */
-        var reference = new SharedReference({
-            representations: [],
-            switchingMode: "lazy",
-        });
-        /* eslint-disable-next-line @typescript-eslint/no-this-alias */
-        var self = this;
-        manifest.addEventListener("decipherabilityUpdate", updateReferenceIfNeeded);
-        manifest.addEventListener("manifestUpdate", updateReferenceIfNeeded);
-        this._canceller.signal.register(removeListeners);
-        trackInfo.lockedRepresentations.onUpdate(updateReferenceIfNeeded, {
-            clearSignal: this._canceller.signal,
-            emitCurrentValue: false,
-        });
-        updateReferenceIfNeeded();
-        return reference;
-        function updateReferenceIfNeeded() {
-            var repSettings = trackInfo.lockedRepresentations.getValue();
-            var switchingMode;
-            /** Representations for which a `RepresentationStream` can be created. */
-            var playableRepresentations;
-            if (repSettings === null) { // unlocking
-                playableRepresentations = trackInfo.adaptation.getPlayableRepresentations();
-                // No need to remove the previous content when unlocking
-                switchingMode = "lazy";
-            }
-            else {
-                var representations = repSettings.representations;
-                switchingMode = repSettings.switchingMode;
-                playableRepresentations = representations.filter(function (r) { return r.isPlayable(); });
-                if (playableRepresentations.length === 0) {
-                    self.trigger("noPlayableLockedRepresentation", null);
-                    return;
-                }
-            }
-            if (playableRepresentations.length <= 0) {
-                var adaptationType = trackInfo.adaptation.type;
-                var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
-                    adaptationType + " Adaptation can be played", { adaptation: trackInfo.adaptation });
-                throw noRepErr;
-            }
-            // Check if Locked Representations have changed
-            var oldRef = reference.getValue();
-            var sortedReps = playableRepresentations.slice().sort();
-            if (sortedReps.length !== oldRef.representations.length) {
-                reference.setValue({ representations: sortedReps, switchingMode: switchingMode });
-                return;
-            }
-            for (var i = 0; i < sortedReps.length; i++) {
-                if (oldRef.representations[i].id !== sortedReps[i].id) {
-                    reference.setValue({ representations: sortedReps, switchingMode: switchingMode });
-                    return;
-                }
-            }
-        }
-        function removeListeners() {
-            manifest.removeEventListener("decipherabilityUpdate", updateReferenceIfNeeded);
-            manifest.removeEventListener("manifestUpdate", updateReferenceIfNeeded);
-        }
-    };
-    /**
-     * Free the resources (e.g. `Manifest` event listeners) linked to this
-     * `TrackDispatcher`.
-     */
-    TrackDispatcher.prototype.dispose = function () {
-        this.removeEventListener();
-        this._canceller.cancel();
-        this._adaptationRef.finish();
-    };
-    return TrackDispatcher;
-}(EventEmitter));
-export default TrackDispatcher;