ntk 8.12.10 → 8.12.12

package/lib/glswapchain.js

@@ -12,14 +12,19 @@
 // and every later frame in that buffer is a Present of a pixmap the server
 // already has.
 //
-// Two rules shape the code. **A buffer belongs to the server until IdleNotify
+// Three rules shape the code. **A buffer belongs to the server until IdleNotify
 // says otherwise** — drawing into one before then paints whatever is on
-// screen — so a buffer is released back to GBM there and nowhere else. And
-// **a pixmap must exist before it is presented**: a new buffer's import is
+// screen — so a buffer is released back to GBM there and nowhere else. **A
+// pixmap must exist before it is presented**: a new buffer's import is
 // confirmed by a round trip before the first Present names it, or the Present
 // would fail with BadPixmap. A new buffer appears a handful of times per
 // generation (and never again in steady state), so that round trip is a
-// startup cost, not a per-frame one.
+// startup cost, not a per-frame one. And **a surface is never destroyed while
+// it is current** (`_destroySurface`): destroying one takes its GBM surface —
+// the native window under the EGL surface — with it, while EGL still holds
+// the EGL surface as current, and on NVIDIA's driver the next surface made
+// current after that swaps nothing but EGL_BAD_SURFACE. A resize retires the
+// generation being drawn into, so every resize of a window killed its GL.
 
 import { GLError, glError } from './gl.js';
 
@@ -88,6 +93,9 @@ export class GLSwapchain {
     this.onReady = null;
     /** called once the first buffer has been imported, or it failed */
     this.onValidated = null;
+    /** called with the error when the chain fails after it validated — the
+     *  one failure `onValidated` has no way left to report */
+    this.onError = null;
     this._validated = false;
 
     this._eid = this.X.AllocID();
@@ -107,10 +115,44 @@ export class GLSwapchain {
     const h = Math.max(1, Math.round(height));
     const gen = this.generation;
     if (gen && gen.width === w && gen.height === h) return gen.surface;
+    // The new generation first, and only then the old one's retirement: a
+    // driver that refuses the new size leaves the chain drawing where it
+    // was, and the old surface — current, as a rule, since this runs at the
+    // top of a frame — is let go by `_destroySurface`, which unbinds it.
+    // A generation that had to go linear keeps that layout: whatever refused
+    // the tiled buffer — the server, or EGL itself — has not changed since.
+    const surface = this._newGeneration(w, h, gen ? gen.linear : false);
     this._retire(gen);
-    // a generation that had to go linear keeps that layout: whatever refused
-    // the tiled buffer — the server, or EGL itself — has not changed since
-    return this._newGeneration(w, h, gen ? gen.linear : false);
+    return surface;
+  }
+
+  /**
+   * Destroy a generation's surface, unbinding it first if it is the one
+   * current on the connection.
+   *
+   * The currency is the connection's (`app._glCurrentSurface`, which the
+   * context sets whenever it binds): every direct surface on it shares one
+   * GPU context, and exactly one surface is current. Unbinding leaves no
+   * surface current and says so (`app._glCurrent`), so the next GL call of
+   * whichever context draws next binds its own, as it would after another
+   * surface stole currency.
+   */
+  _destroySurface(surface) {
+    const app = this.window.app;
+    if (app && app._glCurrentSurface === surface) {
+      try {
+        this.gpu.makeCurrent(null);
+      } catch {
+        // nothing is current now either way
+      }
+      app._glCurrentSurface = null;
+      app._glCurrent = null;
+    }
+    try {
+      surface.destroy();
+    } catch {
+      // already gone
+    }
   }
 
   /** A GBM surface at this size, in the layout asked for. */
@@ -384,14 +426,20 @@ export class GLSwapchain {
   _fail(err) {
     if (this.error) return;
     this.error = err;
-    this._validate(err);
+    // Before validation the failure is `ready`'s rejection. After it — a
+    // swap refused mid-life — nothing is waiting on `ready` any more, and a
+    // chain that only recorded the error left its window showing its last
+    // frame, or nothing, with no word to anyone.
+    if (this._validated) this.onError?.(err);
+    else this._validate(err);
   }
 
   _retire(gen) {
     if (!gen || gen.retired) return;
     gen.retired = true;
     this.retired.push(gen);
-    this.generation = null;
+    // `surfaceFor` retires the old generation after making the new one
+    if (this.generation === gen) this.generation = null;
     this._sweep(gen);
   }
 
@@ -409,11 +457,7 @@ export class GLSwapchain {
     if (gen.pixmaps.size || this.importing) return;
     const index = this.retired.indexOf(gen);
     if (index >= 0) this.retired.splice(index, 1);
-    try {
-      gen.surface.destroy();
-    } catch {
-      // already gone
-    }
+    this._destroySurface(gen.surface);
   }
 
   _freePixmap(pixmap) {
@@ -429,14 +473,11 @@ export class GLSwapchain {
     this.destroyed = true;
     this.onReady = null;
     this.onValidated = null;
+    this.onError = null;
     for (const gen of this._generations()) {
       for (const entry of gen.pixmaps.values()) this._freePixmap(entry.pixmap);
       gen.pixmaps.clear();
-      try {
-        gen.surface.destroy();
-      } catch {
-        // already gone
-      }
+      this._destroySurface(gen.surface);
     }
     this.generation = null;
     this.retired.length = 0;

package/lib/renderingcontext_cgl.js

@@ -416,7 +416,24 @@ does not make it retroactive. Either:
   _fail(err) {
     if (this.error) return;
     this.error = err;
-    this._settleReady?.(err);
+    // before `ready` settled this is its rejection; after, the one word the
+    // failure gets is `onError` (the GLES flavor's contract)
+    if (this._settleReady) this._settleReady(err);
+    else this._errorHandler?.(err);
+  }
+
+  /**
+   * Called once, with the coded error `error` then holds, when the context
+   * fails after `ready` resolved — a flush refused, or a surface that could
+   * not be exported again after the window came back. A failure before that
+   * is `ready`'s rejection, and only that.
+   */
+  set onError(fn) {
+    this._errorHandler = fn;
+  }
+
+  get onError() {
+    return this._errorHandler;
   }
 
   destroy() {

package/lib/renderingcontext_gles.js

@@ -167,6 +167,12 @@ does not make it retroactive. Either:
     this.ready.catch(() => {});
     this.swapchain.onReady = () => this._onFrameAvailable();
     this._frameWanted = null;
+    // …and a failure after `ready` resolved, which nothing awaits any more
+    this._errorHandler = null;
+    this.swapchain.onError = (err) => {
+      this.error = err;
+      this._errorHandler?.(err);
+    };
 
     // GL entry points and constants, bound so that whichever surface this
     // context owns is the current one when they run
@@ -208,24 +214,28 @@ does not make it retroactive. Either:
    */
   makeCurrent() {
     if (this.error || this._destroyed || this.window._destroyed) return this;
-    const width = this.window.width;
-    const height = this.window.height;
-    if (width !== this._width || height !== this._height) {
-      this._width = width;
-      this._height = height;
-      this._surface = null; // a new size is a new generation
-    }
+    // a new size is a new generation, which `_bind` asks the chain for
+    this._width = this.window.width;
+    this._height = this.window.height;
     this._bind();
     return this;
   }
 
   _bind() {
     if (this.error || this._destroyed) return;
-    if (!this._surface) {
-      this._surface = this.swapchain.surfaceFor(this._width ?? this.window.width, this._height ?? this.window.height);
-    }
+    // Asked of the chain every time rather than cached here: the chain also
+    // replaces its generation on its own — the linear retry after the server
+    // refuses a buffer — and a surface cached across that is one the chain
+    // has destroyed. At the same size it is a comparison and a return.
+    this._surface = this.swapchain.surfaceFor(
+      this._width ?? this.window.width,
+      this._height ?? this.window.height
+    );
     this.gpu.makeCurrent(this._surface);
     this.app._glCurrent = this;
+    // which surface is current, for the chain: it never destroys that one
+    // without unbinding it first (GLSwapchain#_destroySurface)
+    this.app._glCurrentSurface = this._surface;
   }
 
   /**
@@ -252,6 +262,20 @@ does not make it retroactive. Either:
     this._frameWanted?.();
   }
 
+  /**
+   * Called once, with the coded error `error` then holds, when the context
+   * fails after `ready` resolved — the driver refusing a swap mid-life. A
+   * failure before that is `ready`'s rejection, and only that. Either way
+   * the context draws nothing more, and a caller with a fallback shows it.
+   */
+  set onError(fn) {
+    this._errorHandler = fn;
+  }
+
+  get onError() {
+    return this._errorHandler;
+  }
+
   /**
    * Show the frame just drawn.
    *
@@ -266,9 +290,8 @@ does not make it retroactive. Either:
     // A resize seen only now still gets picked up: the next frame binds a
     // generation at the new size. Checked after the swap so the frame that was
     // drawn at the old size is the one that goes out.
-    if (this.window.width !== this._width || this.window.height !== this._height) {
-      this._surface = null;
-    }
+    this._width = this.window.width;
+    this._height = this.window.height;
     return sent;
   }
 
@@ -288,10 +311,14 @@ does not make it retroactive. Either:
   destroy() {
     if (this._destroyed) return;
     this._destroyed = true;
+    this._errorHandler = null;
+    // unbinds this context's surface first where it is the current one
+    // (GLSwapchain#_destroySurface)
     this.swapchain.destroy();
     this.window._setGenericEventSink(0, null);
     if (this.app._glCurrent === this) {
       this.app._glCurrent = null;
+      this.app._glCurrentSurface = null;
       try {
         this.gpu.makeCurrent(null);
       } catch {

package/lib/window.js

@@ -1560,6 +1560,7 @@ export default class Window extends Drawable {
 
   _runFrame() {
     const f = this._frame;
+    const startedAt = performance.now();
     if (
       !f.pending.size &&
       !f.rafCbs.length &&
@@ -1601,7 +1602,7 @@ export default class Window extends Drawable {
     // that drew nothing has to fall back to the timer, or nothing would ever
     // run the next frame.
     if (!this._clockOnPresent()) this._armFence();
-    this._armTimer();
+    this._armTimer(startedAt);
   }
 
   /**
@@ -2156,8 +2157,14 @@ export default class Window extends Drawable {
    * and arming one would only cap the rate the display just set. An explicit
    * `frameInterval` is honoured in both, since a cap the caller asked for
    * applies whatever ends the frame.
+   *
+   * The period runs from the start of the frame (`startedAt`), not from its
+   * end: a frame's own work is part of its period, not a pause owed after it.
+   * Counted from the end, a window whose frames took 3 ms drew one every 19
+   * under a 16.7 ms interval — a GL map panned by an animation, whose window
+   * is on the fence, ran at 51 frames a second on a 60 Hz panel.
    */
-  _armTimer() {
+  _armTimer(startedAt = performance.now()) {
     const f = this._frame;
     if (f.timer) return;
     let period = this.frameInterval;
@@ -2169,7 +2176,7 @@ export default class Window extends Drawable {
     f.timer = setTimeout(() => {
       f.timer = null;
       if (f.pending.size || f.rafCbs.length || f.needsRedraw) this._scheduleFrame();
-    }, period);
+    }, Math.max(0, period - (performance.now() - startedAt)));
     if (typeof f.timer.unref === 'function') f.timer.unref();
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.12.10",
+  "version": "8.12.12",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",