rx-player 4.4.1-dev.2025101500 → 4.4.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "4.4.1-dev.2025101500",
+  "version": "4.4.1",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/commonjs/index.js",
   "module": "./dist/es2017/index.js",
@@ -166,11 +166,11 @@
     "fmt:prettier:check": "prettier . --check",
     "fmt:rust": "cd ./src/parsers/manifest/dash/wasm-parser && cargo fmt",
     "fmt:rust:check": "cd ./src/parsers/manifest/dash/wasm-parser && cargo fmt --check",
-    "lint": "eslint src -c eslint.config.mjs",
-    "lint:all": "npm run lint && npm run lint:demo && npm run lint:scripts && npm run lint:tests",
-    "lint:demo": "eslint -c demo/eslint.config.mjs demo/scripts",
-    "lint:scripts": "eslint -c scripts/eslint.config.mjs --ext .js --ext .mjs --ext .cjs scripts",
-    "lint:tests": "eslint -c tests/eslint.config.mjs tests",
+    "lint": "eslint -c eslint.config.mjs src",
+    "lint:all": "eslint -c eslint.config.mjs",
+    "lint:demo": "eslint -c eslint.config.mjs demo",
+    "lint:scripts": "eslint -c eslint.config.mjs scripts",
+    "lint:tests": "eslint -c eslint.config.mjs tests",
     "list": "node scripts/list-npm-scripts.mjs",
     "prepublishOnly": "bash ./scripts/make_all_builds.sh",
     "releases:changelog": "node ./scripts/update_changelog.mjs",

package/src/README.md

@@ -34,13 +34,13 @@ it:
 -------------------------|- RxPlayer Main Thread ---------------------------
                          |
      Front-facing API    v
-     +---------------------------------------+      +----------------------+
-     |               Public API              | uses |      TracksStore     |
-     |          (./main_thread/api)          |----->|(./main_thread/tracks_|
-     +---------------------------------------+      |store)                |
-                 |                                  +----------------------+
-                 |                                  Facilitate track switching
- Initialize      | creates                          for the API
+     +---------------------------------------+    +--------------------+
+     |               Public API              |uses|     TracksStore    |
+     |          (./main_thread/api)          |--->|(./main_thread/track|
+     +---------------------------------------+    |s_store)            |
+                 |                                +--------------------+
+                 |                                 Facilitate track switching
+ Initialize      | creates                         for the API
  playback and    |
  create/connect  |        Negotiate content
  modules         v        decryption
@@ -52,49 +52,41 @@ it:
  |(./main_thread/init)|            creates          |  Text Displayer  |
  |                    | --------------------------->|(./main_thread/te |
  +--------------------+                             |xt_displayer)     |
-           |  ^                                     +------------------+
-           V  |                                                       ^
- +--------------------------------+                                   |
- |          CoreInterface         | Link `main_thread`                |
- | (./main_thread/core_interface) | to `core` logic                   |
- +--------------------------------+                                   |
-   |  ^                                                               |
-   |  |                                                               |
-   |  |                                                               |
-   |  | Message exchanges                                             |
-   |  |                                                               |
-   |  |                                                               |
----|--|----------- RxPlayer Core (May run in a WebWorker) ----------------
-   |  |                                                               |
-   |  |                                                               |
-   |  |                                                               |
-   |  |    Exchange messages with the main                            |
-   V  |    thread and process them.                                   |
-  +-----------------------+             +--------------------------+  |
-  |      Core Entry       |------------>|     Manifest Fetcher     |  |
-  |    (./core/entry)     |   creates   |(./core/fetchers/manifest)|  |
-  +-----------------------+             +--------------------------+  |
-     | Creates           |              Load and     |                |
-     V                   |              refresh the  | Ask to load    |
- +-------------------+   |              Manifest     | and parse the  |
- |                   |   | creates                   | Manifest       |
- | CMCD data builder |   |                           v                |
- |  (./core/cmcd)    |   |        +--------------------+              |   ` Internet
- |                   |   |        |                    |   request    |   `    ,,,,,
- +-------------------+   |        |      transport     |--------------+---`-->( CDN )
- Perform data collection |        |    (./transport)   |              |   `    `````
- for the "Common Media   |        |                    |<-----+       |   `
- Client Data" (CMCD)     |        +--------------------+       \      |
- scheme.                 |        Abstract the streaming        \     |
-                         |        protocol (e.g. DASH)           \    |
-                         |                                        \   |
-Stream (./core/stream)   |                                         \  +
-+------------------------|---------------------------------+        \  \
-|                        v                                 |         \  \
-| Create PeriodStreams  +----------------------------+     |    Ask to\  \
-| based on the position |      StreamOrchestrator    |     |    load   \  \
-| and settings          |(./core/stream/orchestrator)|     |    and     \  \
-|                       +----------------------------+     |    parse    \  \
+   |  ^                                             +------------------+
+   |  | Message exchanges                                          ^
+   |  |                                                            |
+---|--|----------- RxPlayer Core (May run in a WebWorker) ---------|---
+   |  |                                                            |
+   |  |  (*Only if running in a WebWorker)                         +----+
+   |  |  Exchange messages with the main                                |
+   V  |  thread and process them.                                       |
+  +---------------------------+         +----------------------------+  |
+  |                           | creates |                            |  |
+  |        Worker Main*       |-------->|       Manifest Fetcher     |  |
+  |   (./core/main/worker)    |         | (./core/fetchers/manifest) |  |
+  |                           |         |                            |  |
+  +---------------------------+         +----------------------------+  |
+     | Creates             |            Load and     |                  |
+     V                     |            refresh the  | Ask to load      |
+   +-------------------+   |            Manifest     | and parse the    |
+   |                   |   | creates                 | Manifest         |
+   | CMCD data builder |   |                         v                  |
+   |  (./core/cmcd)    |   |        +--------------------+              |   ` Internet
+   |                   |   |        |                    |   request    |   `    ,,,,,
+   +-------------------+   |        |      transport     |--------------+---`-->( CDN )
+   Perform data collection |        |    (./transport)   |              |   `    `````
+   for the "Common Media   |        |                    |<---+         |   `
+   Client Data" (CMCD)     |        +--------------------+     \        |
+   scheme.                 |        Abstract the streaming      \       |
+                           |        protocol (e.g. DASH)         \      |
+                           |                                      \     |
+Stream (./core/stream)     |                                       \    |
++--------------------------|-------------------------------+        \   |
+|                          v                               |         \  +
+| Create the right        +----------------------------+   |    Ask to\  \
+| PeriodStreams depending |      StreamOrchestrator    |   |    load   \  \
+| on the current position,|(./core/stream/orchestrator)|   |    and     \  \
+| and settings            +----------------------------+   |    parse    \  \
 |                          |            |            |     |    segments  \  \
 |                          | creates    |            |     |               \  \
 |                          |            |            |     |                \  +
@@ -158,7 +150,7 @@ Stream (./core/stream)   |                                         \  +
                     +-----------------------+  +-------------------------+     |
   Actually pushes   |      MediaSource      |  |      TextDisplayer      |     |
   audio and video   |       Interface       |  |      Message sender     |-----+
-  data to the right |        (./mse)        |  |      (./core/enry)      |
+  data to the right |        (./mse)        |  |      (./core/main)      |
   low-level buffers +-----------------------+  +-------------------------+
                                                Small interface
                                                facilitating communication
@@ -215,43 +207,161 @@ For the subdirectories and files in this directory not represented in that schem
   RxPlayer which will run in the WebWorker (and which will have to be loaded separately by
   the application).
 
-## Directfile mode
+## Multithread, Monothread and Directfile code paths
 
-The RxPlayer can also play content already natively decodable by the browser, e.g. mp4
-files or HLS playlists on Safari.
+There are actually three different main "code paths" that may be run, depending on the
+current content played.
 
-When playing such content, the code path is slightly different and simpler:
+The previous schema mostly illustrated the most complex code path of the three (the
+"multithread mode"). Yet, to be more exact we need to separate those three cases:
 
-```
-               +---------------------------------------------+
-               |               Application/UI                |
-               +---------------------------------------------+
-                         |
-                         | call RxPlayer API
-                         |
--------------------------|--- RxPlayer Main Thread ----------------------------
-                         |
-     Front-facing API    v
-     +---------------------------------------+      +-------------------------+
-     |               Public API              | uses | MediaElementTracksStore |
-     |          (./main_thread/api)          |----->|(./main_thread/tracks_sto|
-     +---------------------------------------+      |re)                      |
-                         |                          +-------------------------+
-     Manage playback of  | creates                  Handle track switching
-     a "directfile"      |                          using directly the media
-     content             V                          element's API (`audioTracks`,
-     +---------------------------------------+      `textTracks` etc.)
-     |       DirectfileContentInitializer    |
-     |          (./main_thread/init)         |
-     +---------------------------------------+
-                         |
-                         V
-                        ... Some other RxPlayer modules
-                            (All running in main thread)
-```
-
-As you can see, everything runs in main thread, a specialized module called the
-`DirectfileContentInitializer` is called by the API to start-up such contents and a
-specialized `MediaElementTracksStore` is handling tracks specifically for directfile
-contents (as they are handled differently than for other code paths, here trough API
-exposed by the browser).
+1. For "directfile" contents (contents directly decodable by the browser, e.g. mp4 files
+   or HLS playlists on Safari), the code path is the simplest and follows something like
+   this:
+
+   ```
+                  +---------------------------------------------+
+                  |               Application/UI                |
+                  +---------------------------------------------+
+                            |
+                            | call RxPlayer API
+                            |
+   -------------------------|--- RxPlayer Main Thread ----------------------------
+                            |
+        Front-facing API    v
+        +---------------------------------------+      +-------------------------+
+        |               Public API              | uses | MediaElementTracksStore |
+        |          (./main_thread/api)          |----->|(./main_thread/tracks_sto|
+        +---------------------------------------+      |re)                      |
+                            |                          +-------------------------+
+        Manage playback of  | creates                  Handle track switching
+        a "directfile"      |                          using directly the media
+        content             V                          element's API (`audioTracks`,
+        +---------------------------------------+      `textTracks` etc.)
+        |       DirectfileContentInitializer    |
+        |          (./main_thread/init)         |
+        +---------------------------------------+
+                            |
+                            V
+                           ... Some other RxPlayer modules
+                               (All running in main thread)
+   ```
+
+   As you can see, everything runs in main thread, a specialized module called the
+   `DirectfileContentInitializer` is called by the API to start-up such contents and a
+   specialized `MediaElementTracksStore` is handling tracks specifically for directfile
+   contents (as they are handled differently than for other code paths, here trough API
+   exposed by the browser).
+
+2. A second code path, we may call the "monothreaded code path" apply for non-directfile
+   contents (so, contents which rely on the MSE API instead) loaded in monothreaded mode,
+   which is the default.
+
+   It is much closer to the schema of the previous chapter:
+
+   ```
+                  +---------------------------------------------+
+                  |               Application/UI                |
+                  +---------------------------------------------+
+                            |
+                            | call RxPlayer API
+                            |
+   -------------------------|- RxPlayer Main Thread ---------------------------
+                            |
+        Front-facing API    v
+        +---------------------------------------+    +--------------------+
+        |               Public API              |uses|     TracksStore    |
+        |          (./main_thread/api)          |--->|(./main_thread/track|
+        +---------------------------------------+    |s_store)            |
+                            |                        +--------------------+
+                            |                        Facilitate track switching
+        Manage playback of  | creates                for the API
+        contents relying    |
+        on a MediaSource,   |
+        all in main thread  v
+        +---------------------------------------+
+        |      MediaSourceContentInitializer    | ----> ... Some other RxPlayer
+        |          (./main_thread/init)         |           modules not in ./core
+        +---------------------------------------+
+                                |
+        Actually load and parse |
+        the right manifest and  | creates
+        media segments          |
+        (here in main thread)   V
+        +--------------------------------------+
+        |              Core modules            |
+        |                (./core)              |
+        +--------------------------------------+
+   ```
+
+   As you can see, the part of `./main_thread/init` run by the API is this time different
+   (`MediaSourceContentInitializer`) and the track handling also goes to a differently
+   named `TracksStore` when compared to directfile contents.
+
+   I also summarized all core modules into a single block, you can refer to the previous
+   chapter to have some examples of what they are (you can look at modules in the `./core`
+   directory in that schema - or at the `./core` directory itself).
+
+3. A third code path, the "multithreaded code path" apply for non-directfile contents (so,
+   contents which rely on MSE API instead) loaded in "multithread mode" (which has to be
+   explicitely enabled by the application).
+
+   Here you get all the complexity of the previous chapter, with two threads running. To
+   repeat the schema than the one used for the other code paths here, you would have
+   something like:
+
+   ```
+                  +---------------------------------------------+
+                  |               Application/UI                |
+                  +---------------------------------------------+
+                            |
+                            | call RxPlayer API
+                            |
+   -------------------------|----- RxPlayer Main Thread ---------------------------
+                            |
+        Front-facing API    v
+        +---------------------------------------+    +--------------------+
+        |               Public API              |uses|     TracksStore    |
+        |          (./main_thread/api)          |--->|(./main_thread/track|
+        +---------------------------------------+    |s_store)            |
+                            |                        +--------------------+
+                            |                        Facilitate track switching
+        Manage playback of  | creates                for the API
+        contents relying    |
+        on a MediaSource,   |
+        in multiple threads v
+        +---------------------------------------+
+        |      MultiThreadContentInitializer    | ----> ... Some other RxPlayer
+        |          (./main_thread/init)         |           modules not in ./core
+        +---------------------------------------+
+                                |  ^
+                                |  | postMessage exchanges
+                                |  |
+        ------------------------|--|- RxPlayer WebWorker --------------------------
+                                |  |
+        Actually load and parse |  |
+        the right manifest and  |  |
+        media segments          |  |
+        (here in a Worker)      V  |
+        +--+--------------------------------+--+
+        |  |            Worker Main         |  |
+        |  |        (./core/main/worker)    |  |
+        |  +--------------------------------+  |
+        |              Core modules            |
+        |                (./core)              |
+        +--------------------------------------+
+   ```
+
+   This time, the part of `./main_thread/init` run by the API is the
+   `MultiThreadContentInitializer` and the track handling also goes through the
+   `TracksStore`, like for the monothreaded code path.
+
+   The main difference however is that now all core modules are running completely in a
+   WebWorker, meaning in another thread. It is the role of the
+   `MultiThreadContentInitializer` to send message to it and to process most of the
+   messages the WebWorker sends back.
+
+   Because this time, the core also has to reception and send backs messages from and to
+   the main thread, there's a supplementary core module involved than on the "monothreaded
+   code path", the "Worker Main". It then however relies on the exact same other core
+   modules than for the "monothreaded code path".