@shopify/react-native-skia 2.6.5 → 2.6.6

package/cpp/skia/src/base/SkAutoLocaleSetter.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAutoLocaleSetter_DEFINED
+#define SkAutoLocaleSetter_DEFINED
+
+#include "include/private/base/SkNoncopyable.h"
+
+#if defined(SK_BUILD_FOR_WIN)
+#include <optional>
+#include <string>
+#endif
+
+#if !defined(SK_BUILD_FOR_ANDROID)
+#include <locale.h>
+#endif
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+#include <xlocale.h>
+#include <cstring>
+#define HAVE_XLOCALE 1
+#else
+#define HAVE_XLOCALE 0
+#endif
+
+#if defined(SK_BUILD_FOR_ANDROID) || defined(__UCLIBC__) || defined(_NEWLIB_VERSION)
+#define HAVE_LOCALE_T 0
+#else
+#define HAVE_LOCALE_T 1
+#endif
+
+/**
+ * Helper class for ensuring that we don't use the wrong locale when building shaders. Android
+ * doesn't support locale in the NDK, so this is a no-op there.
+ */
+class SkAutoLocaleSetter : public SkNoncopyable {
+public:
+    SkAutoLocaleSetter (const char* name) {
+#if defined(SK_BUILD_FOR_WIN)
+        fOldPerThreadLocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
+        char* oldLocale = setlocale(LC_ALL, name);
+        if (oldLocale) {
+            fOldLocale.emplace(oldLocale);
+        }
+#elif HAVE_LOCALE_T
+#if HAVE_XLOCALE
+        // In xlocale nullptr means the C locale.
+        if (0 == strcmp(name, "C")) {
+            name = nullptr;
+        }
+#endif
+        fLocale = newlocale(LC_ALL_MASK, name, nullptr);
+        if (fLocale) {
+            fOldLocale = uselocale(fLocale);
+        } else {
+            fOldLocale = static_cast<locale_t>(nullptr);
+        }
+#else
+        (void) name; // suppress unused param warning.
+#endif
+    }
+
+    ~SkAutoLocaleSetter () {
+#if defined(SK_BUILD_FOR_WIN)
+        if (fOldLocale) {
+            setlocale(LC_ALL, fOldLocale->c_str());
+        }
+        _configthreadlocale(fOldPerThreadLocale);
+#elif HAVE_LOCALE_T
+        if (fLocale) {
+             uselocale(fOldLocale);
+             freelocale(fLocale);
+        }
+#endif
+    }
+
+private:
+#if defined(SK_BUILD_FOR_WIN)
+    int fOldPerThreadLocale;
+    std::optional<std::string> fOldLocale;
+#elif HAVE_LOCALE_T
+    locale_t fOldLocale;
+    locale_t fLocale;
+#endif
+};
+
+#undef HAVE_LOCALE_T
+#undef HAVE_XLOCALE
+
+#endif

package/cpp/skia/src/base/SkUTF.h

@@ -1,4 +1,4 @@
-// Copyright 2018 Google LLC.
+// Copyright 2018 Google LLC
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 #ifndef SkUTF_DEFINED
 #define SkUTF_DEFINED

package/lib/commonjs/skia/types/WebGPU.d.ts

@@ -24,6 +24,62 @@ export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBas
 export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
     handle: NativeBuffer;
 }
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+    /**
+     * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+     * the device.
+     */
+    type: GPUSharedFenceType;
+    /**
+     * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+     * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+     */
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    /**
+     * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+     * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+     * once consumed.
+     */
+    handle: bigint;
+}
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -36,14 +92,16 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
     /**
      * Acquire the memory for GPU access. `initialized` marks whether the existing
      * contents should be preserved (pass `true` for an already-rendered frame).
-     * Returns `false` if access could not be acquired.
+     * Optional `fences` are wait fences: Dawn waits for each to reach its
+     * `signaledValue` before writing the surface. Throws if the access could not
+     * be acquired.
      */
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
     /**
-     * Release the memory after the GPU work that accessed it has been submitted.
-     * Returns `false` on failure.
+     * Release the memory after the GPU work that accessed it has been submitted,
+     * and return the fences Dawn produced for the access. Throws on failure.
      */
-    endAccess(texture: GPUTexture): boolean;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 /**
  * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
@@ -84,5 +142,12 @@ declare global {
          * begin/end access window yourself.
          */
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        /**
+         * Skia extension: import a native synchronization primitive (an
+         * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+         * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+         * matching `shared-fence-*` feature must be enabled on the device.
+         */
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
 }

package/lib/commonjs/skia/types/WebGPU.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Returns `false` if access could not be acquired.\n   */\n  beginAccess(texture: GPUTexture, initialized: boolean): boolean;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted.\n   * Returns `false` on failure.\n   */\n  endAccess(texture: GPUTexture): boolean;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n  }\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,\n * matching the `shared-fence-*` device feature names. Limited to the kinds\n * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`\n * accepts these and `export()` reports them.\n */\nexport type GPUSharedFenceType =\n  | \"mtl-shared-event\"\n  | \"sync-fd\"\n  | \"vk-semaphore-opaque-fd\";\n\n/**\n * Descriptor for {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFenceDescriptor {\n  /**\n   * The fence kind to import. Must match a `shared-fence-*` feature enabled on\n   * the device.\n   */\n  type: GPUSharedFenceType;\n  /**\n   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for\n   * `\"mtl-shared-event\"`, or an OS file descriptor for the `*-fd` kinds.\n   */\n  handle: bigint;\n  label?: string;\n}\n\nexport interface GPUSharedFenceExportInfo {\n  type: GPUSharedFenceType;\n  /**\n   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a\n   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed\n   * once consumed.\n   */\n  handle: bigint;\n}\n\n/**\n * A native GPU synchronization primitive shared across queues/APIs. Produced by\n * {@link GPUSharedTextureMemory.endAccess}, consumed by\n * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's\n * fence with {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFence {\n  readonly __brand: \"GPUSharedFence\";\n  label: string;\n  export(): GPUSharedFenceExportInfo;\n}\n\n/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */\nexport interface GPUSharedFenceState {\n  fence: GPUSharedFence;\n  signaledValue: bigint;\n}\n\n/**\n * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled\n * at its `signaledValue` once Dawn's GPU work for the access completes.\n */\nexport interface GPUSharedTextureMemoryEndAccessState {\n  initialized: boolean;\n  fences: GPUSharedFenceState[];\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Optional `fences` are wait fences: Dawn waits for each to reach its\n   * `signaledValue` before writing the surface. Throws if the access could not\n   * be acquired.\n   */\n  beginAccess(\n    texture: GPUTexture,\n    initialized: boolean,\n    fences?: GPUSharedFenceState[]\n  ): void;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted,\n   * and return the fences Dawn produced for the access. Throws on failure.\n   */\n  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n    /**\n     * Skia extension: import a native synchronization primitive (an\n     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a\n     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The\n     * matching `shared-fence-*` feature must be enabled on the device.\n     */\n    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;\n  }\n}\n"],"mappings":"","ignoreList":[]}

package/lib/module/skia/types/WebGPU.d.ts

@@ -24,6 +24,62 @@ export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBas
 export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
     handle: NativeBuffer;
 }
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+    /**
+     * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+     * the device.
+     */
+    type: GPUSharedFenceType;
+    /**
+     * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+     * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+     */
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    /**
+     * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+     * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+     * once consumed.
+     */
+    handle: bigint;
+}
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -36,14 +92,16 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
     /**
      * Acquire the memory for GPU access. `initialized` marks whether the existing
      * contents should be preserved (pass `true` for an already-rendered frame).
-     * Returns `false` if access could not be acquired.
+     * Optional `fences` are wait fences: Dawn waits for each to reach its
+     * `signaledValue` before writing the surface. Throws if the access could not
+     * be acquired.
      */
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
     /**
-     * Release the memory after the GPU work that accessed it has been submitted.
-     * Returns `false` on failure.
+     * Release the memory after the GPU work that accessed it has been submitted,
+     * and return the fences Dawn produced for the access. Throws on failure.
      */
-    endAccess(texture: GPUTexture): boolean;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 /**
  * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
@@ -84,5 +142,12 @@ declare global {
          * begin/end access window yourself.
          */
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        /**
+         * Skia extension: import a native synchronization primitive (an
+         * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+         * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+         * matching `shared-fence-*` feature must be enabled on the device.
+         */
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
 }

package/lib/module/skia/types/WebGPU.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Returns `false` if access could not be acquired.\n   */\n  beginAccess(texture: GPUTexture, initialized: boolean): boolean;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted.\n   * Returns `false` on failure.\n   */\n  endAccess(texture: GPUTexture): boolean;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n  }\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sources":["WebGPU.ts"],"sourcesContent":["import type { NativeBuffer } from \"./NativeBuffer\";\n\n// Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by\n// @webgpu/types) with a few Skia- and Dawn-specific entry points. These are\n// only available on native (SK_GRAPHITE) builds, reachable through\n// `Skia.getDevice()`.\n//\n// The exported interfaces below describe the descriptors and objects those\n// entry points use; the `declare global` block augments the standard WebGPU\n// interfaces so the new methods are typed without casting to `any`.\n\n/**\n * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a\n * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).\n *\n * `source` is the handle returned by `Skia.NativeBuffer.MakeFromImage`: a\n * `CVPixelBufferRef` on Apple, an `AHardwareBuffer*` on Android. The caller\n * owns its lifetime (release it with `Skia.NativeBuffer.Release`) and must keep\n * it alive until the imported texture is destroyed.\n */\nexport interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBase {\n  source: NativeBuffer;\n  /** Rotation applied while sampling, in degrees. One of 0 | 90 | 180 | 270. */\n  rotation?: number;\n  /** Mirror horizontally while sampling. */\n  mirrored?: boolean;\n}\n\n/**\n * Descriptor for {@link GPUDevice.importSharedTextureMemory}. `handle` is the\n * NativeBuffer returned by `Skia.NativeBuffer.MakeFromImage` (see\n * {@link SkiaGPUExternalTextureDescriptor} for the platform-specific types and\n * lifetime rules).\n */\nexport interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {\n  handle: NativeBuffer;\n}\n\n/**\n * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,\n * matching the `shared-fence-*` device feature names. Limited to the kinds\n * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`\n * accepts these and `export()` reports them.\n */\nexport type GPUSharedFenceType =\n  | \"mtl-shared-event\"\n  | \"sync-fd\"\n  | \"vk-semaphore-opaque-fd\";\n\n/**\n * Descriptor for {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFenceDescriptor {\n  /**\n   * The fence kind to import. Must match a `shared-fence-*` feature enabled on\n   * the device.\n   */\n  type: GPUSharedFenceType;\n  /**\n   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for\n   * `\"mtl-shared-event\"`, or an OS file descriptor for the `*-fd` kinds.\n   */\n  handle: bigint;\n  label?: string;\n}\n\nexport interface GPUSharedFenceExportInfo {\n  type: GPUSharedFenceType;\n  /**\n   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a\n   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed\n   * once consumed.\n   */\n  handle: bigint;\n}\n\n/**\n * A native GPU synchronization primitive shared across queues/APIs. Produced by\n * {@link GPUSharedTextureMemory.endAccess}, consumed by\n * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's\n * fence with {@link GPUDevice.importSharedFence}.\n */\nexport interface GPUSharedFence {\n  readonly __brand: \"GPUSharedFence\";\n  label: string;\n  export(): GPUSharedFenceExportInfo;\n}\n\n/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */\nexport interface GPUSharedFenceState {\n  fence: GPUSharedFence;\n  signaledValue: bigint;\n}\n\n/**\n * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled\n * at its `signaledValue` once Dawn's GPU work for the access completes.\n */\nexport interface GPUSharedTextureMemoryEndAccessState {\n  initialized: boolean;\n  fences: GPUSharedFenceState[];\n}\n\n/**\n * Shared texture memory imported from a platform native buffer via\n * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases\n * the memory, then bracket the GPU work that touches it with\n * {@link GPUSharedTextureMemory.beginAccess} / {@link GPUSharedTextureMemory.endAccess}.\n */\nexport interface GPUSharedTextureMemory extends GPUObjectBase {\n  /** Create a texture that aliases the shared memory. */\n  createTexture(descriptor?: GPUTextureDescriptor): GPUTexture;\n  /**\n   * Acquire the memory for GPU access. `initialized` marks whether the existing\n   * contents should be preserved (pass `true` for an already-rendered frame).\n   * Optional `fences` are wait fences: Dawn waits for each to reach its\n   * `signaledValue` before writing the surface. Throws if the access could not\n   * be acquired.\n   */\n  beginAccess(\n    texture: GPUTexture,\n    initialized: boolean,\n    fences?: GPUSharedFenceState[]\n  ): void;\n  /**\n   * Release the memory after the GPU work that accessed it has been submitted,\n   * and return the fences Dawn produced for the access. Throws on failure.\n   */\n  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;\n}\n\n/**\n * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to\n * `adapter.requestDevice`. This is a non-spec, Dawn-only extension; see Dawn's\n * toggle list for valid names.\n */\nexport interface GPUDawnTogglesDescriptor {\n  enabledToggles?: string[];\n  disabledToggles?: string[];\n}\n\ndeclare global {\n  interface GPUDeviceDescriptor {\n    /** Dawn-specific toggles (Skia/Graphite extension, non-spec). */\n    dawnToggles?: GPUDawnTogglesDescriptor;\n  }\n\n  interface GPUExternalTexture {\n    /**\n     * Skia extension: end the imported buffer's shared-memory access window and\n     * release the underlying resources. Call right after the `queue.submit()`\n     * that sampled this texture (never before). Idempotent, and also runs at\n     * garbage collection as a fallback.\n     */\n    destroy(): void;\n  }\n\n  interface GPUDevice {\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as a {@link GPUExternalTexture}, sampled\n     * with `texture_external` in WGSL. The returned texture owns the\n     * shared-memory access window; call `destroy()` on it after the sampling\n     * `queue.submit()`.\n     */\n    importExternalTexture(\n      descriptor: SkiaGPUExternalTextureDescriptor\n    ): GPUExternalTexture;\n    /**\n     * Skia extension: import a NativeBuffer (from\n     * `Skia.NativeBuffer.MakeFromImage`) as {@link GPUSharedTextureMemory}, the\n     * lower-level path that lets you create an aliasing texture and manage the\n     * begin/end access window yourself.\n     */\n    importSharedTextureMemory(\n      descriptor: GPUSharedTextureMemoryDescriptor\n    ): GPUSharedTextureMemory;\n    /**\n     * Skia extension: import a native synchronization primitive (an\n     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a\n     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The\n     * matching `shared-fence-*` feature must be enabled on the device.\n     */\n    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;\n  }\n}\n"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/skia/types/WebGPU.d.ts

@@ -24,6 +24,62 @@ export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBas
 export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
     handle: NativeBuffer;
 }
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+    /**
+     * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+     * the device.
+     */
+    type: GPUSharedFenceType;
+    /**
+     * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+     * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+     */
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    /**
+     * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+     * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+     * once consumed.
+     */
+    handle: bigint;
+}
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -36,14 +92,16 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
     /**
      * Acquire the memory for GPU access. `initialized` marks whether the existing
      * contents should be preserved (pass `true` for an already-rendered frame).
-     * Returns `false` if access could not be acquired.
+     * Optional `fences` are wait fences: Dawn waits for each to reach its
+     * `signaledValue` before writing the surface. Throws if the access could not
+     * be acquired.
      */
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
     /**
-     * Release the memory after the GPU work that accessed it has been submitted.
-     * Returns `false` on failure.
+     * Release the memory after the GPU work that accessed it has been submitted,
+     * and return the fences Dawn produced for the access. Throws on failure.
      */
-    endAccess(texture: GPUTexture): boolean;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 /**
  * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
@@ -84,5 +142,12 @@ declare global {
          * begin/end access window yourself.
          */
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        /**
+         * Skia extension: import a native synchronization primitive (an
+         * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+         * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+         * matching `shared-fence-*` feature must be enabled on the device.
+         */
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
 }

package/package.json

@@ -8,7 +8,7 @@
     "setup-skia-web": "scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "2.6.5",
+  "version": "2.6.6",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",
@@ -131,10 +131,10 @@
   },
   "dependencies": {
     "canvaskit-wasm": "0.41.0",
-    "react-native-skia-android": "147.1.0",
-    "react-native-skia-apple-ios": "147.1.0",
-    "react-native-skia-apple-macos": "147.1.0",
-    "react-native-skia-apple-tvos": "147.1.0",
+    "react-native-skia-android": "150.0.0",
+    "react-native-skia-apple-ios": "150.0.0",
+    "react-native-skia-apple-macos": "150.0.0",
+    "react-native-skia-apple-tvos": "150.0.0",
     "react-reconciler": "0.31.0"
   },
   "eslintIgnore": [

package/src/skia/types/WebGPU.ts

@@ -36,6 +36,71 @@ export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBas
   handle: NativeBuffer;
 }
 
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType =
+  | "mtl-shared-event"
+  | "sync-fd"
+  | "vk-semaphore-opaque-fd";
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+  /**
+   * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+   * the device.
+   */
+  type: GPUSharedFenceType;
+  /**
+   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+   * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+   */
+  handle: bigint;
+  label?: string;
+}
+
+export interface GPUSharedFenceExportInfo {
+  type: GPUSharedFenceType;
+  /**
+   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+   * once consumed.
+   */
+  handle: bigint;
+}
+
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+  readonly __brand: "GPUSharedFence";
+  label: string;
+  export(): GPUSharedFenceExportInfo;
+}
+
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+  fence: GPUSharedFence;
+  signaledValue: bigint;
+}
+
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+  initialized: boolean;
+  fences: GPUSharedFenceState[];
+}
+
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -48,14 +113,20 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
   /**
    * Acquire the memory for GPU access. `initialized` marks whether the existing
    * contents should be preserved (pass `true` for an already-rendered frame).
-   * Returns `false` if access could not be acquired.
+   * Optional `fences` are wait fences: Dawn waits for each to reach its
+   * `signaledValue` before writing the surface. Throws if the access could not
+   * be acquired.
    */
-  beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+  beginAccess(
+    texture: GPUTexture,
+    initialized: boolean,
+    fences?: GPUSharedFenceState[]
+  ): void;
   /**
-   * Release the memory after the GPU work that accessed it has been submitted.
-   * Returns `false` on failure.
+   * Release the memory after the GPU work that accessed it has been submitted,
+   * and return the fences Dawn produced for the access. Throws on failure.
    */
-  endAccess(texture: GPUTexture): boolean;
+  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 
 /**
@@ -104,5 +175,12 @@ declare global {
     importSharedTextureMemory(
       descriptor: GPUSharedTextureMemoryDescriptor
     ): GPUSharedTextureMemory;
+    /**
+     * Skia extension: import a native synchronization primitive (an
+     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+     * matching `shared-fence-*` feature must be enabled on the device.
+     */
+    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
   }
 }