rx-player 3.30.0-dev.2023022200 → 3.30.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.30.0-dev.2023022200",
+  "version": "3.30.0",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [
@@ -97,6 +97,7 @@
     "core-js": "3.28.0",
     "esbuild": "0.17.10",
     "eslint": "8.34.0",
+    "eslint-plugin-ban": "1.6.0",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-jsdoc": "40.0.0",
     "eslint-plugin-react": "7.32.2",

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.30.0-dev.2023022200
+sonar.projectVersion=3.30.0
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

package/src/compat/browser_detection.ts

@@ -24,71 +24,118 @@ interface IIE11Document extends Document {
   documentMode? : unknown;
 }
 
-// true on IE11
-// false on Edge and other IEs/browsers.
-const isIE11 : boolean =
-  !isNode &&
-  typeof (window as IIE11WindowObject).MSInputMethodContext !== "undefined" &&
-  typeof (document as IIE11Document).documentMode !== "undefined";
-
-// true for IE / Edge
-const isIEOrEdge : boolean = isNode ?
-  false :
-  navigator.appName === "Microsoft Internet Explorer" ||
-  navigator.appName === "Netscape" &&
-  /(Trident|Edge)\//.test(navigator.userAgent);
-
-const isEdgeChromium: boolean = !isNode &&
-                                navigator.userAgent.toLowerCase().indexOf("edg/") !== -1;
-
-const isFirefox : boolean = !isNode &&
-                            navigator.userAgent.toLowerCase().indexOf("firefox") !== -1;
-
-const isSamsungBrowser : boolean = !isNode &&
-                                   /SamsungBrowser/.test(navigator.userAgent);
-
-const isTizen : boolean = !isNode &&
-                          /Tizen/.test(navigator.userAgent);
-
-const isWebOs : boolean = !isNode &&
-                          navigator.userAgent.indexOf("Web0S") >= 0;
-
-// Inspired form: http://webostv.developer.lge.com/discover/specifications/web-engine/
-// Note: even that page doesn't correspond to what we've actually seen in the
-// wild
-const isWebOs2021 : boolean = isWebOs &&
-                              (
-                                /[Ww]eb[O0]S.TV-2021/.test(navigator.userAgent) ||
-                                /[Cc]hr[o0]me\/79/.test(navigator.userAgent)
-                              );
-const isWebOs2022 : boolean = isWebOs &&
-                              (
-                                /[Ww]eb[O0]S.TV-2022/.test(navigator.userAgent) ||
-                                /[Cc]hr[o0]me\/87/.test(navigator.userAgent)
-                              );
+/** Edge Chromium, regardless of the device */
+let isEdgeChromium = false;
 
-interface ISafariWindowObject extends Window {
-  safari? : { pushNotification? : { toString() : string } };
-}
+/** IE11, regardless of the device */
+let isIE11 = false;
+
+/** IE11 or Edge __Legacy__ (not Edge Chromium), regardless of the device */
+let isIEOrEdge = false;
+
+/** Firefox, regardless of the device */
+let isFirefox = false;
 
 /** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
-const isSafariDesktop : boolean =
-  !isNode && (
+let isSafariDesktop = false;
+
+/** `true` on Safari on an iPhone, iPad & iPod platform */
+let isSafariMobile = false;
+
+/** Samsung's own browser application */
+let isSamsungBrowser = false;
+
+/** `true` on devices where Tizen is the OS (e.g. Samsung TVs). */
+let isTizen = false;
+
+/** `true` on devices where WebOS is the OS (e.g. LG TVs). */
+let isWebOs = false;
+
+/** `true` specifically for WebOS 2021 version. */
+let isWebOs2021 = false;
+
+/** `true` specifically for WebOS 2022 version. */
+let isWebOs2022 = false;
+
+/** `true` for Panasonic devices. */
+let isPanasonic = false;
+
+((function findCurrentBrowser() : void {
+  if (isNode) {
+    return ;
+  }
+
+  // 1 - Find out browser between IE/Edge Legacy/Edge Chromium/Firefox/Safari
+
+  if (typeof (window as IIE11WindowObject).MSInputMethodContext !== "undefined" &&
+      typeof (document as IIE11Document).documentMode !== "undefined")
+  {
+    isIE11 = true;
+    isIEOrEdge = true;
+  } else if (
+    navigator.appName === "Microsoft Internet Explorer" ||
+    navigator.appName === "Netscape" &&
+    /(Trident|Edge)\//.test(navigator.userAgent)
+  ) {
+    isIEOrEdge = true;
+  } else if (navigator.userAgent.toLowerCase().indexOf("edg/") !== -1) {
+    isEdgeChromium = true;
+  } else if (navigator.userAgent.toLowerCase().indexOf("firefox") !== -1) {
+    isFirefox = true;
+  } else if (typeof navigator.platform === "string" &&
+             /iPad|iPhone|iPod/.test(navigator.platform))
+  {
+    isSafariMobile = true;
+  } else if (
     Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
     (window as ISafariWindowObject).safari?.pushNotification?.toString() ===
       "[object SafariRemoteNotification]"
-  );
+  ) {
+    isSafariDesktop = true;
+  }
 
-/** `true` on Safari on an iPhone, iPad & iPod platform */
-const isSafariMobile : boolean = !isNode &&
-                                 typeof navigator.platform === "string" &&
-                                 /iPad|iPhone|iPod/.test(navigator.platform);
+  // 2 - Find out specific device/platform information
+
+  // Samsung browser e.g. on Android
+  if (/SamsungBrowser/.test(navigator.userAgent)) {
+    isSamsungBrowser = true;
+  }
+
+  if (/Tizen/.test(navigator.userAgent)) {
+    isTizen = true;
+
+  // Inspired form: http://webostv.developer.lge.com/discover/specifications/web-engine/
+  // Note: even that page doesn't correspond to what we've actually seen in the
+  // wild
+  } else if (/[Ww]eb[O0]S/.test(navigator.userAgent)) {
+    isWebOs = true;
+
+    if (
+      /[Ww]eb[O0]S.TV-2022/.test(navigator.userAgent) ||
+      /[Cc]hr[o0]me\/87/.test(navigator.userAgent)
+    ) {
+      isWebOs2022 = true;
+    } else if (
+      /[Ww]eb[O0]S.TV-2021/.test(navigator.userAgent) ||
+      /[Cc]hr[o0]me\/79/.test(navigator.userAgent)
+    ) {
+      isWebOs2021 = true;
+    }
+  } else if (/[Pp]anasonic/.test(navigator.userAgent)) {
+    isPanasonic = true;
+  }
+})());
+
+interface ISafariWindowObject extends Window {
+  safari? : { pushNotification? : { toString() : string } };
+}
 
 export {
   isEdgeChromium,
   isIE11,
   isIEOrEdge,
   isFirefox,
+  isPanasonic,
   isSafariDesktop,
   isSafariMobile,
   isSamsungBrowser,

package/src/compat/can_reuse_media_keys.ts

@@ -1,4 +1,7 @@
-import { isWebOs } from "./browser_detection";
+import {
+  isPanasonic,
+  isWebOs,
+} from "./browser_detection";
 
 /**
  * Returns `true` if a `MediaKeys` instance (the  `Encrypted Media Extension`
@@ -13,5 +16,5 @@ import { isWebOs } from "./browser_detection";
  * @returns {boolean}
  */
 export default function canReuseMediaKeys() : boolean {
-  return !isWebOs;
+  return !isWebOs && !isPanasonic;
 }

package/src/core/api/debug/buffer_size_graph.ts

@@ -72,7 +72,6 @@ export default class BufferSizeGraph {
     const gridWidth = width / TIME_SAMPLES_MS;
 
     drawData();
-    // drawGrid();
 
     /**
      * Get more appropriate maximum buffer size to put on top of the graph

package/src/core/api/public_api.ts

@@ -364,7 +364,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.30.0-dev.2023022200";
+    this.version = /* PLAYER_VERSION */"3.30.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -980,7 +980,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       // Previous call could have performed all kind of side-effects, thus,
       // we re-check the current state associated to the RxPlayer
       if (this.state === PLAYER_STATES.ENDED && this._priv_stopAtEnd) {
-        currentContentCanceller.cancel();
+        this.stop();
       }
     }, { emitCurrentValue: true, clearSignal: currentContentCanceller.signal });
 
@@ -2985,7 +2985,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return mediaElementTrackChoiceManager;
   }
 }
-Player.version = /* PLAYER_VERSION */"3.30.0-dev.2023022200";
+Player.version = /* PLAYER_VERSION */"3.30.0";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/core/decrypt/__tests__/__global__/utils.ts

@@ -40,48 +40,68 @@ import {
 import { CancellationSignal } from "../../../../utils/task_canceller";
 
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
-export const defaultKSConfig = [{
-  audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { contentType: "audio/webm;codecs=opus" } ],
-  distinctiveIdentifier: "optional" as const,
-  initDataTypes: ["cenc"] as const,
-  persistentState: "optional" as const,
-  sessionTypes: ["temporary"] as const,
-  videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { contentType: "video/webm;codecs=\"vp8\"" } ],
-}];
+export const defaultKSConfig = [
+  {
+    audioCapabilities: [ { contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { contentType: "audio/webm;codecs=opus" } ],
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: [ { contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { contentType: "video/webm;codecs=\"vp8\"" } ],
+  },
+  {
+    audioCapabilities: undefined,
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: undefined,
+  },
+];
 
 /**
  * Default "com.microsoft.playready.recommendation" MediaKeySystemAccess
  * configuration used by the RxPlayer.
  */
-export const defaultPRRecommendationKSConfig = [{
-  audioCapabilities: [ { robustness: "3000",
-                         contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { robustness: "3000",
-                         contentType: "audio/webm;codecs=opus" },
-                       { robustness: "2000",
-                         contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
-                       { robustness: "2000",
-                         contentType: "audio/webm;codecs=opus" } ],
-  distinctiveIdentifier: "optional" as const,
-  initDataTypes: ["cenc"] as const,
-  persistentState: "optional" as const,
-  sessionTypes: ["temporary"] as const,
-  videoCapabilities: [ { robustness: "3000",
-                         contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { robustness: "3000",
-                         contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { robustness: "3000",
-                         contentType: "video/webm;codecs=\"vp8\"" },
-                       { robustness: "2000",
-                         contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
-                       { robustness: "2000",
-                         contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
-                       { robustness: "2000",
-                         contentType: "video/webm;codecs=\"vp8\"" } ],
-}];
+export const defaultPRRecommendationKSConfig = [
+  {
+    audioCapabilities: [ { robustness: "3000",
+                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { robustness: "3000",
+                           contentType: "audio/webm;codecs=opus" },
+                         { robustness: "2000",
+                           contentType: "audio/mp4;codecs=\"mp4a.40.2\"" },
+                         { robustness: "2000",
+                           contentType: "audio/webm;codecs=opus" } ],
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: [ { robustness: "3000",
+                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { robustness: "3000",
+                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { robustness: "3000",
+                           contentType: "video/webm;codecs=\"vp8\"" },
+                         { robustness: "2000",
+                           contentType: "video/mp4;codecs=\"avc1.4d401e\"" },
+                         { robustness: "2000",
+                           contentType: "video/mp4;codecs=\"avc1.42e01e\"" },
+                         { robustness: "2000",
+                           contentType: "video/webm;codecs=\"vp8\"" } ],
+  },
+  {
+    audioCapabilities: undefined,
+    distinctiveIdentifier: "optional" as const,
+    initDataTypes: ["cenc"] as const,
+    persistentState: "optional" as const,
+    sessionTypes: ["temporary"] as const,
+    videoCapabilities: undefined,
+  },
+];
 
 /** Default Widevine MediaKeySystemAccess configuration used by the RxPlayer. */
 export const defaultWidevineConfig = (() => {
@@ -104,9 +124,10 @@ export const defaultWidevineConfig = (() => {
             { contentType: "audio/webm;codecs=opus",
               robustness } ];
   });
-  return defaultKSConfig.map(conf => {
-    return { ...conf,  audioCapabilities, videoCapabilities };
-  });
+  return [
+    { ...defaultKSConfig[0],  audioCapabilities, videoCapabilities },
+    defaultKSConfig[1],
+  ];
 })();
 
 /**

package/src/core/decrypt/find_key_system.ts

@@ -155,7 +155,9 @@ function buildKeySystemConfigurations(
   if (keySystem.distinctiveIdentifierRequired === true) {
     distinctiveIdentifier = "required";
   }
-  const { EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
+  const { EME_DEFAULT_AUDIO_CODECS,
+          EME_DEFAULT_VIDEO_CODECS,
+          EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
           EME_DEFAULT_PLAYREADY_ROBUSTNESSES } = config.getCurrent();
 
   // Set robustness, in order of consideration:
@@ -206,42 +208,41 @@ function buildKeySystemConfigurations(
   // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
 
   const videoCapabilities: IMediaCapability[] =
-    flatMap(videoRobustnesses, (robustness) =>
-      ["video/mp4;codecs=\"avc1.4d401e\"",
-       "video/mp4;codecs=\"avc1.42e01e\"",
-       "video/webm;codecs=\"vp8\""].map(contentType => {
-        return robustness !== undefined ? { contentType, robustness } :
-                                          { contentType };
-      }));
+    flatMap(videoRobustnesses, (robustness) => {
+      return EME_DEFAULT_VIDEO_CODECS.map(contentType => {
+        return robustness === undefined ? { contentType } :
+                                          { contentType, robustness };
+      });
+    });
 
   const audioCapabilities: IMediaCapability[] =
-    flatMap(audioRobustnesses, (robustness) =>
-      ["audio/mp4;codecs=\"mp4a.40.2\"",
-       "audio/webm;codecs=opus"].map(contentType => {
-        return robustness !== undefined ? { contentType, robustness } :
-                                          { contentType };
-      }));
-
-  // TODO Re-test with a set contentType but an undefined robustness on the
-  // STBs on which this problem was found.
-  //
-  // add another with no {audio,video}Capabilities for some legacy browsers.
-  // As of today's spec, this should return NotSupported but the first
-  // candidate configuration should be good, so we should have no downside
-  // doing that.
-  // initDataTypes: ["cenc"],
-  // videoCapabilities: undefined,
-  // audioCapabilities: undefined,
-  // distinctiveIdentifier,
-  // persistentState,
-  // sessionTypes,
-
-  return [{ initDataTypes: ["cenc"],
-            videoCapabilities,
-            audioCapabilities,
-            distinctiveIdentifier,
-            persistentState,
-            sessionTypes }];
+    flatMap(audioRobustnesses, (robustness) => {
+      return EME_DEFAULT_AUDIO_CODECS.map(contentType => {
+        return robustness === undefined ? { contentType } :
+                                          { contentType, robustness };
+      });
+    });
+
+  const wantedMediaKeySystemConfiguration : MediaKeySystemConfiguration = {
+    initDataTypes: ["cenc"],
+    videoCapabilities,
+    audioCapabilities,
+    distinctiveIdentifier,
+    persistentState,
+    sessionTypes,
+  };
+
+  return [
+    wantedMediaKeySystemConfiguration,
+
+    // Some legacy implementations have issues with `audioCapabilities` and
+    // `videoCapabilities`, so we're including a supplementary
+    // `MediaKeySystemConfiguration` without those properties.
+    { ...wantedMediaKeySystemConfiguration,
+      audioCapabilities: undefined ,
+      videoCapabilities: undefined,
+    } as unknown as MediaKeySystemConfiguration,
+  ];
 }
 
 /**

package/src/core/decrypt/session_events_listener.ts

@@ -210,23 +210,36 @@ export default function SessionEventsListener(
   ) : Promise<BufferSource | null> {
     let timeoutId : number | undefined;
     return new Promise<BufferSource | null>((res, rej) => {
-      log.debug("DRM: Calling `getLicense`", messageType);
-      const getLicense = keySystemOptions.getLicense(message, messageType);
-      const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
-        10 * 1000 :
-        getLicenseConfig.timeout;
+      try {
+        log.debug("DRM: Calling `getLicense`", messageType);
+        const getLicense = keySystemOptions.getLicense(message, messageType);
+        const getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
+          10 * 1000 :
+          getLicenseConfig.timeout;
 
-      if (getLicenseTimeout >= 0) {
-        timeoutId = setTimeout(() => {
-          rej(new GetLicenseTimeoutError(
-            `"getLicense" timeout exceeded (${getLicenseTimeout} ms)`
-          ));
-        }, getLicenseTimeout) as unknown as number;
+        if (getLicenseTimeout >= 0) {
+          timeoutId = setTimeout(() => {
+            rej(new GetLicenseTimeoutError(
+              `"getLicense" timeout exceeded (${getLicenseTimeout} ms)`
+            ));
+          }, getLicenseTimeout) as unknown as number;
+        }
+        Promise.resolve(getLicense)
+          .then(clearTimeoutAndResolve, clearTimeoutAndReject);
+      } catch (err) {
+        clearTimeoutAndReject(err);
+      }
+      function clearTimeoutAndResolve(data : BufferSource | null) {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
+        res(data);
       }
-      Promise.resolve(getLicense).then(res, rej);
-    }).finally(() => {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId);
+      function clearTimeoutAndReject(err : unknown) {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
+        rej(err);
       }
     });
   }

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

@@ -368,18 +368,28 @@ export async function scheduleRequestWithCdns<T>(
           throw cancellationSignal.cancellationError;
         }
         if (updatedPrioritaryCdn === undefined) {
-          return rej(prevRequestError);
+          return cleanAndReject(prevRequestError);
         }
         if (updatedPrioritaryCdn !== nextWantedCdn) {
           canceller.cancel();
           waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-            .then(res, rej);
+            .then(cleanAndResolve, cleanAndReject);
         }
       }, canceller.signal);
 
       cancellableSleep(blockedFor, canceller.signal)
-        .then(() => requestCdn(nextWantedCdn).then(res, rej), noop);
-    }).finally(unlinkCanceller);
+        .then(() => requestCdn(nextWantedCdn)
+          .then(cleanAndResolve, cleanAndReject), noop);
+
+      function cleanAndResolve(response : T) {
+        unlinkCanceller();
+        res(response);
+      }
+      function cleanAndReject(err : unknown) {
+        unlinkCanceller();
+        rej(err);
+      }
+    });
   }
 
   /**

package/src/core/init/utils/media_duration_updater.ts

@@ -209,7 +209,7 @@ function setMediaSourceDuration(
     if (maxBufferedEnd < mediaSource.duration) {
       try {
         log.info("Init: Updating duration to what is currently buffered", maxBufferedEnd);
-        mediaSource.duration = newDuration;
+        mediaSource.duration = maxBufferedEnd;
       } catch (err) {
         log.warn("Duration Updater: Can't update duration on the MediaSource.",
                  err instanceof Error ? err : "");

package/src/core/init/utils/rebuffering_controller.ts

@@ -123,7 +123,7 @@ export default class RebufferingController
       playbackRateUpdater.dispose();
     });
 
-    let prevFreezingState : { attemptTimestamp : number } | null;
+    let prevFreezingState : { attemptTimestamp : number } | null = null;
 
     this._playbackObserver.listen((observation) => {
       const discontinuitiesStore = this._discontinuitiesStore;

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -19,6 +19,8 @@ import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
 import { Representation } from "../../../manifest";
+import cancellableSleep from "../../../utils/cancellable_sleep";
+import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
 import {
   createMappedReference,
@@ -325,19 +327,27 @@ export default function AdaptationStream<T>(
           defaultCode: "NONE",
           defaultReason: "Unknown `RepresentationStream` error",
         });
-        if (formattedError.code === "BUFFER_FULL_ERROR") {
+        if (formattedError.code !== "BUFFER_FULL_ERROR") {
+          representationStreamCallbacks.error(err);
+        } else {
           const wba = wantedBufferAhead.getValue();
           const lastBufferGoalRatio = bufferGoalRatioMap.get(representation.id) ?? 1;
-          if (lastBufferGoalRatio <= 0.25 || wba * lastBufferGoalRatio <= 2) {
+          // 70%, 49%, 34.3%, 24%, 16.81%, 11.76%, 8.24% and 5.76%
+          const newBufferGoalRatio = lastBufferGoalRatio * 0.7;
+          if (newBufferGoalRatio <= 0.05 || wba * newBufferGoalRatio <= 2) {
             throw formattedError;
           }
-          bufferGoalRatioMap.set(representation.id, lastBufferGoalRatio - 0.25);
-          return createRepresentationStream(representation,
-                                            terminateCurrentStream,
-                                            fastSwitchThreshold,
-                                            representationStreamCallbacks);
+          bufferGoalRatioMap.set(representation.id, newBufferGoalRatio);
+
+          // We wait 4 seconds to let the situation evolve by itself before
+          // retrying loading segments with a lower buffer goal
+          cancellableSleep(4000, adapStreamCanceller.signal).then(() => {
+            return createRepresentationStream(representation,
+                                              terminateCurrentStream,
+                                              fastSwitchThreshold,
+                                              representationStreamCallbacks);
+          }).catch(noop);
         }
-        representationStreamCallbacks.error(err);
       },
       terminating() {
         terminatingRepStreamCanceller.cancel();