react-x11 2.39.0 → 2.41.0

package/src/cocoa/panehost.js

@@ -12,9 +12,25 @@
 // And the players its `<video src>`s ask for, which a process with no
 // AppKit would never hear from: each is a player here, its events and its
 // frames sent back (`HostedPlayer`, src/cocoa/paneplayer.js).
+import { now } from '../nodes/animation.js';
 import { HostedPlayer } from './paneplayer.js';
 import { withoutActions } from './quiet.js';
 
+/** The live-resize handshake's budget when the app names none
+ *  (`RESIZE_WAIT_MS`, src/cocoa/app.js). */
+const RESIZE_WAIT_MS = 50;
+
+/** How many sizes asked of the pane are remembered until a frame of one
+ *  answers them (`_asked`): a drag asks one a frame. */
+const ASKED_KEPT = 16;
+
+/** How long after the last size asked a new one starts a gesture of its
+ *  own, which finds the pane keeping up until it shows otherwise: a pane
+ *  whose layout at a width it was not dragged to took long — a long page
+ *  laid out whole, as the first step of a drag is — keeps up with the
+ *  drag itself. */
+const GESTURE_GAP_MS = 500;
+
 /** One shared surface on glass: a sublayer of a window's root layer, its
  * contents the IOSurface the pane last presented into it. */
 class PaneLayer {
@@ -29,6 +45,82 @@ class PaneLayer {
     });
     this.destroyed = false;
     this._rect = null;
+    // How the frame the layer holds sits in it while one of the size the
+    // layer was just given is on its way (`_gravityNow`): the gravity set,
+    // Core Animation's own until one is, the sizes asked of the pane with
+    // when each was asked, and whether the pane has fallen behind them.
+    this._gravity = 'resize';
+    this._contentsScale = null;
+    this._asked = [];
+    this._askedAt = null;
+    this._behind = false;
+  }
+
+  /**
+   * The gravity a pane's last frame sits in its layer by, until a frame of
+   * the layer's new size lands. The host gives the layer its new size the
+   * moment the window lays out, and the pane's frame of that size comes a
+   * pane frame later: Core Animation's default, `resize`, stretches the
+   * frame it has to the new bounds meanwhile, and a page's left column was
+   * drawn scaled a little at every step of a window dragged wider, and then
+   * at its size again. A pane that keeps up has its frame anchored at the
+   * top left instead, at its size, what it does not cover yet showing the
+   * window under it for a pane frame; one that falls behind the budget is
+   * stretched, which is the better picture for the long wait — a pane
+   * repainting at three frames a second shows a squeezed page, not a page
+   * and a growing strip. The budget is the window's live-resize handshake's
+   * (`createRoot({ cocoa: { resizeWait } })`), how long a frame of a new
+   * size may take before the old one is shown in its place: 0 stretches
+   * always, as before. A bridge that predates `contentsGravity` ignores it,
+   * and stretches.
+   */
+  _gravityNow() {
+    const budget = this.app._resizeWait ?? RESIZE_WAIT_MS;
+    if (!(budget > 0)) return 'resize';
+    // a size asked longer ago than the budget, and no frame of it yet
+    const oldest = this._asked[0];
+    if (oldest && now() - oldest.at > budget) this._behind = true;
+    return this._behind ? 'resize' : 'topLeft';
+  }
+
+  /** The props that set the gravity, where it changed. */
+  _gravityProps() {
+    const gravity = this._gravityNow();
+    if (gravity === this._gravity) return null;
+    this._gravity = gravity;
+    // a frame anchored and larger than the layer would hang out of it
+    return { contentsGravity: gravity, masksToBounds: gravity !== 'resize' };
+  }
+
+  /**
+   * The props that say how many of the pane's pixels make a point of the
+   * layer, where that changed: the window's scale, which the pane draws
+   * at. A frame stretched to the bounds never asked, and one anchored at
+   * its size is shown at it — pixels over `contentsScale` points, so at
+   * the default of 1 a page at 2x came out twice its size.
+   */
+  _scaleProps() {
+    const scale = this.wnd.scale ?? 1;
+    if (scale === this._contentsScale) return null;
+    this._contentsScale = scale;
+    return { contentsScale: scale };
+  }
+
+  /** A frame of `width` by `height` device px landed: what it answers of
+   *  the sizes asked, and how long it took. */
+  _answered(width, height) {
+    const asked = this._asked;
+    // the pane rounds the logical size it was sent back to device pixels
+    const slack = Math.max(2, this.wnd.scale ?? 1);
+    const at = asked.findIndex(
+      (a) =>
+        Math.abs(a.width - width) <= slack &&
+        Math.abs(a.height - height) <= slack,
+    );
+    if (at < 0) return;
+    this._behind =
+      now() - asked[at].at > (this.app._resizeWait ?? RESIZE_WAIT_MS);
+    asked.splice(0, at + 1);
   }
 
   /** Geometry in device px, the node's abs — points at the layer. */
@@ -46,6 +138,17 @@ class PaneLayer {
       return;
     }
     this._rect = { ...rect };
+    // a size the pane is asked for, answered by the first frame of it
+    if (prev && (prev.width !== rect.width || prev.height !== rect.height)) {
+      const at = now();
+      if (at - (this._askedAt ?? -Infinity) >= GESTURE_GAP_MS) {
+        this._asked = [];
+        this._behind = false;
+      }
+      this._askedAt = at;
+      if (this._asked.length === ASKED_KEPT) this._asked.shift();
+      this._asked.push({ width: rect.width, height: rect.height, at });
+    }
     // Actions off: the layer is ours, not a presenter's, so no frame's
     // transaction covers it, and a bare set tweens the pane into place at
     // mount and after every resize — the trap CocoaGLArea._setLayerProps
@@ -57,6 +160,8 @@ class PaneLayer {
         frame: [rect.x / s, rect.y / s, rect.width / s, rect.height / s],
         zPosition: 1e7,
         hidden: false,
+        ...this._scaleProps(),
+        ...this._gravityProps(),
       });
     } finally {
       native.txCommit();
@@ -67,18 +172,22 @@ class PaneLayer {
    * A pane-present landed: scan out of the named shared surface.
    *
    * A present names a buffer the pane may since have retired. The channel
-   * is a queue and nothing acknowledges a present, so a pane-rect that
-   * changes the pane's size (or its scale — the host window moved to another
-   * display during startup, which is how this was first hit) can cross a
-   * present already in flight: the pane rebuilds its ring on that rect and
-   * releases the old one (`CocoaPaneWindow._ensureSurface`), and by the
-   * time the host looks the id up the surface is gone. That present is
-   * stale by construction — the pane's full frame on the fresh ring is
-   * queued behind it — so it is dropped, and the layer keeps the frame it
-   * already holds a reference to. Nothing else here throws; any other
-   * error is the bug it says it is.
+   * is a queue, so a pane-rect that changes the pane's size (or its scale —
+   * the host window moved to another display during startup, which is how
+   * this was first hit) can cross a present already in flight: the pane
+   * rebuilds its ring on that rect (`CocoaPaneWindow._ensureSurface`)
+   * before the host has looked the id up. The id is all the present
+   * carries, and the system gives a freed id to the next surface made, so
+   * the pane keeps such a buffer until the host says it has looked it up
+   * (`pane-shown`, which `CocoaPaneHost` sends once it has) — the lookup finds
+   * the frame the present named, a size behind, and the full frame on the
+   * fresh ring is queued behind it. Where the buffer is gone anyway — a
+   * pane that freed it for want of an answer, or one that died with
+   * presents in the channel — the present is dropped, and the layer keeps
+   * the frame it already holds a reference to. Nothing else here throws;
+   * any other error is the bug it says it is.
    */
-  present(iosurfaceId) {
+  present(iosurfaceId, size = null) {
     if (this.destroyed) return false;
     try {
       this._native.setLayerContentsIOSurface(this.layer, iosurfaceId);
@@ -86,6 +195,17 @@ class PaneLayer {
       if (!/IOSurfaceLookup/.test(err?.message ?? '')) throw err;
       return false;
     }
+    // how long the pane took to a frame of a size it was asked for, which
+    // is what the gravity follows (`_gravityNow`)
+    if (size) {
+      this._answered(size.width, size.height);
+      const gravity = this._gravityProps();
+      if (gravity) {
+        withoutActions(this._native, () =>
+          this._native.setLayerProps(this.layer, gravity),
+        );
+      }
+    }
     return true;
   }
 
@@ -144,6 +264,28 @@ export class CocoaPaneHost extends PaneLayer {
     this._players = new Map();
   }
 
+  /**
+   * The pane's own present, scanned out (`PaneLayer.present`), and the pane
+   * told: whatever the buffer it named holds is the layer's now, or was
+   * dropped, so the pane may free it (`CocoaPaneWindow._releaseRing`).
+   */
+  present(iosurfaceId, size = null) {
+    const shown = super.present(iosurfaceId, size);
+    this._acknowledge(size?.seq, null);
+    return shown;
+  }
+
+  /** `pane-shown`: the host has looked up the presents to `seq` of the
+   *  pane's own window, or of the one `window` names. */
+  _acknowledge(seq, window) {
+    if (this.destroyed || seq == null) return;
+    this._send?.({
+      type: 'pane-shown',
+      seq,
+      ...(window != null && { window }),
+    });
+  }
+
   /**
    * A `pane-player` message: one of the pane's `<video src>`s made, steered
    * or let go of its player. A player that cannot be made says so the way
@@ -259,9 +401,15 @@ export class CocoaPaneHost extends PaneLayer {
   /** A pane-present naming one of the pane's other windows. */
   presentWindow(msg) {
     const entry = this._windows.get(msg.window);
-    if (!entry || this.destroyed) return;
+    if (!entry || this.destroyed) {
+      this._acknowledge(msg.seq, msg.window);
+      return;
+    }
     entry.layer.setRect({ x: 0, y: 0, width: msg.width, height: msg.height });
-    if (!entry.layer.present(msg.id)) return;
+    const shown = entry.layer.present(msg.id);
+    // its ring is the pane's own ring, retired the same way
+    this._acknowledge(msg.seq, msg.window);
+    if (!shown) return;
     entry.presented = true;
     // a transparent window's shadow is the shape of what it shows
     entry.wnd._shadowAfterFlip?.();

package/src/cocoa/paneplayer.js

@@ -18,6 +18,15 @@
 // other: the host writes the buffer after the one it last named, so the one
 // the pane is told about is not written again for two frames — some 66ms at
 // 30fps, against a pane that copies within a display frame of hearing.
+//
+// A buffer is named by its IOSurface id, and the system gives a freed id to
+// the next surface anyone makes, in either process. So the pane answers
+// each frame once it has looked the buffer up (`seen`), the host keeps a
+// buffer of a ring it retired until the frame naming it is answered
+// (`HostedPlayer._freeRing`), and the pane keeps nothing a lookup found at
+// another size than the frame says (`PanePlayer._lookUp`) — the pane's own
+// presents, the other way round, are kept the same way
+// (`CocoaPaneWindow._releaseRing`).
 
 import { PlayerState } from './player.js';
 
@@ -113,27 +122,13 @@ export class PanePlayer extends PlayerState {
   }
 
   /** The host named a buffer with a new frame in it. */
-  _frame({ surface, width, height, time }) {
+  _frame({ surface, width, height, time, seq }) {
     if (this.released) return;
-    // a ring of another size is a new ring: the old one's buffers are the
-    // host's to free, and these handles only keep them alive
-    if (
-      this._bufferSize?.width !== width ||
-      this._bufferSize?.height !== height
-    ) {
-      this._dropBuffers();
-      this._bufferSize = { width, height };
-    }
-    let handle = this._buffers.get(surface);
-    if (!handle) {
-      try {
-        handle = this._native.surfaceFromIOSurfaceID(surface, 1).handle;
-      } catch {
-        // freed before it got here: the next frame is in another buffer
-        return;
-      }
-      this._buffers.set(surface, handle);
-    }
+    const handle = this._lookUp(surface, width, height);
+    // this frame's lookup is done, whatever it found: the host may free the
+    // buffer, which it kept for it (`HostedPlayer._freeRing`)
+    if (seq != null) this._post({ op: 'seen', seq });
+    if (!handle) return;
     this._shown = { handle, width, height, time };
     this._fresh = true;
     // a playing `<video>` asks every display frame; a paused one asks when
@@ -148,6 +143,40 @@ export class PanePlayer extends PlayerState {
     }
   }
 
+  /**
+   * The buffer the host named, looked up the first time it is named; null
+   * where the lookup found none, or found a surface of another size than
+   * the frame, which is not the frame's buffer but whatever the id has gone
+   * to since (`HostedPlayer._freeRing` says how) — never kept, and never
+   * copied out of.
+   */
+  _lookUp(surface, width, height) {
+    // a ring of another size is a new ring: the old one's buffers are the
+    // host's to free, and these handles only keep them alive
+    if (
+      this._bufferSize?.width !== width ||
+      this._bufferSize?.height !== height
+    ) {
+      this._dropBuffers();
+      this._bufferSize = { width, height };
+    }
+    const known = this._buffers.get(surface);
+    if (known) return known;
+    let found;
+    try {
+      found = this._native.surfaceFromIOSurfaceID(surface, 1);
+    } catch {
+      // freed before it got here: the next frame is in another buffer
+      return null;
+    }
+    if (found.width !== width || found.height !== height) {
+      this._native.releaseSurface?.(found.handle);
+      return null;
+    }
+    this._buffers.set(surface, found.handle);
+    return found.handle;
+  }
+
   /** As `CocoaPlayer.copyFrame`: the newest frame into `surface`, or null
    *  when the host has sent nothing since the last copy. */
   copyFrame(surface) {
@@ -212,6 +241,12 @@ export class HostedPlayer {
     this._next = 0;
     this._want = 0;
     this._pull = null;
+    // Each frame's number, the newest the pane has looked up (`seen`), and
+    // the buffers of retired rings a frame it has not looked up yet names:
+    // freed as it does (`_freeRing`).
+    this._seq = 0;
+    this._seenSeq = 0;
+    this._retired = [];
     this._off = this.player._subscribe((ev) => this._event(ev));
   }
 
@@ -221,6 +256,7 @@ export class HostedPlayer {
     if (player.released) return;
     if (msg.op === 'set') player.set(msg.settings);
     else if (msg.op === 'seek') player.seek(msg.seconds);
+    else if (msg.op === 'seen') this._seen(msg.seq);
     else if (msg.op === 'release') this.release();
   }
 
@@ -274,6 +310,9 @@ export class HostedPlayer {
       );
       if (got?.written) {
         this._next = (this._next + 1) % RING;
+        // the buffer is named in the channel until the pane says otherwise
+        // (`_freeRing`)
+        buffer.namedSeq = ++this._seq;
         this._send({
           type: 'pane-player-frame',
           player: this.id,
@@ -281,6 +320,7 @@ export class HostedPlayer {
           width: got.width,
           height: got.height,
           time: got.time,
+          seq: this._seq,
         });
         if (!player.playing) this._want = 0;
       } else if (got?.width > 0 && got?.height > 0) {
@@ -316,13 +356,46 @@ export class HostedPlayer {
     return this._ring[this._next];
   }
 
+  /**
+   * Let the ring go — all but a buffer a frame names that the pane has not
+   * looked up yet. The pane finds a buffer by its IOSurface id, and the
+   * system hands a freed id to the next surface anyone makes: the ring of
+   * the new size this same call is about to make, the pane's own ring,
+   * another process's surface. A frame still in the channel named the id,
+   * not the surface, so the pane copied out of whatever had it by the time
+   * it looked — the next ring's buffer, unwritten, shown until the next
+   * frame came, which for a paused player is the next seek. So that buffer
+   * is kept (`_retired`) until the pane says it has looked the frame up
+   * (`seen`, `_seen`). One, as a rule, since the pane answers as it reads,
+   * and never more than a ring's worth: a pane that stops answering has the
+   * oldest freed anyway, the one it is likeliest to have looked up already.
+   */
   _freeRing() {
+    const ring = this._ring;
+    this._ring = [];
     const release = this._native.releaseSurface;
-    if (typeof release === 'function') {
-      for (const buffer of this._ring)
-        release.call(this._native, buffer.handle);
+    if (typeof release !== 'function') return;
+    for (const buffer of ring) {
+      if (buffer.namedSeq > this._seenSeq) this._retired.push(buffer);
+      else release.call(this._native, buffer.handle);
     }
-    this._ring = [];
+    while (this._retired.length > RING) {
+      release.call(this._native, this._retired.shift().handle);
+    }
+  }
+
+  /** The pane has looked up every frame up to `seq`: the retired buffers
+   *  they named go. */
+  _seen(seq) {
+    if (!(seq > this._seenSeq)) return;
+    this._seenSeq = seq;
+    if (this._retired.length === 0) return;
+    const release = this._native.releaseSurface;
+    this._retired = this._retired.filter((buffer) => {
+      if (buffer.namedSeq > seq) return true;
+      release.call(this._native, buffer.handle);
+      return false;
+    });
   }
 
   release() {
@@ -332,5 +405,9 @@ export class HostedPlayer {
     this._want = 0;
     this._syncPull();
     this._freeRing();
+    // and what it kept: the pane's player is gone, or the pane is
+    for (const buffer of this._retired.splice(0)) {
+      this._native.releaseSurface(buffer.handle);
+    }
   }
 }