Lecture : repli CPU quand le GPU sature, plus de spinner infini

Serveur chargé ou VRAM limite : NVENC refuse d'ouvrir l'encodeur
(OpenEncodeSessionEx failed: out of memory), FFmpeg meurt en une
seconde et la playlist part en 502. Chaque relance retombait sur le
même GPU saturé : le flux restait illisible.

- Serveur : un échec imputable au GPU (NVENC, CUDA, mémoire) relance
  la session une fois en libx264, sous le même identifiant — les
  segments suivent sans que le lecteur s'en aperçoive. Direct, VOD et
  enregistrements
- Le GPU est écarté 2 min après une panne : les sessions suivantes
  partent directement sur le CPU au lieu d'échouer une à une
- Source injoignable ou délai dépassé : pas de repli, il doublerait la
  charge d'un serveur déjà occupé
- Process.start qui échoue (serveur à court de ressources) : 502/503
  au lieu d'une exception remontée en 500
- Client : une erreur réseau fatale avant la première playlist
  appelait hls.startLoad(), qui ne relance pas ce chargement → spinner
  infini, aucune erreur, relances de page jamais déclenchées. L'erreur
  remonte désormais à la page
- mpegts.js : au-delà de 3 erreurs en 60 s, bascule sur HLS au lieu de
  recréer sans fin (un FFmpeg neuf toutes les 1,2 s)
- player_lite.html : 3 relances avant l'erreur, comme les autres pages

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

web/player_lite.html

@@ -90,25 +90,49 @@
                 playOverlay.style.display = 'none';
             }
 
-            var player = new XFPlayer({
-                video: video,
-                logPrefix: '[LitePlayer]',
-                onLoading: showLoading,
-                onReady: function () {
-                    hideLoading();
-                    playOverlay.style.display = 'none';
-                },
-                onError: showError,
-                onBlocked: function () {
-                    hideLoading();
-                    playOverlay.style.display = 'flex';
-                },
-                onProfileChange: function (name) {
-                    loadingHint.textContent =
-                        name === 'safe' ? 'Réseau instable — buffer maximal'
-                                        : 'Réseau instable — buffer élargi';
-                }
-            });
+            // Un serveur chargé peut rater le démarrage du transcodeur : on
+            // relance un lecteur neuf avant d'afficher l'erreur, comme le
+            // font déjà player.html et player_mobile.html.
+            var retryCount = 0;
+            var maxRetries = 3;
+            var player = null;
+
+            function buildPlayer() {
+                if (player) { try { player.destroy(); } catch (e) {} }
+
+                player = new XFPlayer({
+                    video: video,
+                    logPrefix: '[LitePlayer]',
+                    onLoading: showLoading,
+                    onReady: function () {
+                        hideLoading();
+                        retryCount = 0;
+                        playOverlay.style.display = 'none';
+                    },
+                    onError: function (msg) {
+                        if (retryCount < maxRetries) {
+                            retryCount++;
+                            showLoading(
+                                'Reconnexion ' + retryCount + '/' + maxRetries
+                            );
+                            setTimeout(buildPlayer, 1500);
+                        } else {
+                            showError(msg);
+                        }
+                    },
+                    onBlocked: function () {
+                        hideLoading();
+                        playOverlay.style.display = 'flex';
+                    },
+                    onProfileChange: function (name) {
+                        loadingHint.textContent =
+                            name === 'safe' ? 'Réseau instable — buffer maximal'
+                                            : 'Réseau instable — buffer élargi';
+                    }
+                });
+                window.xfPlayer = player;
+                player.start();
+            }
 
             playOverlay.addEventListener('click', function () {
                 video.play();
@@ -123,8 +147,7 @@
                 }
             });
 
-            player.start();
-            window.xfPlayer = player;
+            buildPlayer();
         })();
     </script>
 </body>

web/xf-player-core.js

@@ -55,6 +55,9 @@
 
   var ORDER = ['fast', 'balanced', 'safe'];
 
+  // Erreurs MPEG-TS tolérées sur 60 s avant de basculer sur HLS.
+  var MPEGTS_MAX_ERRORS = 3;
+
   // ------------------------------------------------------------------
   // Chargement paresseux des libs (aucune requête inutile)
   // ------------------------------------------------------------------
@@ -178,6 +181,7 @@
     this._started = false;
     this._stalls = 0;
     this._stallTimes = [];
+    this._mpegtsErrorTimes = [];
     this._destroyed = false;
     this._reportedTime = 0;
     this._hlsDuration = 0;
@@ -317,10 +321,15 @@
       self.hls = hls;
       global.hlsInstance = hls; // compat : code existant qui inspecte l'instance
 
+      // Faux tant que la première playlist n'a pas été obtenue : voir le
+      // traitement des erreurs réseau plus bas.
+      var manifestParsed = false;
+
       hls.loadSource(self.url);
       hls.attachMedia(self.video);
 
       hls.on(Hls.Events.MANIFEST_PARSED, function () {
+        manifestParsed = true;
         // Démarrage immédiat : on ne sonde plus le buffer toutes les 200 ms.
         // Si le réseau ne suit pas, l'escalade de profil s'en chargera.
         self._attemptPlay();
@@ -337,6 +346,15 @@
         if (!d.fatal) return;
         self.log('Erreur HLS fatale : ' + d.details);
         if (d.type === Hls.ErrorTypes.NETWORK_ERROR) {
+          // Playlist jamais obtenue (transcodeur en échec → 502, serveur trop
+          // chargé → délai dépassé), après les relances internes de hls.js.
+          // `startLoad()` ne relance pas ce chargement-là : le lecteur
+          // restait muet sur un spinner infini. On remonte l'erreur pour que
+          // la page relance un lecteur neuf ou l'affiche.
+          if (!manifestParsed) {
+            self.onError('Flux indisponible : le serveur n\'a pas pu le préparer');
+            return;
+          }
           self._escalate('erreur réseau');
           hls.startLoad();
         } else if (d.type === Hls.ErrorTypes.MEDIA_ERROR) {
@@ -446,6 +464,37 @@
     player.on(mpegts.Events.ERROR, function (type, detail) {
       self.log('Erreur MPEG-TS : ' + type + ' / ' + detail);
       if (self._destroyed) return;
+
+      // Chaque recréation relance un FFmpeg côté serveur : sur un serveur
+      // déjà saturé, recréer sans fin toutes les 1,2 s ne faisait
+      // qu'aggraver la charge. Au-delà de quelques échecs rapprochés, on
+      // passe par la route HLS, qui renvoie un vrai code d'erreur.
+      var now = Date.now();
+      self._mpegtsErrorTimes = self._mpegtsErrorTimes.filter(function (t) {
+        return now - t < 60000;
+      });
+      self._mpegtsErrorTimes.push(now);
+      if (self._mpegtsErrorTimes.length > MPEGTS_MAX_ERRORS) {
+        try {
+          player.unload();
+          player.detachMediaElement();
+          player.destroy();
+        } catch (e) {}
+        self.mpegts = null;
+
+        var hlsUrl = self._hlsEquivalent(self.url);
+        if (!hlsUrl) {
+          self.onError('Flux indisponible');
+          return;
+        }
+        self.log('Erreurs MPEG-TS répétées — bascule HLS');
+        self.onLoading('Ouverture du flux');
+        self.url = hlsUrl;
+        if (self._canPlayNativeHls()) self._playDirect(hlsUrl);
+        else self._startHls();
+        return;
+      }
+
       self._escalate('erreur MPEG-TS');
       // Recréation propre avec le nouveau profil.
       setTimeout(function () {