rx-player 3.30.1-dev.2023032800 → 3.31.0-dev.2023052200

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.30.1-dev.2023032800",
+  "version": "3.31.0-dev.2023052200",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [
@@ -45,7 +45,7 @@
     "demo": "node ./scripts/generate_full_demo.js --production-mode",
     "demo:min": "node ./scripts/generate_full_demo.js --production-mode --minify",
     "demo:watch": "node ./scripts/generate_full_demo.js --watch --production-mode",
-    "doc": "rm -rf doc/generated; node ./scripts/doc-generator/index.js doc/ doc/generated \"$(cat VERSION)\"",
+    "doc": "docgen.ico doc/ doc/generated \"$(cat VERSION)\"",
     "lint": "eslint src -c .eslintrc.js",
     "lint:demo": "eslint -c demo/full/.eslintrc.js demo/full/scripts",
     "lint:tests": "eslint tests/**/*.js --ignore-pattern '/tests/performance/bundle*'",
@@ -80,58 +80,57 @@
     "next-tick": "1.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.21.0",
-    "@babel/plugin-transform-runtime": "7.21.0",
-    "@babel/preset-env": "7.20.2",
+    "@babel/core": "7.21.4",
+    "@babel/plugin-transform-runtime": "7.21.4",
+    "@babel/preset-env": "7.21.4",
     "@babel/preset-react": "7.18.6",
     "@types/chai": "4.3.4",
-    "@types/jest": "29.4.0",
+    "@types/jest": "29.5.0",
     "@types/mocha": "10.0.1",
-    "@types/node": "18.14.0",
-    "@types/react": "18.0.28",
+    "@types/node": "18.15.11",
+    "@types/react": "18.0.33",
     "@types/react-dom": "18.0.11",
     "@types/sinon": "10.0.13",
-    "@typescript-eslint/eslint-plugin": "5.53.0",
-    "@typescript-eslint/eslint-plugin-tslint": "5.53.0",
-    "@typescript-eslint/parser": "5.53.0",
+    "@typescript-eslint/eslint-plugin": "5.57.1",
+    "@typescript-eslint/eslint-plugin-tslint": "5.57.1",
+    "@typescript-eslint/parser": "5.57.1",
     "arraybuffer-loader": "1.0.8",
     "babel-loader": "9.1.2",
     "chai": "4.3.7",
-    "cheerio": "1.0.0-rc.12",
-    "core-js": "3.28.0",
-    "esbuild": "0.17.10",
-    "eslint": "8.34.0",
+    "core-js": "3.30.0",
+    "docgen.ico": "^0.2.2",
+    "esbuild": "0.17.15",
+    "eslint": "8.37.0",
     "eslint-plugin-ban": "1.6.0",
     "eslint-plugin-import": "2.27.5",
-    "eslint-plugin-jsdoc": "40.0.0",
+    "eslint-plugin-jsdoc": "40.1.1",
     "eslint-plugin-react": "7.32.2",
     "esm": "3.2.25",
     "express": "4.18.2",
-    "highlight.js": "11.7.0",
+    "github-buttons": "2.27.0",
     "html-entities": "2.3.3",
-    "jest": "29.4.3",
-    "jest-environment-jsdom": "29.4.3",
+    "jest": "29.5.0",
+    "jest-environment-jsdom": "29.5.0",
     "karma": "6.4.1",
     "karma-chrome-launcher": "3.1.1",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-webpack": "5.0.0",
-    "markdown-it": "13.0.1",
     "mocha": "10.2.0",
     "mocha-loader": "5.1.5",
     "raw-loader": "4.0.2",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "regenerator-runtime": "0.13.11",
-    "rimraf": "4.1.2",
+    "rimraf": "4.4.1",
     "semver": "7.3.8",
-    "sinon": "15.0.1",
-    "terser-webpack-plugin": "5.3.6",
-    "ts-jest": "29.0.5",
+    "sinon": "15.0.3",
+    "terser-webpack-plugin": "5.3.7",
+    "ts-jest": "29.1.0",
     "ts-loader": "9.4.2",
     "tslint": "6.1.3",
-    "typescript": "4.9.5",
-    "webpack": "5.75.0",
+    "typescript": "5.0.3",
+    "webpack": "5.77.0",
     "webpack-bundle-analyzer": "4.8.0",
     "webpack-cli": "5.0.1"
   },

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.30.1-dev.2023032800
+sonar.projectVersion=3.31.0-dev.2023052200
 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

@@ -60,6 +60,9 @@ let isWebOs2022 = false;
 /** `true` for Panasonic devices. */
 let isPanasonic = false;
 
+/** `true` for the PlayStation 5 game console. */
+let isPlayStation5 = false;
+
 ((function findCurrentBrowser() : void {
   if (isNode) {
     return ;
@@ -101,7 +104,9 @@ let isPanasonic = false;
     isSamsungBrowser = true;
   }
 
-  if (/Tizen/.test(navigator.userAgent)) {
+  if (navigator.userAgent.indexOf("PlayStation 5") !== -1) {
+    isPlayStation5 = true;
+  } else if (/Tizen/.test(navigator.userAgent)) {
     isTizen = true;
 
   // Inspired form: http://webostv.developer.lge.com/discover/specifications/web-engine/
@@ -136,6 +141,7 @@ export {
   isIEOrEdge,
   isFirefox,
   isPanasonic,
+  isPlayStation5,
   isSafariDesktop,
   isSafariMobile,
   isSamsungBrowser,

package/src/compat/has_issues_with_high_media_source_duration.ts

@@ -0,0 +1,27 @@
+import { isPlayStation5 } from "./browser_detection";
+
+/**
+ * Some platforms have issues when the `MediaSource`'s `duration` property
+ * is set to a very high value (playback freezes) but not when setting it
+ * to `Infinity`, which is what the HTML spec as of now (2023-05-15) recommends
+ * for live contents.
+ *
+ * However setting the `MediaSource`'s `duration` property to `Infinity` seems
+ * more risky, considering all platforms we now support, than setting it at a
+ * relatively high ~2**32 value which is what we do generally.
+ *
+ * Moreover, setting it to `Infinity` require us to use another MSE API,
+ * `setLiveSeekableRange` to properly allow seeking. We're used to MSE issues so
+ * I'm not too confident of using another MSE API for all platforms directly.
+ *
+ * So this methods just return `true` based on a whitelist of platform for which
+ * it has been detected that high `duration` values cause issues but setting it
+ * to Infinity AND playing with `setLiveSeekableRange` does not.
+ *
+ * @returns {boolean}
+ */
+export default function hasIssuesWithHighMediaSourceDuration(): boolean {
+  // For now only seen on the Webkit present in the PlayStation 5, for which the
+  // alternative is known to work.
+  return isPlayStation5;
+}

package/src/core/adaptive/__tests__/buffer_based_chooser.test.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { ScoreConfidenceLevel } from "../utils/representation_score_calculator";
+
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-var-requires */
@@ -47,12 +49,25 @@ describe("BufferBasedChooser", () => {
       bufferGap: 0,
       speed: 1,
       currentBitrate: undefined,
-      currentScore: 4,
+      currentScore: { score: 4, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(1);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
+      bufferGap: 0,
+      speed: 1,
+      currentBitrate: undefined,
+      currentScore: { score: 4, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(1);
+    expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
+      bufferGap: 0,
+      speed: 1,
+      currentBitrate: undefined,
+      currentScore: { score: 1, confidenceLevel: ScoreConfidenceLevel.LOW },
     })).toEqual(1);
     expect(new BufferBasedChooser([1, 2, 3]).getEstimate({
       bufferGap: 0,
       speed: 1,
-      currentScore: 1,
+      currentBitrate: undefined,
+      currentScore: { score: 1, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(1);
   });
 
@@ -76,7 +91,7 @@ describe("BufferBasedChooser", () => {
   });
 
   /* eslint-disable max-len */
-  it("should go to the next bitrate if the current one is maintainable and we have more buffer than the next level", () => {
+  it("should not go to the next bitrate if we don't have a high enough maintainability score", () => {
   /* eslint-enable max-len */
     const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
@@ -86,82 +101,82 @@ describe("BufferBasedChooser", () => {
       bufferGap: 16,
       speed: 1,
       currentBitrate: 10,
-      currentScore: 1.01,
-    })).toEqual(20);
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(10);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 1.01,
-    })).toEqual(40);
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
-    })).toEqual(40);
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
-    })).toEqual(40);
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
-    })).toEqual(40);
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
       bufferGap: 30,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
-      currentScore: 100,
-    })).toEqual(40);
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
   });
 
   /* eslint-disable max-len */
-  it("should go to the next bitrate if the current one is maintainable and we have the buffer corresponding to the next level", () => {
+  it("should go to the next bitrate if the current one is maintainable and we have more buffer than the next level", () => {
   /* eslint-enable max-len */
     const logger = { debug: jest.fn() };
     jest.mock("../../../log", () => ({ __esModule: true as const,
                                        default: logger }));
     const BufferBasedChooser = jest.requireActual("../buffer_based_chooser").default;
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 15,
+      bufferGap: 16,
       speed: 1,
       currentBitrate: 10,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 30,
       speed: 0, // 0 is a special case
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
   });
 
@@ -176,31 +191,31 @@ describe("BufferBasedChooser", () => {
       bufferGap: 6,
       speed: 1,
       currentBitrate: 10,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(10);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 1.01,
+      currentScore: { score: 1.15, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 1,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 10,
+      bufferGap: 13,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.30, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
   });
 
@@ -216,13 +231,13 @@ describe("BufferBasedChooser", () => {
       bufferGap: 100000000000,
       speed: 1,
       currentBitrate: 40,
-      currentScore: 1000000,
+      currentScore: { score: 1000000, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
     expect(new BufferBasedChooser([10, 20, 40, 40]).getEstimate({
       bufferGap: 100000000000,
       speed: 1,
       currentBitrate: 40,
-      currentScore: 1000000,
+      currentScore: { score: 1000000, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(40);
   });
 
@@ -237,31 +252,115 @@ describe("BufferBasedChooser", () => {
       bufferGap: 15,
       speed: 2,
       currentBitrate: 10,
-      currentScore: 1.01,
+      currentScore: { score: 2, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(10);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
       speed: 2,
       currentBitrate: 20,
-      currentScore: 1.01,
+      currentScore: { score: 2, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
       speed: 100,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
       speed: 100,
       currentBitrate: 20,
-      currentScore: 100,
+      currentScore: { score: 100, confidenceLevel: ScoreConfidenceLevel.HIGH },
     })).toEqual(20);
     expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
-      bufferGap: 20,
+      bufferGap: 22,
+      speed: 3,
+      currentBitrate: 20,
+      currentScore: { score: 3, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(20);
+  });
+
+  /* eslint-disable max-len */
+  it("should lower bitrate if the current one is not maintainable due to the speed", () => {
+  /* eslint-enable max-len */
+    const logger = { debug: jest.fn() };
+    jest.mock("../../../log", () => ({ __esModule: true as const,
+                                       default: logger }));
+    const BufferBasedChooser = jest.requireActual("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 15,
+      speed: 2,
+      currentBitrate: 10,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 2,
+      currentBitrate: 20,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 3,
+      currentBitrate: 20,
+      currentScore: { score: 2.5, confidenceLevel: ScoreConfidenceLevel.HIGH },
+    })).toEqual(10);
+  });
+
+  /* eslint-disable max-len */
+  it("should not lower bitrate if the current one is not maintainable due to the speed but confidence on the score is low", () => {
+  /* eslint-enable max-len */
+    const logger = { debug: jest.fn() };
+    jest.mock("../../../log", () => ({ __esModule: true as const,
+                                       default: logger }));
+    const BufferBasedChooser = jest.requireActual("../buffer_based_chooser").default;
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 15,
+      speed: 2,
+      currentBitrate: 10,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(10);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 2,
+      currentBitrate: 20,
+      currentScore: undefined,
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 2,
+      currentBitrate: 20,
+      currentScore: { score: 1.9, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 20, 40]).getEstimate({
+      bufferGap: 22,
+      speed: 100,
+      currentBitrate: 20,
+      currentScore: { score: 99, confidenceLevel: ScoreConfidenceLevel.LOW },
+    })).toEqual(20);
+    expect(new BufferBasedChooser([10, 20, 40]).getEstimate({
+      bufferGap: 22,
       speed: 3,
       currentBitrate: 20,
-      currentScore: 2.1,
+      currentScore: { score: 2.5, confidenceLevel: ScoreConfidenceLevel.LOW },
     })).toEqual(20);
   });
 

package/src/core/adaptive/adaptive_representation_selector.ts

@@ -317,8 +317,7 @@ function getEstimateReference(
       const timeRanges = val.buffered;
       const bufferGap = getLeftSizeOfRange(timeRanges, position.last);
       const { representation } = val.content;
-      const scoreData = scoreCalculator.getEstimate(representation);
-      const currentScore = scoreData?.[0];
+      const currentScore = scoreCalculator.getEstimate(representation);
       const currentBitrate = representation.bitrate;
       const observation = { bufferGap, currentBitrate, currentScore, speed };
       currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);