ntk 8.10.0 → 8.11.1

package/lib/text/layout.js

@@ -1,5 +1,6 @@
 import LineBreaker from 'linebreak';
 
+import { rasterizePolys } from '../rasterize.js';
 import { drawGlyphRuns } from './glyphs.js';
 import { embeddingLevels, normalizedLevels, reorderRuns } from './shape.js';
 
@@ -533,6 +534,53 @@ export class TextLayout {
     return this;
   }
 
+  /**
+   * How much of each pixel the glyphs cover, one byte a pixel, without
+   * drawing them anywhere — for text that is drawn where a 2d context is
+   * not: a GL surface's label atlas, a distance field (react-x11#673).
+   *
+   * The raster is the layout box in whole pixels with `pad` pixels round it
+   * (`width` × `height` bytes, row-major), and the layout's origin — the
+   * (x, y) of `draw(ctx, x, y)` — is at (pad, pad). Every glyph's outline is
+   * placed where the shaped runs put it, unrounded, and the whole layout is
+   * filled once, nonzero, so overlapping glyphs cover a pixel once: the
+   * outlines' own coverage, unhinted, which is what a raster that will be
+   * scaled wants. Nothing is uploaded and nothing is read back.
+   *
+   * @param {{ pad?: number }} [options]
+   * @returns {{ width: number, height: number, data: Uint8Array } | null}
+   */
+  coverage({ pad = 0 } = {}) {
+    const p = pad > 0 ? Math.ceil(pad) : 0;
+    const width = Math.ceil(this.width) + p * 2;
+    const height = Math.ceil(this.height) + p * 2;
+    if (!(width > 0 && height > 0)) return null;
+    const polys = [];
+    for (const line of this.lines) {
+      for (const r of line.runs) {
+        const { font, size, glyphs } = r.run;
+        let cursor = p + line.x + r.x;
+        const baseline = p + line.baseline;
+        for (const g of glyphs) {
+          const gx = cursor + g.dx;
+          const gy = baseline - g.dy;
+          cursor += g.ax;
+          for (const poly of font.outline(g.id, size)) {
+            const placed = new Float64Array(poly.length);
+            for (let i = 0; i < poly.length; i += 2) {
+              placed[i] = poly[i] + gx;
+              placed[i + 1] = poly[i + 1] + gy;
+            }
+            polys.push(placed);
+          }
+        }
+      }
+    }
+    const data = new Uint8Array(width * height);
+    if (polys.length > 0) rasterizePolys(polys, width, height, 'nonzero', { out: data });
+    return { width, height, data };
+  }
+
   // ---- caret positioning / hit testing ----------------------------------
   //
   // Both methods speak logical **code-point** indices (what you get from

package/lib/window.js

@@ -109,6 +109,32 @@ const REFRESH_QUANTILE = 0.25;
 const STALL_TIMEOUT = 2000;
 const STALL_TIMEOUT_FIRST = 250;
 
+/**
+ * The frame period Present makes up for a screen with no vertical blank to
+ * offer it, in µs: 60Hz, which xorg-server 21.1 and later compute as
+ * `1000000 / 60` and 1.20 and earlier wrote down as 16667.
+ *
+ * A server started with `-fakescreenfps` at another rate is not recognised.
+ * It was asked for that clock, and keeps it.
+ */
+const FAKE_MSC_INTERVALS = [16666, 16667];
+
+/**
+ * How much of the counter a made-up msc has to account for before a window
+ * believes it, in vblanks: about a quarter of a second.
+ *
+ * One completion that fits proves little. A display's counter starts after
+ * the server's clock does, so its `ust / msc` falls toward its own period as
+ * it runs, and a display a little faster than 60Hz passes through the
+ * made-up line on the way down. It stays within half a tick of the line for
+ * `interval / (interval - period)` vblanks, so a fit across this span rules
+ * out every display more than `interval / span` µs faster than the tick, which
+ * is anything past 64Hz. A display closer than that fits only while its
+ * counter crosses the line, and only a window whose first frames land in that
+ * stretch is fooled.
+ */
+const SYNTHETIC_MSC_SPAN = 16;
+
 /**
  * MotionNotify detail saying "this is the only motion you get until you ask".
  *
@@ -476,7 +502,9 @@ export default class Window extends Drawable {
     this._frameSyncEnabled = args.frameSync !== false;
     // which signal ends a frame (see _clockOnPresent): 'auto' takes the
     // display's own vblank where the Present path can supply it and the fence
-    // everywhere else, 'fence' pins the round-trip clock
+    // everywhere else, including a server whose Present has no display behind
+    // it (see _probeMsc); 'present' takes Present's clock even there; 'fence'
+    // pins the round-trip clock
     this._frameClockPref = args.frameClock ?? 'auto';
     // _NET_WM_SYNC_REQUEST (see enableSyncRequest): the counter the window
     // manager watches, the value it last asked for, and the watchdog that
@@ -520,6 +548,12 @@ export default class Window extends Drawable {
     this._refreshSamples = [];
     this._lastComplete = null;
     this._clockStalled = false;
+    // Whether the msc on those completions is a display's count or a number
+    // the server works out from its clock (see _probeMsc): while undecided,
+    // the fake intervals every completion so far fits and the msc of the
+    // first of them; then the verdict.
+    this._mscProbe = { intervals: FAKE_MSC_INTERVALS, since: null };
+    this._mscSynthetic = false;
     // `frameInterval` is a plain number, but whether the caller set it is what
     // decides its meaning under the vblank clock — an explicit value caps the
     // frame rate, an unasked-for default must not (see _armTimer). Assigning
@@ -1311,6 +1345,8 @@ export default class Window extends Drawable {
    *  - a fence, everywhere else: a cheap request with a reply
    *    (GetInputFocus) sent after each frame; X processes requests in order,
    *    so its reply confirms the server consumed everything the frame drew.
+   *    That includes a server whose Present has no display behind it and
+   *    makes its vertical blanks up from a timer (see _probeMsc).
    *
    * Either way at most one is outstanding, which is what bounds the work in
    * flight: on a slow connection frames degrade to one per round-trip instead
@@ -1379,14 +1415,15 @@ export default class Window extends Drawable {
   /**
    * Which clock is ending this window's frames right now: 'present' when the
    * display is, 'fence' when the server round-trip is. Assignable with
-   * 'auto' (prefer the display) or 'fence' (never use it).
+   * 'auto' (prefer the display), 'present' (prefer Present's clock even
+   * where no display is behind it) or 'fence' (never use it).
    */
   get frameClock() {
     return this._clockOnPresent() ? 'present' : 'fence';
   }
 
   set frameClock(mode) {
-    this._frameClockPref = mode === 'present' ? 'auto' : mode;
+    this._frameClockPref = mode;
     if (this._frameClockPref !== 'fence') this._selectPresentInput();
   }
 
@@ -1400,21 +1437,35 @@ export default class Window extends Drawable {
    * completion that never came drops the window back to the fence until one
    * does, so a clock that stops cannot stop the window with it.
    *
-   * `_presentFlipped` is the one-way door — a server that has flipped a copy
-   * present is off this path for good, and its blits no longer produce the
-   * completions the clock is made of.
+   * `_presentAbandoned` is the one-way door — a window whose server turned
+   * out unable to do what the path is for is off it from then on, and its
+   * blits no longer produce the completions the clock is made of.
    */
   _clockOnPresent() {
     return (
       this._frameClockPref !== 'fence' &&
       this._frameSyncEnabled &&
       !this._clockStalled &&
-      !this._presentFlipped &&
+      !this._presentAbandoned() &&
       !!this._presentExt &&
       !!this._presentEid
     );
   }
 
+  /**
+   * Has this window stopped presenting through the extension, the blit along
+   * with the clock, because of what its server turned out to be?
+   *
+   * Two things close the door. A server that flipped a present sent with
+   * Option.Copy owns the pixmap it was handed (see _handlePresentEvent). A
+   * server whose msc is made up has no display behind the extension, and
+   * only holds each copy back for a timer (see _probeMsc) — that one stays
+   * open to a caller who asked for Present's clock by name.
+   */
+  _presentAbandoned() {
+    return !!this._presentFlipped || (this._mscSynthetic && this._frameClockPref !== 'present');
+  }
+
   _runFrame() {
     const f = this._frame;
     if (
@@ -1823,6 +1874,7 @@ export default class Window extends Drawable {
     f.presentInFlight = false;
     this.frameLatency = now - f.presentAt;
     this._sampleRefresh(ev, now);
+    this._probeMsc(ev);
     this._frameEnded();
   }
 
@@ -1890,6 +1942,60 @@ export default class Window extends Drawable {
     this.refreshInterval = sorted[Math.floor(REFRESH_QUANTILE * (sorted.length - 1))];
   }
 
+  /**
+   * Is a display counting these frames, or is the server making the count up?
+   *
+   * Present waits for vertical blanks, and a screen whose driver has none to
+   * offer gets fake ones: xserver's present_fake.c computes the msc from its
+   * clock, `(ust + interval / 2) / interval`, and completes a present when a
+   * timer set for the next tick fires. That is XQuartz, Xvfb, Xephyr, Xnest,
+   * the VNC servers and Xorg on a driver without Present support. The
+   * vblank clock buys nothing there and costs throughput. It paces to a 60Hz
+   * timer rather than to the panel, which on XQuartz is the macOS
+   * compositor's business. And a present arriving past the middle of a
+   * period already counts as the next tick, and is aimed at the one after
+   * that, so a frame that takes more than half a period to turn round waits
+   * two (issue #366).
+   *
+   * The blit goes with the clock, as it does for a server that flips: the
+   * copy waits for the same timer, so a window on the fence would draw
+   * faster yet still update at most 60 times a second, and a copy could
+   * read a frame half drawn, because the fence reply only says the server
+   * has read the present, not run it. CopyArea runs in request order.
+   *
+   * So the question is whether `msc` is `ust` rounded to the nearest tick.
+   * A display's counter cannot keep to that for long (SYNTHETIC_MSC_SPAN),
+   * and a single completion off the line settles it the other way. Either
+   * verdict is final: whether Present has a driver behind it is settled per
+   * screen, when the server starts.
+   */
+  _probeMsc(ev) {
+    const probe = this._mscProbe;
+    if (!probe) return;
+    const intervals = probe.intervals.filter((interval) => {
+      // msc === floor((ust + half) / interval), in integers
+      const half = Math.floor(interval / 2);
+      const offset = ev.ust - ev.msc * interval;
+      return offset >= -half && offset < interval - half;
+    });
+    if (!intervals.length) {
+      this._mscProbe = null; // a count, so a display
+      return;
+    }
+    probe.intervals = intervals;
+    probe.since ??= ev.msc;
+    if (ev.msc - probe.since < SYNTHETIC_MSC_SPAN) return;
+    this._mscProbe = null;
+    this._mscSynthetic = true;
+    // What was measured was a timer: no display period to report, and no
+    // display to have dropped frames on. A window kept on this clock by
+    // `frameClock: 'present'` learns the timer's period again from here.
+    this.refreshInterval = null;
+    this._refreshSamples = [];
+    this._lastComplete = null;
+    this.droppedFrames = 0;
+  }
+
   /**
    * Guarantee that a frame ends even if its completion does not arrive.
    *
@@ -2235,7 +2341,7 @@ export default class Window extends Drawable {
   _presentWithExtension(rects) {
     const P = this._presentExt;
     if (!P || !this._fixesExt || !this._updateRegion) return false;
-    if (this._presentFlipped) return false; // see _handlePresentEvent
+    if (this._presentAbandoned()) return false;
     safeRelease(this.X, () => {
       this._fixesExt.SetRegion(
         this._updateRegion,

package/package.json

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