senza-sdk 4.5.8 → 4.6.0

package/src/implementation/senzaShakaPlayer.js

@@ -1,7 +1,7 @@
 import { SenzaShakaPlayer as SenzaShakaInterface, shaka } from "../interface/senzaShakaPlayer";
 import * as shakaDebug from "shaka-player/dist/shaka-player.compiled.debug.js";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
-import { ONE_DAY_SECONDS } from "./remotePlayer.js";
+import { ONE_DAY_SECONDS, VOD_INIT_SEEK_EPSILON_SEC } from "./remotePlayer.js";
 import { sdkLogger, SwitchMode } from "./utils";
 import moment from "moment";
 import set from "lodash.set";
@@ -156,12 +156,19 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
     _seekCounterAfterLoad = 0;
 
     /**
-     * When true, the next `seeked` is Shaka jumping to live-edge time after load; skip background pause logic.
+     * When true, the next `seeked` is Shaka jumping to live-edge / VOD startTime after load; skip background pause logic.
      * @private
      * @type {boolean}
      */
     _ignoreNextSeekedForInit = false;
 
+    /**
+     * Start position (seconds) from the most recent load(). Used to ignore Shaka's VOD init seeking/seeked.
+     * @private
+     * @type {number}
+     */
+    _loadStartPosition = 0;
+
     /**
      * Whether the player should call lifecycle.moveToForeground on pause, remote ended/error, unload, and destroy.
      * Only when auto-background is enabled (including streamer overrides) and the UI moved to background via the
@@ -185,8 +192,16 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             this._ignoreNextSeekedForInit = false;
         },
         "seeking": () => {
-            // If the first seeking after load started from time 0, and the current time is a UTC time (live asset), ignore the next seeked event to avoid background pause logic.
-            if (this._seekCounterAfterLoad < 1 && this._loadStartedAtZero && this.videoElement.currentTime > ONE_DAY_SECONDS) {
+            // Ignore the first seeking after load when it is Shaka's initialization jump:
+            // - Live: currentTime is a UTC wall-clock time (> one day in seconds)
+            // - VOD: currentTime is within epsilon of this._loadStartPosition
+            const isFirstSeekAfterLoadAtZero = this._seekCounterAfterLoad < 1 && this._loadStartedAtZero;
+            const isLiveInitSeek = isFirstSeekAfterLoadAtZero && this.videoElement.currentTime > ONE_DAY_SECONDS;
+            const isVodInitSeek = isFirstSeekAfterLoadAtZero
+                && this._loadStartPosition > 0
+                && Math.abs(this.videoElement.currentTime - this._loadStartPosition) <= VOD_INIT_SEEK_EPSILON_SEC;
+            if (isLiveInitSeek || isVodInitSeek) {
+                sdkLogger.info("senzaShakaPlayer seeking: ignoring next seeked for init");
                 this._ignoreNextSeekedForInit = true;
             } else {
                 // Another seeking before seeked means this is no longer the load initialization jump.
@@ -820,6 +835,9 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             startTime = -minInitialLiveOffset;
         }
 
+        // Used to ignore Shaka's init seeking/seeked when currentTime matches load start.
+        this._loadStartPosition = startTime ?? 0;
+
         // This callback will be activated when the manifest is loaded. It will trigger load of the remote player.
         // This will ensure that the remote player is loaded only after the manifest is loaded by local player.
         const responseFilterCallback = async (type, response) => {

package/src/implementation/utils.js

@@ -140,6 +140,26 @@ export function isAudioSyncConfigured() {
     return clientUiAudioSettings?.enabled && clientUiAudioSettings?.from_cdn && clientUiAudioSettings?.ui_sync_enabled;
 }
 
+/** Dual decode is enabled only when both the client capability and the common settings report it as enabled.
+ * @returns {boolean}
+ */
+export function isDualDecodeEnabled() {
+    const sessionInfoObj = sessionInfo.sessionInfoObj;
+    return !!(sessionInfoObj?.capabilities?.dualDecode?.enabled && sessionInfoObj?.settings?.common?.dualDecode?.enabled);
+}
+
+/** Get the ABR surface size that dual decode video should be scaled to before being sent to the client.
+ * The values are read from the client capabilities and coerced to numbers (the platform may report them as strings).
+ * @returns {{width: number, height: number}}
+ */
+export function getDualDecodeAbrSurfaceSize() {
+    const abrSurfaceSize = sessionInfo.sessionInfoObj?.capabilities?.dualDecode?.abrSurfaceSize;
+    return {
+        width: Number(abrSurfaceSize?.width ?? 1280),
+        height: Number(abrSurfaceSize?.height ?? 720)
+    };
+}
+
 export function isSubtitlesTranslationAllowed() {
     return sessionInfo.sessionInfoObj?.settings?.["ui-streamer"]?.allowSubtitlesTranslation === true;
 }
@@ -181,7 +201,14 @@ export const StreamType = Object.freeze({
 
 export const SwitchMode = Object.freeze({
     NON_SEAMLESS: 0,
-    SEAMLESS: 1
+    SEAMLESS: 1,
+    DUAL_DECODE: 2
+});
+
+/** Layer on which dual-decode ABR video is composited (remotePlayer.setVideoRect). */
+export const VideoLayer = Object.freeze({
+    FRONT: 0,
+    BACK: 1
 });
 
 export const SeekState = Object.freeze({

package/src/interface/overlay.js

@@ -10,7 +10,6 @@ import { noop } from "./utils.js";
 /**
  * Overlay is a singleton class that manages displaying UI frames as image overlays. The image can be displayed over background video playback.
  * It can be used in any lifecycle state.
- * @private
  * @fires error
  */
 class Overlay extends EventTarget {

package/src/interface/remotePlayer.js

@@ -132,6 +132,8 @@ export class RemotePlayerError extends Error {
  * | 6502      | Player            | unload() was called while previous unload/load was still in progress                            |
  * | 6503      | Player            | The remote player api call has invalid parameters                                               |
  * | 6504      | Player            | The remote player api internal error                                                            |
+ * | 6505      | Player            | setVideoRect() was called with an invalid rectangle (out of the window bounds or negative)      |
+ * | 6506      | Player            | setVideoRect() or setVideoFullscreen() was called when dual decode is not enabled               |
  * | 8001      | Player            | Error pulling manifest. bad parameters                                                          |
  * | 8002      | Player            | Error pulling manifest. filters returned no data                                                |
  * | 8003      | Player            | Error pulling manifest. fetch error                                                             |
@@ -246,6 +248,19 @@ class RemotePlayer extends EventTarget {
         SPOKEN_SUBTITLES: "9"
     };
 
+    /**
+     * @typedef {Object} VideoLayer
+     * @property {number} FRONT - The ABR video is rendered in front of the UI video.
+     * @property {number} BACK - The ABR video is rendered behind the UI video.
+     */
+    /** The layer on which the remote player (ABR) video is rendered when dual decode is enabled.
+     * @type {VideoLayer}
+     */
+    VideoLayer = Object.freeze({
+        FRONT: 0,
+        BACK: 1
+    });
+
     /** get the player configuration.
      * @returns {Config}
      * */
@@ -325,7 +340,7 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.pause");
     }
 
-    /** Stop playback
+    /** Stop playback of all streams (audio, video and subtitles).
      * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg
      * */
@@ -333,6 +348,34 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.stop");
     }
 
+    /** Set the position and size of the remote player (ABR) video on screen, or make it fullscreen.
+     * Only available when dual decode is enabled, otherwise throws.
+     * The given rectangle is expressed in the UI coordinate space (window.innerWidth/window.innerHeight)
+     * and is validated and scaled to the client's ABR surface size before being sent to the client.
+     * @param {Object} rect
+     * @param {number} [rect.x] horizontal position in px (UI coordinate space)
+     * @param {number} [rect.y] vertical position in px (UI coordinate space)
+     * @param {number} [rect.width] width in px (UI coordinate space)
+     * @param {number} [rect.height] height in px (UI coordinate space)
+     * @param {boolean} [rect.fullScreen=false] when true, the video is rendered fullscreen and the rect is ignored
+     * @param {VideoLayer} [rect.layer=VideoLayer.FRONT] which layer the ABR video should be rendered on
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    setVideoRect(rect) {
+        return noop("RemotePlayer.setVideoRect", rect);
+    }
+
+    /** Make the remote player (ABR) video fullscreen on the given layer.
+     * Only available when dual decode is enabled, otherwise throws.
+     * @param {VideoLayer} [layer=VideoLayer.FRONT] which layer the ABR video should be rendered on
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    setVideoFullscreen(layer = this.VideoLayer.FRONT) {
+        return noop("RemotePlayer.setVideoFullscreen", layer);
+    }
+
     /** Get the currently loaded uri, or empty string is player is not loaded.
      * @returns {string} loaded uri
      * @throws {RemotePlayerError} error object contains code & msg

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.5.8";
+export const version = "4.6.0";