rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

package/src/core/fetchers/utils/schedule_request.ts

@@ -0,0 +1,482 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { isOffline } from "../../../compat";
+import {
+  CustomLoaderError,
+  isKnownError,
+  NetworkErrorTypes,
+  RequestError,
+} from "../../../errors";
+import log from "../../../log";
+import { ICdnMetadata } from "../../../parsers/manifest";
+import cancellableSleep from "../../../utils/cancellable_sleep";
+import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
+import noop from "../../../utils/noop";
+import TaskCanceller, {
+  CancellationSignal,
+} from "../../../utils/task_canceller";
+import CdnPrioritizer from "../cdn_prioritizer";
+
+/**
+ * Called on a loader error.
+ * Returns whether the loader request should be retried.
+ *
+ * TODO the notion of retrying or not could be transport-specific (e.g. 412 are
+ * mainly used for Smooth contents) and thus as part of the transport code (e.g.
+ * by rejecting with an error always having a `canRetry` property?).
+ * Or not, to ponder.
+ *
+ * @param {Error} error
+ * @returns {Boolean} - If true, the request can be retried.
+ */
+function shouldRetry(error : unknown) : boolean {
+  if (error instanceof RequestError) {
+    if (error.type === NetworkErrorTypes.ERROR_HTTP_CODE) {
+      return error.status >= 500 ||
+             error.status === 404 ||
+             error.status === 415 || // some CDN seems to use that code when
+                                     // requesting low-latency segments too much
+                                     // in advance
+             error.status === 412;
+    }
+    return error.type === NetworkErrorTypes.TIMEOUT ||
+           error.type === NetworkErrorTypes.ERROR_EVENT;
+  } else if (error instanceof CustomLoaderError) {
+    if (typeof error.canRetry === "boolean") {
+      return error.canRetry;
+    }
+    if (error.xhr !== undefined) {
+      return error.xhr.status >= 500 ||
+             error.xhr.status === 404 ||
+             error.xhr.status === 415 || // some CDN seems to use that code when
+                                         // requesting low-latency segments too much
+                                         // in advance
+             error.xhr.status === 412;
+    }
+    return false;
+  }
+  return isKnownError(error) && error.code === "INTEGRITY_ERROR";
+}
+
+/**
+ * Returns true if we're pretty sure that the current error is due to the
+ * user being offline.
+ * @param {Error} error
+ * @returns {Boolean}
+ */
+function isOfflineRequestError(error : unknown) : boolean {
+  if (error instanceof RequestError) {
+    return error.type === NetworkErrorTypes.ERROR_EVENT &&
+           isOffline();
+  } else if (error instanceof CustomLoaderError) {
+    return error.isOfflineError;
+  }
+  return false; // under doubt, return false
+}
+
+/** Settings to give to the backoff functions to configure their behavior. */
+export interface IBackoffSettings {
+  /**
+   * 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;
+  /** Callback called when a request is retried. */
+  onRetry : (err : unknown) => void;
+}
+
+const enum REQUEST_ERROR_TYPES { None,
+                                 Regular,
+                                 Offline }
+
+/**
+ * Guess the type of error obtained.
+ * @param {*} error
+ * @returns {number}
+ */
+function getRequestErrorType(error : unknown) : REQUEST_ERROR_TYPES {
+  return isOfflineRequestError(error) ? REQUEST_ERROR_TYPES.Offline :
+                                        REQUEST_ERROR_TYPES.Regular;
+}
+
+/**
+ * Specific algorithm used to perform segment and manifest requests.
+ *
+ * Here how it works:
+ *
+ *   1. You give it one or multiple of the CDN available for the resource you
+ *      want to request (from the most important one to the least important),
+ *      a callback doing the request with the chosen CDN in argument, and some
+ *      options.
+ *
+ *   2. it tries to call the request callback with the most prioritized CDN
+ *      first:
+ *        - if it works as expected, it resolves the returned Promise with that
+ *          request's response.
+ *        - if it fails, it calls ther `onRetry` callback given with the
+ *          corresponding error, un-prioritize that CDN and try with the new
+ *          most prioritized CDN.
+ *
+ *      Each CDN might be retried multiple times, depending on the nature of the
+ *      error and the Configuration given.
+ *
+ *      Multiple retries of the same CDN are done after a delay to avoid
+ *      overwhelming it, this is what we call a "backoff". That delay raises
+ *      exponentially as multiple consecutive errors are encountered on this
+ *      CDN.
+ *
+ * @param {Array.<string>|null} cdns - The different CDN on which the
+ * wanted resource is available. `scheduleRequestWithCdns` will call the
+ * `performRequest` callback with the right element from that array if different
+ * from `null`.
+ *
+ * Can be set to `null` when that resource is not reachable through a CDN, in
+ * which case the `performRequest` callback may be called with `null`.
+ * @param {Object|null} cdnPrioritizer - Interface allowing to give the priority
+ * between multiple CDNs.
+ * @param {Function} performRequest - Callback implementing the request in
+ * itself. Resolving when the resource request succeed and rejecting with the
+ * corresponding error when the request failed.
+ * @param {Object} options - Configuration allowing to tweak the number on which
+ * the algorithm behind `scheduleRequestWithCdns` bases itself.
+ * @param {Object} cancellationSignal - CancellationSignal allowing to cancel
+ * the logic of `scheduleRequestWithCdns`.
+ * To trigger if the resource is not needed anymore.
+ * @returns {Promise} - Promise resolving, with the corresponding
+ * `performRequest`'s data, when the resource request succeed and rejecting in
+ * the following scenarios:
+ *   - `scheduleRequestWithCdns` has been cancelled due to `cancellationSignal`
+ *     being triggered. In that case a `CancellationError` is thrown.
+ *
+ *   - The resource request(s) failed and will not be retried anymore.
+ */
+export async function scheduleRequestWithCdns<T>(
+  cdns : ICdnMetadata[] | null,
+  cdnPrioritizer : CdnPrioritizer | null,
+  performRequest : (
+    cdn : ICdnMetadata | null,
+    cancellationSignal : CancellationSignal
+  ) => Promise<T>,
+  options : IBackoffSettings,
+  cancellationSignal : CancellationSignal
+) : Promise<T> {
+  if (cancellationSignal.cancellationError !== null) {
+    return Promise.reject(cancellationSignal.cancellationError);
+  }
+
+  const { baseDelay,
+          maxDelay,
+          maxRetryRegular,
+          maxRetryOffline,
+          onRetry } = options;
+
+  if (cdns !== null && cdns.length === 0) {
+    log.warn("Fetchers: no CDN given to `scheduleRequestWithCdns`.");
+  }
+
+  const missedAttempts : Map<ICdnMetadata | null, ICdnAttemptMetadata> = new Map();
+  const initialCdnToRequest = getCdnToRequest();
+  if (initialCdnToRequest === undefined) {
+    throw new Error("No CDN to request");
+  }
+  return requestCdn(initialCdnToRequest);
+
+  /**
+   * Returns what is now the most prioritary CDN to request the wanted resource.
+   *
+   * A return value of `null` indicates that the resource can be requested
+   * through another mean than by doing an HTTP request.
+   *
+   * A return value of `undefined` indicates that there's no CDN left to request
+   * the resource.
+   * @returns {Object|null|undefined}
+   */
+  function getCdnToRequest() : ICdnMetadata | null | undefined {
+    if (cdns === null) {
+      const nullAttemptObject = missedAttempts.get(null);
+      if (nullAttemptObject !== undefined && nullAttemptObject.isBlacklisted) {
+        return undefined;
+      }
+      return null;
+    } else if (cdnPrioritizer === null) {
+      return getPrioritaryRequestableCdnFromSortedList(cdns);
+    } else {
+      const prioritized = cdnPrioritizer.getCdnPreferenceForResource(cdns);
+      return getPrioritaryRequestableCdnFromSortedList(prioritized);
+    }
+  }
+
+  /**
+   * Perform immediately the request for the given CDN.
+   *
+   * If it fails, forbid the CDN from being used - optionally and in some
+   * conditions, only temporarily, then try the next CDN according to
+   * previously-set delays (with a potential sleep before to respect them).
+   *
+   * Reject if both the request fails and there's no CDN left to use.
+   * @param {string|null} cdn
+   * @returns {Promise}
+   */
+  async function requestCdn(cdn : ICdnMetadata | null) : Promise<T> {
+    try {
+      const res = await performRequest(cdn, cancellationSignal);
+      return res;
+    } catch (error : unknown) {
+      if (TaskCanceller.isCancellationError(error)) {
+        throw error;
+      }
+
+      if (cdn !== null && cdnPrioritizer !== null) {
+        // We failed requesting the resource on this CDN.
+        // Globally give priority to the next CDN through the CdnPrioritizer.
+        cdnPrioritizer.downgradeCdn(cdn);
+      }
+
+      const currentErrorType = getRequestErrorType(error);
+
+      let missedAttemptsObj = missedAttempts.get(cdn);
+      if (missedAttemptsObj === undefined) {
+        missedAttemptsObj = { errorCounter: 1,
+                              lastErrorType: currentErrorType,
+                              blockedUntil: undefined,
+                              isBlacklisted: false };
+        missedAttempts.set(cdn, missedAttemptsObj);
+      } else {
+        if (currentErrorType !== missedAttemptsObj.lastErrorType) {
+          missedAttemptsObj.errorCounter = 1;
+          missedAttemptsObj.lastErrorType = currentErrorType;
+        } else {
+          missedAttemptsObj.errorCounter++;
+        }
+      }
+
+      if (!shouldRetry(error)) {
+        missedAttemptsObj.blockedUntil = undefined;
+        missedAttemptsObj.isBlacklisted = true;
+        return retryWithNextCdn(error);
+      }
+
+      const maxRetry = currentErrorType === REQUEST_ERROR_TYPES.Offline ?
+        maxRetryOffline :
+        maxRetryRegular;
+
+      if (missedAttemptsObj.errorCounter > maxRetry) {
+        missedAttemptsObj.blockedUntil = undefined;
+        missedAttemptsObj.isBlacklisted = true;
+      } else {
+        const errorCounter = missedAttemptsObj.errorCounter;
+        const delay = Math.min(baseDelay * Math.pow(2, errorCounter - 1),
+                               maxDelay);
+        const fuzzedDelay = getFuzzedDelay(delay);
+        missedAttemptsObj.blockedUntil = performance.now() + fuzzedDelay;
+      }
+
+      return retryWithNextCdn(error);
+    }
+  }
+
+  /**
+   * After a request error, find the new most prioritary CDN and perform the
+   * request with it, optionally after a delay.
+   *
+   * If there's no CDN left to test, reject the original request error.
+   * @param {*} prevRequestError
+   * @returns {Promise}
+   */
+  async function retryWithNextCdn(prevRequestError : unknown) : Promise<T> {
+    const nextCdn = getCdnToRequest();
+
+    if (cancellationSignal.isCancelled) {
+      throw cancellationSignal.cancellationError;
+    }
+
+    if (nextCdn === undefined) {
+      throw prevRequestError;
+    }
+
+    onRetry(prevRequestError);
+    if (cancellationSignal.isCancelled) {
+      throw cancellationSignal.cancellationError;
+    }
+
+    return waitPotentialBackoffAndRequest(nextCdn, prevRequestError);
+  }
+
+  /**
+   * Request the corresponding CDN after the optional backoff needed before
+   * requesting it.
+   *
+   * If a new CDN become prioritary in the meantime, request it instead, again
+   * awaiting its optional backoff delay if it exists.
+   * @param {string|null} nextWantedCdn
+   * @param {*} prevRequestError
+   * @returns {Promise}
+   */
+  function waitPotentialBackoffAndRequest(
+    nextWantedCdn: ICdnMetadata | null,
+    prevRequestError : unknown
+  ) : Promise<T> {
+    const nextCdnAttemptObj = missedAttempts.get(nextWantedCdn);
+    if (nextCdnAttemptObj === undefined ||
+        nextCdnAttemptObj.blockedUntil === undefined)
+    {
+      return requestCdn(nextWantedCdn);
+    }
+
+    const now = performance.now();
+    const blockedFor = nextCdnAttemptObj.blockedUntil - now;
+    if (blockedFor <= 0) {
+      return requestCdn(nextWantedCdn);
+    }
+
+    const canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+    return new Promise<T>((res, rej) => {
+      /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
+      cdnPrioritizer?.addEventListener("priorityChange", () => {
+        const updatedPrioritaryCdn = getCdnToRequest();
+        if (cancellationSignal.isCancelled) {
+          throw cancellationSignal.cancellationError;
+        }
+        if (updatedPrioritaryCdn === undefined) {
+          return rej(prevRequestError);
+        }
+        if (updatedPrioritaryCdn !== nextWantedCdn) {
+          canceller.cancel();
+          waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
+            .then(res, rej);
+        }
+      }, canceller.signal);
+
+      cancellableSleep(blockedFor, canceller.signal)
+        .then(() => requestCdn(nextWantedCdn).then(res, rej), noop);
+    });
+  }
+
+  /**
+   * Takes in input the list of CDN that can be used to request the resource, in
+   * a general preference order.
+   *
+   * Returns the actual most prioritary Cdn to request, based on the current
+   * attempts already done for that resource.
+   *
+   * Returns `undefined` if there's no Cdn left to request the resource.
+   * @param {Array.<Object>}
+   * @returns {Object|undefined}
+   */
+  function getPrioritaryRequestableCdnFromSortedList(
+    sortedCdns : ICdnMetadata[]
+  ) : ICdnMetadata | undefined {
+    if (missedAttempts.size === 0) {
+      return sortedCdns[0];
+    }
+    const now = performance.now();
+    return sortedCdns
+      .filter(c =>  missedAttempts.get(c)?.isBlacklisted !== true)
+      .reduce((
+        acc : [ICdnMetadata, number | undefined] | undefined,
+        x : ICdnMetadata
+      ) : [ICdnMetadata, number | undefined] => {
+        let blockedUntil = missedAttempts.get(x)?.blockedUntil;
+        if (blockedUntil !== undefined && blockedUntil <= now) {
+          blockedUntil = undefined;
+        }
+        if (acc === undefined) {
+          return [x, blockedUntil];
+        }
+        if (blockedUntil === undefined) {
+          if (acc[1] === undefined) {
+            return acc;
+          }
+          return [x, undefined];
+        }
+
+        return acc[1] === undefined  ? acc :
+          blockedUntil < acc[1] ? [x, blockedUntil] :
+          acc;
+      }, undefined)?.[0];
+  }
+}
+
+/**
+ * Lightweight version of the request algorithm, this time with only a simple
+ * Promise given.
+ * @param {Function} performRequest
+ * @param {Object} options
+ * @returns {Promise}
+ */
+export function scheduleRequestPromise<T>(
+  performRequest : () => Promise<T>,
+  options : IBackoffSettings,
+  cancellationSignal : CancellationSignal
+) : Promise<T> {
+  // same than for a single unknown CDN
+  return scheduleRequestWithCdns(null,
+                                 null,
+                                 performRequest,
+                                 options,
+                                 cancellationSignal);
+}
+
+/**
+ * Metadata associated to attempt(s) of requesting a resource through the same
+ * CDN.
+ *
+ * Each `ICdnAttemptMetadata` object should concern only one CDN.
+ */
+interface ICdnAttemptMetadata {
+  /**
+   * Count the amount of consecutive times an error of type `lastErrorType` has
+   * been encountered while requesting this resource though the concerned CDN.
+   *
+   * For example `1` means that the request through this CDN either failed for
+   * the first consecutive time or that it already failed just before but for an
+   * error with a different `lastErrorType` value.
+   * `2` means that after requesting this CDN two consecutive times, the request
+   * failed with an error with the same `lastErrorType` value.
+   * etc.
+   */
+  errorCounter : number;
+  /** The last type of error encountered when requesting through that CDN. */
+  lastErrorType : REQUEST_ERROR_TYPES;
+  /**
+   * Timestamp, in terms of `performance.now()`, until which it should be
+   * forbidden to request this CDN.
+   * Enforcing this delay allows to prevent making too much requests to a given
+   * CDN.
+   *
+   * `undefined` when either there is no enforced delay or when the CDN is
+   * blacklisted anyway (@see isBlacklisted)
+   */
+  blockedUntil : number | undefined;
+  /** If `true`, that request should not be requested at all anymore. */
+  isBlacklisted : boolean;
+}

package/src/core/init/content_time_boundaries_observer.ts

@@ -32,10 +32,12 @@ import Manifest, {
 import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import createSharedReference from "../../utils/reference";
+import createSharedReference, {
+  IReadOnlySharedReference,
+} from "../../utils/reference";
 import { IReadOnlyPlaybackObserver } from "../api";
 import {
-  IStreamOrchestratorEvent,
+  IAdaptationChangeEvent,
   IStreamOrchestratorPlaybackObservation,
 } from "../stream";
 import EVENTS from "./events_generators";
@@ -56,13 +58,13 @@ import { IWarningEvent } from "./types";
  *    theoretically playable.
  *
  * @param {Object} manifest
- * @param {Observable} streams
+ * @param {Object} lastAdaptationChange
  * @param {Object} playbackObserver
  * @returns {Observable}
  */
 export default function ContentTimeBoundariesObserver(
   manifest : Manifest,
-  streams : Observable<IStreamOrchestratorEvent>,
+  lastAdaptationChange : IReadOnlySharedReference<IAdaptationChangeEvent | null>,
   playbackObserver : IReadOnlyPlaybackObserver<IContentTimeObserverPlaybackObservation>
 
 ) : Observable<IContentDurationUpdateEvent | IWarningEvent> {
@@ -115,10 +117,10 @@ export default function ContentTimeBoundariesObserver(
     ignoreElements()
   );
 
-  const updateDurationAndTimeBoundsOnTrackChange$ = streams.pipe(
-    tap((message) => { // Update Manifest's bounds and duration if necessary
-      if (message.type === "adaptationChange") {
-        if (!manifest.isLastPeriodKnown) {
+  const updateDurationAndTimeBoundsOnTrackChange$ = lastAdaptationChange
+    .asObservable().pipe(
+      tap((message) => {
+        if (message === null || !manifest.isLastPeriodKnown) {
           return;
         }
         const lastPeriod = manifest.periods[manifest.periods.length - 1];
@@ -137,10 +139,8 @@ export default function ContentTimeBoundariesObserver(
             contentDuration.setValue(newDuration);
           }
         }
-      }
-    }),
-    ignoreElements()
-  );
+      }),
+      ignoreElements());
 
   return observableMerge(
     updateDurationOnManifestUpdate$,

package/src/core/init/initialize_media_source.ts

@@ -36,11 +36,13 @@ import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import log from "../../log";
 import { IKeySystemOption } from "../../public_types";
+import { ITransportPipelines } from "../../transports";
 import deferSubscriptions from "../../utils/defer_subscriptions";
 import { fromEvent } from "../../utils/event_emitter";
 import filterMap from "../../utils/filter_map";
 import objectAssign from "../../utils/object_assign";
 import { IReadOnlySharedReference } from "../../utils/reference";
+import TaskCanceller from "../../utils/task_canceller";
 import AdaptiveRepresentationSelector, {
   IAdaptiveRepresentationSelectorArguments,
 } from "../adaptive";
@@ -125,8 +127,21 @@ export interface IInitializeArguments {
   mediaElement : HTMLMediaElement;
   /** Limit the frequency of Manifest updates. */
   minimumManifestUpdateInterval : number;
-  /** Interface allowing to load segments */
-  segmentFetcherCreator : SegmentFetcherCreator;
+  /** Interface allowing to interact with the transport protocol */
+  transport : ITransportPipelines;
+  /** Configuration for the segment requesting logic. */
+  segmentRequestOptions : {
+    /** Maximum number of time a request on error will be retried. */
+    regularError : number | undefined;
+    /** Maximum number of time a request be retried when the user is offline. */
+    offlineError : number | undefined;
+    /**
+     * Amount of time after which a request should be aborted.
+     * `undefined` indicates that a default value is wanted.
+     * `-1` indicates no timeout.
+     */
+    requestTimeout : number | undefined;
+  };
   /** Emit the playback rate (speed) set by the user. */
   speed : IReadOnlySharedReference<number>;
   /** The configured starting position. */
@@ -177,14 +192,17 @@ export default function InitializeOnMediaSource(
     mediaElement,
     minimumManifestUpdateInterval,
     playbackObserver,
-    segmentFetcherCreator,
+    segmentRequestOptions,
     speed,
     startAt,
+    transport,
     textTrackOptions } : IInitializeArguments
 ) : Observable<IInitEvent> {
   /** Choose the right "Representation" for a given "Adaptation". */
   const representationEstimator = AdaptiveRepresentationSelector(adaptiveOptions);
 
+  const playbackCanceller = new TaskCanceller();
+
   /**
    * Create and open a new MediaSource object on the given media element on
    * subscription.
@@ -244,6 +262,14 @@ export default function InitializeOnMediaSource(
       const initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
       log.debug("Init: Initial time calculated:", initialTime);
 
+      const requestOptions = { lowLatencyMode,
+                               requestTimeout: segmentRequestOptions.requestTimeout,
+                               maxRetryRegular: segmentRequestOptions.regularError,
+                               maxRetryOffline: segmentRequestOptions.offlineError };
+      const segmentFetcherCreator = new SegmentFetcherCreator(transport,
+                                                              requestOptions,
+                                                              playbackCanceller.signal);
+
       const mediaSourceLoader = createMediaSourceLoader({
         bufferOptions: objectAssign({ textTrackOptions, drmSystemId },
                                     bufferOptions),
@@ -358,5 +384,6 @@ export default function InitializeOnMediaSource(
       }
     }));
 
-  return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()));
+  return observableMerge(loadContent$, mediaError$, drmEvents$.pipe(ignoreElements()))
+    .pipe(finalize(() => { playbackCanceller.cancel(); }));
 }

package/src/core/init/load_on_media_source.ts

@@ -31,12 +31,13 @@ import {
 import { MediaError } from "../../errors";
 import log from "../../log";
 import Manifest from "../../manifest";
-import { IReadOnlySharedReference } from "../../utils/reference";
+import createSharedReference, { IReadOnlySharedReference } from "../../utils/reference";
 import { IRepresentationEstimator } from "../adaptive";
 import { PlaybackObserver } from "../api";
 import { SegmentFetcherCreator } from "../fetchers";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator, {
+  IAdaptationChangeEvent,
   IStreamOrchestratorOptions,
 } from "../stream";
 import ContentTimeBoundariesObserver from "./content_time_boundaries_observer";
@@ -147,6 +148,11 @@ export default function createMediaSourceLoader(
     /** Emits event when streams are "locked", meaning they cannot load segments. */
     const lockedStream$ = new Subject<ILockedStreamEvent>();
 
+    /** Emit each time a new Adaptation is considered by the `StreamOrchestrator`. */
+    const lastAdaptationChange = createSharedReference<
+      IAdaptationChangeEvent | null
+    >(null);
+
     // Creates Observable which will manage every Stream for the given Content.
     const streams$ = StreamOrchestrator({ manifest, initialPeriod },
                                         streamObserver,
@@ -176,6 +182,9 @@ export default function createMediaSourceLoader(
           case "locked-stream":
             lockedStream$.next(evt.value);
             return EMPTY;
+          case "adaptationChange":
+            lastAdaptationChange.setValue(evt);
+            return observableOf(evt);
           default:
             return observableOf(evt);
         }
@@ -183,7 +192,7 @@ export default function createMediaSourceLoader(
     );
 
     const contentTimeObserver = ContentTimeBoundariesObserver(manifest,
-                                                              streams$,
+                                                              lastAdaptationChange,
                                                               streamObserver)
       .pipe(
         mergeMap((evt) => {

package/src/core/init/stall_avoider.ts

@@ -314,7 +314,10 @@ export default function StallAvoider(
       /** Position at which data is awaited. */
       const { position: stalledPosition } = rebuffering;
 
-      if (stalledPosition !== null && speed.getValue() > 0) {
+      if (stalledPosition !== null &&
+          stalledPosition !== undefined &&
+          speed.getValue() > 0)
+      {
         const skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore,
                                                                  manifest,
                                                                  stalledPosition);

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -363,7 +363,6 @@ export default function StreamOrchestrator(
           if (start >= end) {
             return EMPTY;
           }
-
           const canceller = new TaskCanceller();
           return fromCancellablePromise(canceller, () => {
             return segmentBuffer.removeBuffer(start, end, canceller.signal);