stormcloud-video-player 0.8.77 → 0.8.78

package/lib/index.cjs

@@ -2465,6 +2465,9 @@ function requiresMediaPipelineResetAfterAds() {
     var browser = detectBrowser();
     return browser.name === "Samsung Tizen" && ((_browser_tizenVersion = browser.tizenVersion) !== null && _browser_tizenVersion !== void 0 ? _browser_tizenVersion : 0) >= 5;
 }
+function prefersProgressiveAdMedia() {
+    return detectBrowser().isSmartTV;
+}
 function getBrowserConfigOverrides() {
     var browser = detectBrowser();
     var overrides = {};
@@ -3331,6 +3334,7 @@ function createHlsAdPlayer(contentVideo, options) {
         var probe = adVideoElement !== null && adVideoElement !== void 0 ? adVideoElement : document.createElement("video");
         var pageIsHttps = typeof location !== "undefined" && location.protocol === "https:";
         var target = getMediaTargetQuality();
+        var deprioritizeHls = prefersProgressiveAdMedia();
         var accepted = [];
         mediaFiles.forEach(function(file, index) {
             var isHls = isHlsMediaFile(file);
@@ -3361,19 +3365,24 @@ function createHlsAdPlayer(contentVideo, options) {
                 var bitrateDiff = Math.abs((file.bitrate || 5e3) * 1e3 - target.bitrate);
                 score = resolutionDiff * 2 + bitrateDiff / 1e3;
             }
+            var deprioritizedHls = deprioritizeHls && isHls;
             accepted.push({
                 file: file,
                 score: score,
-                insecure: insecure
+                insecure: insecure,
+                deprioritizedHls: deprioritizedHls
             });
             logFunnel("media_candidate", _object_spread_props(_object_spread({}, details), {
                 reason: "accepted",
-                why: insecure ? "insecure_http_deprioritized" : "playable",
+                why: insecure ? "insecure_http_deprioritized" : deprioritizedHls ? "hls_deprioritized_on_tv" : "playable",
                 score: score
             }));
         });
         accepted.sort(function(a, b) {
             if (a.insecure !== b.insecure) return a.insecure ? 1 : -1;
+            if (a.deprioritizedHls !== b.deprioritizedHls) {
+                return a.deprioritizedHls ? 1 : -1;
+            }
             return a.score - b.score;
         });
         return accepted.map(function(entry) {
@@ -5046,8 +5055,8 @@ function createHlsAdPlayer(contentVideo, options) {
             console.warn("[HlsAdPlayer] Error preparing ad video for new source:", error);
         }
     }
-    function recreateAdVideoElement() {
-        console.log("[HlsAdPlayer] Recreating ad video element (single-decoder platform)");
+    function recreateAdVideoElement(reason) {
+        console.log("[HlsAdPlayer] Recreating ad video element (".concat(reason, ")"));
         teardownAdEventListeners();
         prepareVideoElementForNewSource();
         if (adVideoElement) {
@@ -5091,8 +5100,9 @@ function createHlsAdPlayer(contentVideo, options) {
     }
     function resetVideoElementForNextSource() {
         clearStallWatchdog();
-        if (requiresMediaPipelineResetAfterAds()) {
-            recreateAdVideoElement();
+        var previousSourceUsedHlsJs = adHls !== void 0;
+        if (requiresMediaPipelineResetAfterAds() || previousSourceUsedHlsJs) {
+            recreateAdVideoElement(previousSourceUsedHlsJs ? "after hls.js source" : "single-decoder platform");
             setupAdEventListeners();
         } else {
             prepareVideoElementForNewSource();
@@ -12580,6 +12590,181 @@ var AdBreakOrchestrator = /*#__PURE__*/ function() {
     ]);
     return AdBreakOrchestrator;
 }();
+// src/player/ContentHealthWatchdog.ts
+var POLL_INTERVAL_MS = 2e3;
+var STALL_THRESHOLD_MS = 12e3;
+var POST_BREAK_GRACE_MS = 5e4;
+var MAX_BREAK_SUPPRESSION_MS = 10 * 60 * 1e3;
+var SELF_INFLICTED_PAUSE_WINDOW_MS = 5e3;
+var HEALTHY_PLAYBACK_SECONDS = 5;
+var MAX_NORMAL_ADVANCE_PER_TICK_S = 4;
+var LIGHT_STEP_COOLDOWN_MS = 1e4;
+var RELOAD_BASE_COOLDOWN_MS = 15e3;
+var RELOAD_MAX_COOLDOWN_MS = 12e4;
+var ContentHealthWatchdog = /*#__PURE__*/ function() {
+    function ContentHealthWatchdog(host) {
+        var _this = this;
+        _class_call_check(this, ContentHealthWatchdog);
+        this.host = host;
+        this.armed = false;
+        this.userPaused = false;
+        this.wasInBreak = false;
+        this.breakStartedAt = 0;
+        this.stuckBreakLogged = false;
+        this.graceUntil = 0;
+        this.lastPosition = 0;
+        this.lastProgressAt = 0;
+        this.lastRealPlaybackAt = 0;
+        this.healthySeconds = 0;
+        this.step = 0;
+        this.nextActionAt = 0;
+        this.lastActionAt = 0;
+        this.onPlaying = function() {
+            if (_this.host.isAdPlaying()) return;
+            _this.armed = true;
+            _this.userPaused = false;
+        };
+        this.onPause = function() {
+            if (_this.host.isBreakActive() || _this.host.isAdPlaying() || Date.now() - _this.lastActionAt < SELF_INFLICTED_PAUSE_WINDOW_MS) {
+                return;
+            }
+            _this.userPaused = true;
+        };
+        this.onPlay = function() {
+            _this.userPaused = false;
+        };
+    }
+    _create_class(ContentHealthWatchdog, [
+        {
+            key: "start",
+            value: function start() {
+                var _this = this;
+                if (this.intervalId !== void 0) return;
+                var video = this.host.video;
+                video.addEventListener("playing", this.onPlaying);
+                video.addEventListener("pause", this.onPause);
+                video.addEventListener("play", this.onPlay);
+                this.resetProgress(Date.now());
+                this.intervalId = window.setInterval(function() {
+                    return _this.tick();
+                }, POLL_INTERVAL_MS);
+            }
+        },
+        {
+            key: "stop",
+            value: function stop() {
+                if (this.intervalId !== void 0) {
+                    clearInterval(this.intervalId);
+                    this.intervalId = void 0;
+                }
+                var video = this.host.video;
+                video.removeEventListener("playing", this.onPlaying);
+                video.removeEventListener("pause", this.onPause);
+                video.removeEventListener("play", this.onPlay);
+                this.armed = false;
+                this.step = 0;
+            }
+        },
+        {
+            key: "resetProgress",
+            value: function resetProgress(now) {
+                this.lastPosition = this.host.video.currentTime;
+                this.lastProgressAt = now;
+            }
+        },
+        {
+            key: "tick",
+            value: function tick() {
+                var now = Date.now();
+                var video = this.host.video;
+                var hidden = typeof document !== "undefined" && document.visibilityState === "hidden";
+                if (!this.armed || this.userPaused || hidden || video.ended || !this.host.isLiveStream() || !this.host.hasHlsInstance()) {
+                    this.resetProgress(now);
+                    return;
+                }
+                var breakActive = this.host.isBreakActive() || this.host.isAdPlaying();
+                if (breakActive && !this.wasInBreak) {
+                    this.wasInBreak = true;
+                    this.breakStartedAt = now;
+                    this.stuckBreakLogged = false;
+                }
+                if (breakActive && now - this.breakStartedAt < MAX_BREAK_SUPPRESSION_MS) {
+                    this.resetProgress(now);
+                    return;
+                }
+                if (breakActive && !this.stuckBreakLogged) {
+                    this.stuckBreakLogged = true;
+                    console.warn("[ContentWatchdog] Ad break state active for over ".concat(MAX_BREAK_SUPPRESSION_MS / 6e4, " min — monitoring content anyway"));
+                }
+                if (!breakActive && this.wasInBreak) {
+                    this.wasInBreak = false;
+                    this.graceUntil = now + POST_BREAK_GRACE_MS;
+                    this.resetProgress(now);
+                    return;
+                }
+                var currentTime = video.currentTime;
+                var delta = currentTime - this.lastPosition;
+                this.lastPosition = currentTime;
+                if (delta > 0.25 && delta <= MAX_NORMAL_ADVANCE_PER_TICK_S && !video.paused) {
+                    this.lastProgressAt = now;
+                    this.lastRealPlaybackAt = now;
+                    this.healthySeconds += delta;
+                    if (this.step > 0 && this.healthySeconds >= HEALTHY_PLAYBACK_SECONDS) {
+                        console.log("[ContentWatchdog] Content playback recovered after ".concat(this.step, " recovery step(s)"));
+                        this.step = 0;
+                        this.nextActionAt = 0;
+                    }
+                    return;
+                }
+                if (now < this.graceUntil) {
+                    this.lastProgressAt = now;
+                    return;
+                }
+                if (now - this.lastProgressAt < STALL_THRESHOLD_MS || now < this.nextActionAt) {
+                    return;
+                }
+                this.recover(now);
+            }
+        },
+        {
+            key: "recover",
+            value: function recover(now) {
+                var video = this.host.video;
+                var state = "t=".concat(video.currentTime.toFixed(2), " paused=").concat(video.paused, " readyState=").concat(video.readyState, " networkState=").concat(video.networkState, " error=").concat(video.error ? video.error.code : "none");
+                var stalledForS = ((now - (this.lastRealPlaybackAt || this.lastProgressAt)) / 1e3).toFixed(0);
+                var fullReloadOnly = this.host.requiresMediaPipelineResetAfterAds();
+                var action = fullReloadOnly || this.step >= 2 ? "reload" : this.step === 0 ? "recover_media_error" : "restart_load";
+                console.warn("[ContentWatchdog] Content stalled for ".concat(stalledForS, "s — ").concat(action, " (step ").concat(this.step + 1, ") — ").concat(state));
+                this.lastActionAt = now;
+                this.healthySeconds = 0;
+                if (action === "recover_media_error") {
+                    this.host.recoverMediaError();
+                    this.nextActionAt = now + LIGHT_STEP_COOLDOWN_MS;
+                } else if (action === "restart_load") {
+                    var liveSyncPos = this.host.getLiveSyncPosition();
+                    var position = liveSyncPos != null && liveSyncPos > video.currentTime ? liveSyncPos : video.currentTime;
+                    if (position !== video.currentTime) {
+                        video.currentTime = position;
+                    }
+                    this.host.restartHlsLoad(position);
+                    this.nextActionAt = now + LIGHT_STEP_COOLDOWN_MS;
+                } else {
+                    var reloadIndex = fullReloadOnly ? this.step : this.step - 2;
+                    var cooldown = Math.min(RELOAD_BASE_COOLDOWN_MS * Math.pow(2, reloadIndex), RELOAD_MAX_COOLDOWN_MS);
+                    this.host.reloadLiveStream();
+                    this.nextActionAt = now + cooldown;
+                }
+                this.step++;
+                this.resetProgress(now);
+                if (video.paused) {
+                    var _video_play;
+                    (_video_play = video.play()) === null || _video_play === void 0 ? void 0 : _video_play.catch(function() {});
+                }
+            }
+        }
+    ]);
+    return ContentHealthWatchdog;
+}();
 // src/player/StormcloudVideoPlayer.ts
 var StormcloudVideoPlayer = /*#__PURE__*/ function() {
     function StormcloudVideoPlayer(config) {
@@ -12710,6 +12895,36 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
                 return _this.palNonce.sendAdTouch(event);
             }
         }, this.timing, this.adConfig, this.cueManager, this.placeholder);
+        this.contentWatchdog = new ContentHealthWatchdog({
+            video: this.video,
+            isLiveStream: function isLiveStream() {
+                return _this.hlsEngine.isLiveStream;
+            },
+            hasHlsInstance: function hasHlsInstance() {
+                return !!_this.hlsEngine.hls;
+            },
+            isBreakActive: function isBreakActive() {
+                return _this.adBreak.inAdBreak || _this.adBreak.isBreakActive();
+            },
+            isAdPlaying: function isAdPlaying() {
+                return _this.adPlayer.isAdPlaying();
+            },
+            requiresMediaPipelineResetAfterAds: function requiresMediaPipelineResetAfterAds1() {
+                return requiresMediaPipelineResetAfterAds();
+            },
+            getLiveSyncPosition: function getLiveSyncPosition() {
+                return _this.hlsEngine.getLiveSyncPosition();
+            },
+            recoverMediaError: function recoverMediaError() {
+                return _this.hlsEngine.recoverMediaError();
+            },
+            restartHlsLoad: function restartHlsLoad(position) {
+                return _this.hlsEngine.restartLoadAt(position);
+            },
+            reloadLiveStream: function reloadLiveStream() {
+                return _this.hlsEngine.reloadLiveStream();
+            }
+        });
     }
     _create_class(StormcloudVideoPlayer, [
         {
@@ -13030,6 +13245,9 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
                     }
                 };
                 this.video.addEventListener("emptied", this.emptiedHandler);
+                if (this.config.contentStallWatchdog !== false) {
+                    this.contentWatchdog.start();
+                }
             }
         },
         {
@@ -13514,6 +13732,7 @@ var StormcloudVideoPlayer = /*#__PURE__*/ function() {
             key: "destroy",
             value: function destroy() {
                 var _this_adPlayer;
+                this.contentWatchdog.stop();
                 this.adBreak.cancelScheduledRequest();
                 this.timing.destroy();
                 this.adBreak.clearPendingAdBreak();