Add Nimble advertizer support

README.md

@@ -278,16 +278,12 @@ The following features are planned for upcoming releases:
 
 - Automatic aspect ratio detection
 - Picture-in-Picture (PiP)
-- Latency retention for asynchronous renditions
 - CEA-608 closed captions
 - VOD playback (DVR support)
 - VOD thumbnail previews
 - SEI timecodes support
 - WebTransport protocol
-- Nimble Advertizer integration
-- Sync mode
 - Screenshot capture
-- Splash/startup image
 - Extended Player API
 - OffscreenCanvas rendering
 - Resume from pause in DVR mode (no auto-jump to live)

index.html

@@ -58,6 +58,7 @@
           },
           workletLogs: true,
           latencyAdjustMethod: "fast-forward", // "fast-forward" | "seek"
+          syncBuffer: 3000,
         });
 
         window.nimio.on("nimio:play", (inst, contId) => {

package.json

@@ -19,7 +19,7 @@
   "devDependencies": {
     "@vitest/coverage-v8": "^3.2.4",
     "jsdom": "^26.1.0",
-    "prettier": "^3.5.3",
+    "prettier": "^3.8.1",
     "rollup-plugin-copy": "^3.5.0",
     "tseep": "^1.3.1",
     "vite": "^6.4.1",

src/advertizer/evaluator.js

@@ -0,0 +1,144 @@
+import { LoggersFactory } from "@/shared/logger";
+
+export class AdvertizerEvaluator {
+  #types = [];
+  #confIvalUs = 2_000_000;
+
+  constructor(instName, port) {
+    this._tracks = {};
+    this._switches = {};
+    this._swCnt = 0;
+
+    if (port) {
+      port.addEventListener("message", this._portMessageHandler.bind(this));
+      port.postMessage("transp-discont-eval-ready");
+    } else {
+      this._pendingActions = [];
+    }
+
+    this._logger = LoggersFactory.create(instName, "Advertizer Eval", port);
+  }
+
+  reset() {
+    this.clearPendingActions();
+  }
+
+  isApplicable() {
+    return this._swCnt > 0;
+  }
+
+  computeShift(curTsUs, availUs) {
+    // skip for a while if a track is being switched
+    if (this._tracks.video === null || this._tracks.audio === null) return 0;
+
+    let res = 0;
+    let preMatches = [];
+    let win = [Infinity, 0];
+    let del = {};
+    for (let j = 0; j < this.#types.length; j++) {
+      let trackId = this._tracks[this.#types[j]];
+      let switches = this._switches[trackId];
+      if (!switches) break;
+
+      for (let i = 0; i < switches.length; i++) {
+        if (switches[i].to < curTsUs) {
+          del[trackId] = i;
+          continue;
+        }
+        if (switches[i].from - curTsUs > this.#confIvalUs) {
+          break;
+        }
+        if (win[0] > switches[i].from || win[0] < curTsUs) {
+          win[0] = switches[i].from;
+        }
+        if (win[1] < switches[i].to) win[1] = switches[i].to;
+        preMatches.push(i);
+      }
+    }
+    if (preMatches.length === this.#types.length && win[0] - curTsUs < 3_000) {
+      let delta = win[1] - curTsUs;
+      // this._logger.debug(`Switch delta is ${delta / 1000}ms, curTs = ${curTsUs/1000}, to = ${win[1] / 1000}, from = ${win[0] / 1000}`);
+      if (delta + this._bufToKeep <= availUs) {
+        for (let j = 0; j < this.#types.length; j++) {
+          let switches = this._switches[this._tracks[this.#types[j]]];
+          switches.splice(0, preMatches[j] + 1);
+          this._logger.debug(
+            `Remove ${this.#types[j]} switches till ${preMatches[j] + 1}. Cur ts = ${curTsUs}. Left ${switches.length}`,
+          );
+        }
+        del = null;
+        res = delta;
+        this._logger.debug(
+          `Computed init switch shift ${res / 1000}ms to ${win[1]}`,
+        );
+      }
+    }
+    if (del) {
+      for (let tId in del) {
+        this._switches[tId].splice(0, del[tId] + 1);
+        this._logger.debug(
+          `Remove ${tId} switches till ${del[tId] + 1}. Cur ts = ${curTsUs}. Left ${this._switches[tId].length}`,
+        );
+      }
+    }
+
+    return res;
+  }
+
+  handleAction(data) {
+    switch (data.op) {
+      case "init-switch":
+        if (!this._switches[data.id]) {
+          this._switches[data.id] = [];
+        }
+        this._switches[data.id].push({
+          from: data.data.fromPtsUs,
+          to: data.data.toPtsUs,
+        });
+        this._swCnt++;
+        break;
+      case "main":
+        this._tracks[data.type] = data.id;
+        if (!this.#types.includes(data.type)) {
+          this.#types.push(data.type);
+        }
+        break;
+      case "rem":
+        if (this._switches[data.id]) {
+          this._swCnt -= this._switches[data.id].length;
+        }
+        this._switches[data.id] = undefined;
+        if (this._tracks[data.type] === data.id) {
+          this._tracks[data.type] = null;
+        }
+        break;
+      default:
+        this._logger.error(`Unknown action ${data.op}`);
+        break;
+    }
+  }
+
+  hasPendingActions() {
+    return !!this._pendingActions && this._pendingActions.length > 0;
+  }
+
+  clearPendingActions() {
+    if (this._pendingActions) this._pendingActions.length = 0;
+  }
+
+  get pendingActions() {
+    return this._pendingActions;
+  }
+
+  set bufferToKeep(valUs) {
+    this._bufToKeep = valUs;
+  }
+
+  _portMessageHandler(event) {
+    const msg = event.data;
+    if (!msg || msg.aux) return;
+    if (msg.type === "transp-track-action") {
+      this.handleAction(msg.data);
+    }
+  }
+}

src/audio/config.js

@@ -25,7 +25,7 @@ export class AudioConfig {
     this._numberOfChannels = config.numberOfChannels;
     this._sampleCount = config.sampleCount;
 
-    return config;
+    return this;
   }
 
   smpCntToTsUs(smpCnt) {
@@ -34,9 +34,9 @@ export class AudioConfig {
   }
 
   tsUsToSmpCnt(tsUs) {
-    let smpCnt = (tsUs / 1000) * (this._sampleRate / 1000);
-    if (smpCnt < 0) smpCnt = 0;
-    return (smpCnt + 0.5) >>> 0;
+    let k = tsUs > 0 ? 1 : -1;
+    let smpCnt = ((k * tsUs) / 1000) * (this._sampleRate / 1000);
+    return k * ((smpCnt + 0.5) >>> 0);
   }
 
   isCompatible(config) {

src/audio/nimio-processor.js

@@ -5,11 +5,13 @@ import { AudioConfig } from "./config";
 import { LoggersFactory } from "@/shared/logger";
 import { LatencyController } from "@/latency-controller";
 import { WsolaProcessor } from "@/media/processors/wsola-processor";
+import { AdvertizerEvaluator } from "@/advertizer/evaluator";
 
 class AudioNimioProcessor extends AudioWorkletProcessor {
   constructor(options) {
     super(options);
 
+    this.port.start();
     LoggersFactory.setLevel(options.processorOptions.logLevel);
     LoggersFactory.toggleWorkletLogs(options.processorOptions.enableLogs);
     this._logger = LoggersFactory.create(
@@ -32,19 +34,26 @@ class AudioNimioProcessor extends AudioWorkletProcessor {
       this._sampleCount,
     );
 
+    this._advertizerEval = new AdvertizerEvaluator(
+      options.processorOptions.instanceName,
+      this.port,
+    );
+
     this._idle = options.processorOptions.idle;
     this._targetLatencyMs = options.processorOptions.latency;
     this._latencyCtrl = new LatencyController(
       options.processorOptions.instanceName,
       this._stateManager,
       this._audioConfig,
+      this._advertizerEval,
       {
         latency: this._targetLatencyMs,
         tolerance: options.processorOptions.latencyTolerance,
         adjustMethod: options.processorOptions.latencyAdjustMethod,
         video: options.processorOptions.videoEnabled,
         audio: !this._idle,
         port: this.port,
+        syncBuffer: options.processorOptions.syncBuffer,
       },
     );
     this._latencyCtrl.speedFn = this._setSpeed.bind(this);
@@ -86,17 +95,14 @@ class AudioNimioProcessor extends AudioWorkletProcessor {
     }
 
     if (!this._idle) {
-      this._stateManager.incSilenceUs(this._samplesDurationUs(sampleCount));
+      let durUs = (this._audioConfig.smpCntToTsUs(sampleCount) + 0.5) >>> 0;
+      this._stateManager.incSilenceUs(durUs);
       if (!this._audioBuffer.isShareable) {
         this._audioBuffer.ensureCapacity();
       }
     }
   }
 
-  _samplesDurationUs(sampleCount) {
-    return (this._audioConfig.smpCntToTsUs(sampleCount) + 0.5) >>> 0;
-  }
-
   _setSpeed(speed, availableMs) {
     if (this._speed === speed) return;
     this._speed = speed;

src/audio/volume-controller.js

@@ -22,7 +22,7 @@ class AudioVolumeController {
 
     this._storageId = settings.volumeId;
     this._lastVolume = this._getStoredVolume();
-    if (settings.muted) {
+    if (settings.muted || this._muted) {
       this._gainer.gain.value = 0;
       this._muted = true;
       this._eventBus.emit("nimio:muted", true);