@matjash/pixi-native-linux-x64 0.1.2 → 0.2.1

package/native/gpu/src/index.js

@@ -1,47 +1,48 @@
-const Fs = require('fs')
-const { getBindingPath } = require('./binding-path.js')
+const Fs = require("fs");
+const { getBindingPath } = require("./binding-path.js");
 
-const bindingPath = getBindingPath()
+const bindingPath = getBindingPath();
 if (!Fs.existsSync(bindingPath)) {
-	throw new Error(
-		`Native WebGPU is not supported by this pixi-native distribution for ${process.platform}-${process.arch}: ` +
-		'pixi_native_gpu.node is not included.',
-	)
+  throw new Error(
+    `Native WebGPU is not supported by this pixi-native distribution for ${process.platform}-${process.arch}: ` +
+      "pixi_native_gpu.node is not included.",
+  );
 }
-const binding = require(bindingPath)
+const binding = require(bindingPath);
 
-const contexts = new Set()
+const contexts = new Set();
 
 // Pixi probes navigator.gpu by requesting a device before it initializes with
 // the explicitly supplied adapter/device pair. Return the context-owned device
 // so capability detection cannot create an unrelated second Dawn device.
-const createNavigatorAdapter = (context) => new Proxy(context.adapter, {
-	get: (target, property) => {
-		if (property === 'requestDevice') return async () => context.device
-		const value = Reflect.get(target, property, target)
-		return typeof value === 'function' ? value.bind(target) : value
-	},
-})
+const createNavigatorAdapter = (context) =>
+  new Proxy(context.adapter, {
+    get: (target, property) => {
+      if (property === "requestDevice") return async () => context.device;
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+  });
 
 const createWindowContext = (options) => {
-	const context = binding.createWindowContext(options)
-	const navigatorAdapter = createNavigatorAdapter(context)
-	const gpu = {
-		requestAdapter: async () => navigatorAdapter,
-		getPreferredCanvasFormat: () => context.renderer.getPreferredFormat(),
-		wgslLanguageFeatures: new Set(),
-	}
-	const result = { ...context, gpu }
-	contexts.add(result)
-	return result
-}
+  const context = binding.createWindowContext(options);
+  const navigatorAdapter = createNavigatorAdapter(context);
+  const gpu = {
+    requestAdapter: async () => navigatorAdapter,
+    getPreferredCanvasFormat: () => context.renderer.getPreferredFormat(),
+    wgslLanguageFeatures: new Set(),
+  };
+  const result = { ...context, gpu };
+  contexts.add(result);
+  return result;
+};
 
 const destroy = (context) => {
-	contexts.delete(context)
-}
+  contexts.delete(context);
+};
 
 module.exports = {
-	createWindowContext,
-	destroy,
-	...binding.globals,
-}
+  createWindowContext,
+  destroy,
+  ...binding.globals,
+};

package/native/video/package.json

@@ -1,7 +1,7 @@
 {
-    "name": "@pixi-native/native-video",
-    "version": "0.1.0",
-    "private": true,
-    "main": "./src/index.js",
-    "types": "./src/index.d.ts"
+  "name": "@pixi-native/native-video",
+  "version": "0.1.0",
+  "private": true,
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts"
 }

package/native/video/src/binding-path.js

@@ -2,16 +2,25 @@ const path = require("node:path");
 
 const SUPPORTED_TARGETS = new Set(["linux-x64", "win32-x64"]);
 
-function getPlatformDirectory(platform = process.platform, arch = process.arch) {
-    const target = `${platform}-${arch}`;
-    if (!SUPPORTED_TARGETS.has(target)) {
-        throw new Error(`Native video is unsupported on ${target}`);
-    }
-    return target;
+function getPlatformDirectory(
+  platform = process.platform,
+  arch = process.arch,
+) {
+  const target = `${platform}-${arch}`;
+  if (!SUPPORTED_TARGETS.has(target)) {
+    throw new Error(`Native video is unsupported on ${target}`);
+  }
+  return target;
 }
 
 function getBindingPath(platform = process.platform, arch = process.arch) {
-    return path.resolve(__dirname, "..", "dist", getPlatformDirectory(platform, arch), "native_video.node");
+  return path.resolve(
+    __dirname,
+    "..",
+    "dist",
+    getPlatformDirectory(platform, arch),
+    "native_video.node",
+  );
 }
 
 module.exports = { getBindingPath, getPlatformDirectory };

package/native/video/src/index.d.ts

@@ -1,36 +1,36 @@
 export interface DecoderOptions {
-    width: number;
-    height: number;
-    fps?: number;
-    startTime?: number;
-    ffmpegPath?: string;
-    vaapiDevice?: string;
-    playbackRate?: number;
-    endTime?: number;
-    sourcePaced?: boolean;
-    inputArgs?: string[];
-    outputArgs?: string[];
+  width: number;
+  height: number;
+  fps?: number;
+  startTime?: number;
+  ffmpegPath?: string;
+  vaapiDevice?: string;
+  playbackRate?: number;
+  endTime?: number;
+  sourcePaced?: boolean;
+  inputArgs?: string[];
+  outputArgs?: string[];
 }
 
 export interface VideoFrame {
-    width: number;
-    height: number;
-    timestampUs: number;
-    data: Uint8Array;
+  width: number;
+  height: number;
+  timestampUs: number;
+  data: Uint8Array;
 }
 
 export class NativeVideoDecoder {
-    public constructor(options: DecoderOptions);
-    public open(source: string): void;
-    public pollLatest(): VideoFrame | null;
-    public pollNext(): VideoFrame | null;
-    public queuedFrames(): number;
-    public catchUpTo(timestampUs: number): void;
-    public pollError(): string | null;
-    public backend(): string;
-    public decodedFrames(): number;
-    public droppedFrames(): number;
-    public skippedFrames(): number;
-    public isFinished(): boolean;
-    public close(): void;
+  public constructor(options: DecoderOptions);
+  public open(source: string): void;
+  public pollLatest(): VideoFrame | null;
+  public pollNext(): VideoFrame | null;
+  public queuedFrames(): number;
+  public catchUpTo(timestampUs: number): void;
+  public pollError(): string | null;
+  public backend(): string;
+  public decodedFrames(): number;
+  public droppedFrames(): number;
+  public skippedFrames(): number;
+  public isFinished(): boolean;
+  public close(): void;
 }

package/native/video/src/index.js

@@ -5,57 +5,57 @@ const requireNative = createRequire(__filename);
 const native = requireNative(getBindingPath());
 
 class NativeVideoDecoder {
-    constructor(options) {
-        this.decoder = new native.NativeVideoDecoder(options);
-    }
+  constructor(options) {
+    this.decoder = new native.NativeVideoDecoder(options);
+  }
 
-    open(source) {
-        this.decoder.open(source);
-    }
+  open(source) {
+    this.decoder.open(source);
+  }
 
-    pollLatest() {
-        return this.decoder.pollLatest();
-    }
+  pollLatest() {
+    return this.decoder.pollLatest();
+  }
 
-    pollNext() {
-        return this.decoder.pollNext();
-    }
+  pollNext() {
+    return this.decoder.pollNext();
+  }
 
-    queuedFrames() {
-        return this.decoder.queuedFrames();
-    }
+  queuedFrames() {
+    return this.decoder.queuedFrames();
+  }
 
-    catchUpTo(timestampUs) {
-        this.decoder.catchUpTo(timestampUs);
-    }
+  catchUpTo(timestampUs) {
+    this.decoder.catchUpTo(timestampUs);
+  }
 
-    pollError() {
-        return this.decoder.pollError();
-    }
+  pollError() {
+    return this.decoder.pollError();
+  }
 
-    backend() {
-        return this.decoder.backend();
-    }
+  backend() {
+    return this.decoder.backend();
+  }
 
-    decodedFrames() {
-        return this.decoder.decodedFrames();
-    }
+  decodedFrames() {
+    return this.decoder.decodedFrames();
+  }
 
-    droppedFrames() {
-        return this.decoder.droppedFrames();
-    }
+  droppedFrames() {
+    return this.decoder.droppedFrames();
+  }
 
-    skippedFrames() {
-        return this.decoder.skippedFrames();
-    }
+  skippedFrames() {
+    return this.decoder.skippedFrames();
+  }
 
-    isFinished() {
-        return this.decoder.isFinished();
-    }
+  isFinished() {
+    return this.decoder.isFinished();
+  }
 
-    close() {
-        this.decoder.close();
-    }
+  close() {
+    this.decoder.close();
+  }
 }
 
 module.exports = { NativeVideoDecoder };

package/native/video/src/lib.rs

@@ -40,7 +40,6 @@ pub struct VideoFrame {
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum DecoderBackend {
-    #[cfg(target_os = "windows")]
     D3d11va,
     Vaapi,
     Cpu,
@@ -49,7 +48,6 @@ enum DecoderBackend {
 impl DecoderBackend {
     fn name(self) -> &'static str {
         match self {
-            #[cfg(target_os = "windows")]
             Self::D3d11va => "D3D11VA",
             Self::Vaapi => "VA-API",
             Self::Cpu => "CPU",
@@ -504,7 +502,6 @@ fn ffmpeg_args(request: &FfmpegRequest, backend: DecoderBackend) -> Vec<String>
     ];
 
     match backend {
-        #[cfg(target_os = "windows")]
         DecoderBackend::D3d11va => {
             args.extend(["-hwaccel".to_string(), "d3d11va".to_string()]);
         }
@@ -538,12 +535,29 @@ fn ffmpeg_args(request: &FfmpegRequest, backend: DecoderBackend) -> Vec<String>
         "fps={},scale={}:{}:flags=fast_bilinear:in_range=auto:out_range=tv:in_color_matrix=auto:out_color_matrix=bt709,format=nv12",
         request.fps, request.width, request.height
     );
-    let filter = if backend == DecoderBackend::Vaapi {
-        format!("hwdownload,format=nv12,{scale}")
-    } else {
-        scale
+    let filter = match backend {
+        DecoderBackend::Vaapi => format!("hwdownload,format=nv12,{scale}"),
+        DecoderBackend::D3d11va => scale,
+        // Keep the CPU fallback independent from the color-negotiation path
+        // used after VA-API download. Some FFmpeg builds fail to initialize
+        // auto_scale when that path is reused for software yuv420p frames.
+        DecoderBackend::Cpu => format!(
+            "fps={},scale={}:{}:flags=fast_bilinear,format=nv12",
+            request.fps, request.width, request.height
+        ),
     };
 
+    if backend == DecoderBackend::Cpu {
+        // The bundled/minimal FFmpeg builds can fail filter negotiation when
+        // multiple filter workers initialize the software graph concurrently.
+        args.extend([
+            "-filter_threads".to_string(),
+            "1".to_string(),
+            "-filter_complex_threads".to_string(),
+            "1".to_string(),
+        ]);
+    }
+
     args.extend([
         "-vf".to_string(),
         filter,
@@ -820,6 +834,19 @@ mod tests {
         assert!(threads_index > input_index && threads_index < pipe_index);
     }
 
+    #[test]
+    fn builds_serial_software_fallback_filter() {
+        let args = ffmpeg_args(&request(30.0, 0.0), DecoderBackend::Cpu);
+        assert!(args.windows(2).any(|pair| pair == ["-filter_threads", "1"]));
+        assert!(args
+            .windows(2)
+            .any(|pair| pair == ["-filter_complex_threads", "1"]));
+        assert!(args
+            .iter()
+            .any(|arg| arg == "fps=30,scale=1280:720:flags=fast_bilinear,format=nv12"));
+        assert!(!args.iter().any(|arg| arg.contains("in_color_matrix=auto")));
+    }
+
     #[test]
     fn redacts_url_credentials_from_ffmpeg_errors() {
         assert_eq!(

package/native/window/binding-path.js

@@ -1,5 +1,11 @@
-const Path = require('path')
+const Path = require("path");
 
-const getBindingPath = () => Path.join(__dirname, 'dist', `${process.platform}-${process.arch}`, 'native_window.node')
+const getBindingPath = () =>
+  Path.join(
+    __dirname,
+    "dist",
+    `${process.platform}-${process.arch}`,
+    "native_window.node",
+  );
 
-module.exports = { getBindingPath }
+module.exports = { getBindingPath };

package/native/window/package.json

@@ -1,7 +1,7 @@
 {
-    "name": "@pixi-native/native-window",
-    "version": "0.1.0",
-    "private": true,
-    "main": "./src/index.js",
-    "types": "./src/index.d.ts"
+  "name": "@pixi-native/native-window",
+  "version": "0.1.0",
+  "private": true,
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts"
 }

package/native/window/src/index.d.ts

@@ -1,11 +1,46 @@
-export interface NativeWindowApi {
-  setTransparent(nativeData: Uint8Array, transparent: boolean): void;
-  waitForCompositorFrame(timeoutMs?: number): Promise<boolean>;
-  create(
-    nativeData: Uint8Array,
-    onFrame: () => void,
-    onState: (active: boolean) => void,
-  ): ModalFrameController;
+export interface NativeSurfaceDescriptor {
+  readonly version: 1;
+  readonly api: "win32" | "x11" | "wayland";
+  readonly window: Buffer;
+  readonly display?: Buffer;
+  readonly instance?: Buffer;
+  readonly eglWindow?: Buffer;
+}
+
+export interface NativeWindowOptions {
+  readonly title: string;
+  readonly width: number;
+  readonly height: number;
+  readonly resizable: boolean;
+  readonly borderless: boolean;
+  readonly transparent: boolean;
+  readonly x?: number;
+  readonly y?: number;
+  readonly graphics: "webgpu" | "webgl";
+}
+
+export interface NativeWindow {
+  readonly id: number;
+  readonly x: number;
+  readonly y: number;
+  readonly pixelWidth: number;
+  readonly pixelHeight: number;
+  readonly display: { readonly frequency: number };
+  readonly destroyed: boolean;
+  readonly surface: NativeSurfaceDescriptor;
+  readonly videoDriver: string;
+  readonly transparent: boolean;
+  pollEvents(): void;
+  setPosition(x: number, y: number): void;
+  minimize(): void;
+  maximize(): void;
+  restore(): void;
+  makeGlCurrent(): boolean;
+  setGlSwapInterval(interval: number): boolean;
+  swapGl(): boolean;
+  glVersion(): string;
+  on(event: string, listener: (event: Record<string, unknown>) => void): this;
+  destroy(): void;
 }
 
 export interface ModalFrameController {
@@ -13,5 +48,16 @@ export interface ModalFrameController {
   detach(): void;
 }
 
+export interface NativeWindowApi {
+  createWindow(options: NativeWindowOptions): NativeWindow;
+  pollEvents(): void;
+  waitForCompositorFrame(timeoutMs?: number): Promise<boolean>;
+  createModalFrameController(
+    nativeData: Buffer,
+    onFrame: () => void,
+    onState: (active: boolean) => void,
+  ): ModalFrameController;
+}
+
 declare const nativeWindow: NativeWindowApi;
 export = nativeWindow;

package/native/window/src/index.js

@@ -1,6 +1,8 @@
-const Fs = require("fs");
+const { EventEmitter } = require("node:events");
+const Fs = require("node:fs");
 const { createRequire } = require("node:module");
 const { getBindingPath } = require("../binding-path.js");
+const { normalizeSdlKeyName } = require("./key-mapping.js");
 
 const requireNative = createRequire(__filename);
 const bindingPath = getBindingPath();
@@ -11,22 +13,89 @@ if (!Fs.existsSync(bindingPath)) {
 }
 
 const binding = requireNative(bindingPath);
+const windows = new Map();
+let waylandPositionWarned = false;
 
-const setTransparent = (nativeData, transparent) => {
-  binding.setTransparent(nativeData, transparent);
+class NativeWindow extends EventEmitter {
+  constructor(options) {
+    super();
+    this._nativeWindow = new binding.NativeSdlWindow(options);
+    windows.set(this._nativeWindow.id, this);
+  }
+
+  get id() { return this._nativeWindow.id; }
+  get x() { return this._nativeWindow.x; }
+  get y() { return this._nativeWindow.y; }
+  get pixelWidth() { return this._nativeWindow.pixelWidth; }
+  get pixelHeight() { return this._nativeWindow.pixelHeight; }
+  get display() { return { frequency: this._nativeWindow.refreshRate }; }
+  get destroyed() { return this._nativeWindow.destroyed; }
+  get surface() { return this._nativeWindow.surface; }
+  get videoDriver() { return this._nativeWindow.videoDriver; }
+  get transparent() { return this._nativeWindow.transparent; }
+
+  pollEvents() { pollEvents(); }
+
+  setPosition(x, y) {
+    if (this._nativeWindow.setPosition(x, y)) return;
+    if (!waylandPositionWarned) {
+      waylandPositionWarned = true;
+      console.warn(
+        "[pixi-native] SDL3 Wayland ignores absolute toplevel window positioning.",
+      );
+    }
+  }
+
+  minimize() { this._nativeWindow.minimize(); }
+  maximize() { this._nativeWindow.maximize(); }
+  restore() { this._nativeWindow.restore(); }
+  makeGlCurrent() { return this._nativeWindow.makeGlCurrent(); }
+  setGlSwapInterval(interval) { return this._nativeWindow.setGlSwapInterval(interval); }
+  swapGl() { return this._nativeWindow.swapGl(); }
+  glVersion() { return this._nativeWindow.glVersion(); }
+
+  destroy() {
+    if (this.destroyed) return;
+    windows.delete(this.id);
+    this._nativeWindow.destroy();
+    this.removeAllListeners();
+  }
+}
+
+const emitNativeEvent = (window, event) => {
+  const { kind, windowId, superKey, ...payload } = event;
+  if (kind === "keyDown" || kind === "keyUp") {
+    payload.key = normalizeSdlKeyName(payload.key);
+  }
+  window.emit(kind, { ...payload, type: kind, super: superKey });
+};
+
+const pollEvents = () => {
+  for (const event of binding.pollEvents()) {
+    if (event.kind === "quit") {
+      for (const window of [...windows.values()]) {
+        emitNativeEvent(window, { ...event, kind: "close" });
+      }
+      continue;
+    }
+    const window = windows.get(event.windowId);
+    if (window) emitNativeEvent(window, event);
+  }
 };
 
+const createWindow = (options) => new NativeWindow(options);
 const waitForCompositorFrame = (timeoutMs) =>
   binding.waitForCompositorFrame(timeoutMs);
-
-const create = (nativeData, onFrame, onState) => {
-  const controller = new binding.ModalFrameController(
-    nativeData,
-    onFrame,
-    onState,
-  );
+const createModalFrameController = (nativeData, onFrame, onState) => {
+  const controller = new binding.ModalFrameController(nativeData, onFrame, onState);
   controller.attach();
   return controller;
 };
 
-module.exports = { create, setTransparent, waitForCompositorFrame };
+module.exports = {
+  NativeWindow,
+  createWindow,
+  createModalFrameController,
+  pollEvents,
+  waitForCompositorFrame,
+};

package/native/window/src/key-mapping.js

@@ -0,0 +1,32 @@
+const SDL_KEY_NAMES = Object.freeze({
+  Up: "up",
+  Down: "down",
+  Left: "left",
+  Right: "right",
+  Space: "space",
+  Return: "return",
+  Escape: "escape",
+  Backspace: "backspace",
+  Tab: "tab",
+  "Left Ctrl": "ctrl",
+  "Right Ctrl": "ctrl",
+  "Left Shift": "shift",
+  "Right Shift": "shift",
+  "Left Alt": "alt",
+  "Right Alt": "alt",
+  "Left GUI": "gui",
+  "Right GUI": "gui",
+});
+
+/** Preserves the key names exposed by the previous @kmamal/sdl adapter. */
+const normalizeSdlKeyName = (name) => {
+  if (typeof name !== "string") return name;
+  const mapped = SDL_KEY_NAMES[name];
+  if (mapped) return mapped;
+  if (/^[A-Z]$/.test(name) || /^F\d{1,2}$/.test(name)) {
+    return name.toLowerCase();
+  }
+  return name;
+};
+
+module.exports = { normalizeSdlKeyName };