Checkpoint current playback recovery work

Author: ziyadhussain23

src/autoPause.js

@@ -16,6 +16,7 @@
  */
 
 import GObject from 'gi://GObject';
+import GLib from 'gi://GLib';
 import Meta from 'gi://Meta';
 import * as Config from 'resource:///org/gnome/shell/misc/config.js';
 
@@ -122,6 +123,20 @@ const PauseOnMaximizeOrFullscreenModule = GObject.registerClass(
             this._windows = []; // [{metaWindow, signals: [...]}, ...]
             this._windowAddedId = null;
             this._windowRemovedId = null;
+            // Coalesce bursts of window-state notifies (a single user
+            // (un)maximize fires 2-4 notify signals back-to-back) into one
+            // _update() per idle tick.
+            this._pendingUpdateId = 0;
+        }
+
+        _scheduleUpdate() {
+            if (this._pendingUpdateId)
+                return;
+            this._pendingUpdateId = GLib.idle_add(GLib.PRIORITY_DEFAULT_IDLE, () => {
+                this._pendingUpdateId = 0;
+                this._update();
+                return GLib.SOURCE_REMOVE;
+            });
         }
 
         enable() {
@@ -146,23 +161,19 @@ const PauseOnMaximizeOrFullscreenModule = GObject.registerClass(
             let signals = [];
             signals.push(
                 metaWindow.connect('notify::maximized-horizontally', () => {
-                    this._logger.debug('maximized-horizontally changed');
-                    this._update();
+                    this._scheduleUpdate();
                 }));
             signals.push(
                 metaWindow.connect('notify::maximized-vertically', () => {
-                    this._logger.debug('maximized-vertically changed');
-                    this._update();
+                    this._scheduleUpdate();
                 }));
             signals.push(
                 metaWindow.connect('notify::fullscreen', () => {
-                    this._logger.debug('fullscreen changed');
-                    this._update();
+                    this._scheduleUpdate();
                 }));
             signals.push(
                 metaWindow.connect('notify::minimized', () => {
-                    this._logger.debug('minimized changed');
-                    this._update();
+                    this._scheduleUpdate();
                 })
             );
             this._windows.push(
@@ -274,6 +285,10 @@ const PauseOnMaximizeOrFullscreenModule = GObject.registerClass(
         }
 
         disable() {
+            if (this._pendingUpdateId) {
+                GLib.source_remove(this._pendingUpdateId);
+                this._pendingUpdateId = 0;
+            }
             this._workspaceManager?.disconnect(this._activeWorkspaceChangedId);
             this._windows.forEach(({metaWindow, signals}) => {
                 signals.forEach(signal => metaWindow.disconnect(signal));

src/extension.js

@@ -120,12 +120,20 @@ export default class HanabiExtension extends Extension {
         //  handler would immediately pause it.)
         this.launchRenderer();
 
+        // Handle monitor configuration changes (connect/disconnect)
+        this._monitorsChangedId = Main.layoutManager.connect('monitors-changed', () => {
+            this._onMonitorsChanged();
+        });
+
         this.playbackState.suppressMismatch = true;
         this._autoPauseDelayId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 5000, () => {
             this._autoPauseDelayId = null;
             this.playbackState.suppressMismatch = false;
+            
             if (this.isEnabled)
                 this.autoPause.enable();
+
+            this.playbackState.sync();
             return false;
         });
 
@@ -135,6 +143,56 @@ export default class HanabiExtension extends Extension {
         this._setupSleepWatch();
     }
 
+    _onMonitorsChanged() {
+        if (!this.isEnabled || this._isSuspending)
+            return;
+
+        // Debounce rapid monitor changes
+        if (this._monitorChangeTimeoutId) {
+            GLib.source_remove(this._monitorChangeTimeoutId);
+            this._monitorChangeTimeoutId = null;
+        }
+
+        this._monitorChangeTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 500, () => {
+            this._monitorChangeTimeoutId = null;
+
+            if (!this.isEnabled || this._isSuspending)
+                return false;
+
+            // Disable autoPause during transition
+            this.autoPause.disable();
+
+            // Cancel any pending autoPause delay
+            if (this._autoPauseDelayId) {
+                GLib.source_remove(this._autoPauseDelayId);
+                this._autoPauseDelayId = null;
+            }
+
+            // Reset playback state for fresh start
+            this.playbackState.reset();
+
+            // Restart renderer for new monitor configuration
+            this.killCurrentProcess();
+
+            // If no process was running and no relaunch is pending, launch directly
+            if (!this.currentProcess && !this.launchRendererId)
+                this.launchRenderer();
+
+            // Suppress mismatch and re-enable autoPause after renderer stabilizes
+            this.playbackState.suppressMismatch = true;
+            this._autoPauseDelayId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 5000, () => {
+                this._autoPauseDelayId = null;
+                this.playbackState.suppressMismatch = false;
+                if (this.isEnabled && !this._isSuspending)
+                    this.autoPause.enable();
+                this.playbackState.sync();
+                return false;
+            });
+
+            return false;
+        });
+    }
+
     _setupSleepWatch() {
         if (this._sleepWatchId)
             return;
@@ -175,19 +233,16 @@ export default class HanabiExtension extends Extension {
                         }
                         this._cancelRendererWait();
 
-                        // Suppress the mismatch handler so the renderer isn't
-                        // force-paused while starting up.
-                        this.playbackState.suppressMismatch = true;
-
-                        // After 5 seconds, force-sync: directly tell renderer to
-                        // play via D-Bus (bypassing state machine which has no
-                        // transition from 'playing'), then re-enable autoPause.
-                        this._autoPauseDelayId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 5000, () => {
+                        // Small grace period for the renderer process to come
+                        // up and export its D-Bus interface before we start
+                        // sending it commands. This is just a launch race
+                        // guard, not a "wait for GStreamer to stabilize" hack.
+                        // The actual post-wake play/pause loop is prevented
+                        // by the mismatch-handler and autoPause changes in
+                        // playbackState.js (see comments there).
+                        const POST_WAKE_GRACE_MS = 1500;
+                        this._autoPauseDelayId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, POST_WAKE_GRACE_MS, () => {
                             this._autoPauseDelayId = null;
-                            this.playbackState.suppressMismatch = false;
-                            // Force renderer to play - reset() set state to 'playing'
-                            // but never sent a D-Bus command.
-                            this.playbackState._renderer.setPlay();
                             if (this.isEnabled && !this._isSuspending)
                                 this.autoPause.enable();
                             return false;
@@ -196,7 +251,7 @@ export default class HanabiExtension extends Extension {
                 }
             });
         } catch (e) {
-            Logger.Logger.prototype.warn?.call(null, `Failed to setup sleep watch: ${e}`);
+            console.warn(`Failed to setup sleep watch: ${e}`);
         }
     }
 
@@ -317,6 +372,21 @@ export default class HanabiExtension extends Extension {
             this._autoPauseDelayId = null;
         }
 
+        // Cancel any pending post-wake mismatch-resume timer.
+        if (this._mismatchResumeId) {
+            GLib.source_remove(this._mismatchResumeId);
+            this._mismatchResumeId = 0;
+        }
+
+        if (this._monitorsChangedId) {
+            Main.layoutManager.disconnect(this._monitorsChangedId);
+            this._monitorsChangedId = null;
+        }
+        if (this._monitorChangeTimeoutId) {
+            GLib.source_remove(this._monitorChangeTimeoutId);
+            this._monitorChangeTimeoutId = null;
+        }
+
         this._cancelRendererWait();
         this._teardownSleepWatch();
         this._isSuspending = false;

src/playbackState.js

@@ -15,9 +15,19 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+import GLib from 'gi://GLib';
+
 import * as DBus from './dbus.js';
 import * as Logger from './logger.js';
 
+// Debounce window for the renderer/state-machine mismatch corrector.
+// GStreamer can rapidly oscillate between PAUSED and PLAYING while a hardware
+// decoder pipeline is warming up (especially right after suspend/resume). If
+// we react to every isPlayingChanged immediately, our forced setPlay/setPause
+// calls amplify that oscillation and the video can stay frozen for tens of
+// seconds. Only act on a mismatch that has remained stable for this long.
+const MISMATCH_DEBOUNCE_MS = 1500;
+
 
 /**
  * Ref: https://kentcdodds.com/blog/implementing-a-simple-state-machine-library-in-javascript
@@ -57,6 +67,8 @@ export class PlaybackState {
         // Used during startup and wake-from-sleep to let the renderer start
         // playing without being immediately force-paused.
         this.suppressMismatch = false;
+        // GLib source id for the debounced mismatch corrector (0 = none).
+        this._mismatchTimeoutId = 0;
         this._machineDefinition = {
             initialState: 'playing',
             playing: {
@@ -154,26 +166,28 @@ export class PlaybackState {
                 },
             },
         };
-        this._renderer.proxy.connectSignal(
-            'isPlayingChanged',
-            (_proxy, _sender, [isPlaying]) => {
-                if (this.suppressMismatch) {
-                    this._logger.debug('isPlayingChanged mismatch check suppressed');
-                    return;
-                }
-                if (isPlaying && this.getCurrentState() !== 'playing') {
-                    // The renderer is playing the media but the current playback state isn't 'playing'
-                    // This discrepancy can happen when the shell reload, renderer process reload,
-                    // or when the user restarts the playback (e.g. select another video file in prefs).
-                    // Pause the renderer if that's the case.
-                    this._renderer.setPause();
-                }
-            }
-        );
+        // Note: we do NOT install an `isPlayingChanged` corrector that fights
+        // the renderer when its reported state diverges from ours. The signal
+        // is reported by GStreamer's state-changed callback in the renderer,
+        // which can fire transient PAUSED reports while the pipeline is
+        // mid-recovery (very common after suspend/resume with hardware video
+        // decode). Any auto-correction here re-sends setPlay()/setPause() into
+        // a recovering pipeline on a fixed cadence and creates a self-
+        // sustaining play/pause loop. The state machine here is the single
+        // source of truth for what we WANT; what the renderer momentarily
+        // REPORTS is best-effort and only used for UI labels.
         // Initialize
         this.reset();
     }
 
+    sync() {
+        if (this.getCurrentState() === 'playing') {
+            this._renderer.setPlay();
+        } else {
+            this._renderer.setPause();
+        }
+    }
+
     getCurrentState() {
         return this._machine.value;
     }

src/renderer/renderer.js

@@ -107,7 +107,7 @@ let changeWallpaperMode = extSettings ? extSettings.get_int('change-wallpaper-mo
 let changeWallpaperInterval = extSettings ? extSettings.get_int('change-wallpaper-interval') : 15;
 let windowDimension = {width: 1920, height: 1080};
 let windowed = false;
-let fullscreened = true;
+let fullscreened = false;
 let isDebugMode = extSettings ? extSettings.get_boolean('debug-mode') : true;
 let changeWallpaperTimerId = null;
 let fadeDuration = extSettings ? extSettings.get_int('fade-duration') : 500;

src/roundedCornersEffect.js

@@ -16,11 +16,15 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+import Cogl from 'gi://Cogl';
 import GObject from 'gi://GObject';
 import Shell from 'gi://Shell';
 
 import * as Logger from './logger.js';
 
+// Shell.SnippetHook was removed in GNOME Shell 47+, use Cogl as fallback
+const SnippetHook = Shell.SnippetHook ?? Cogl.SnippetHook;
+
 const logger = new Logger.Logger('roundedCorners');
 
 // This shader is copied from Mutter project.
@@ -86,7 +90,7 @@ export const RoundedCornersEffect = GObject.registerClass(
     class RoundedCornersEffect extends Shell.GLSLEffect {
         vfunc_build_pipeline() {
             this.add_glsl_snippet(
-                Shell.SnippetHook.FRAGMENT,
+                SnippetHook.FRAGMENT,
                 fragmentShaderDeclarations,
                 fragmentShaderCode,
                 false