react-native-webgpu 0.16.1 → 0.19.0

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -19,6 +19,9 @@
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "CanvasColorSpace.h"
+#include "WebGPURuntime.h"
+
 #if defined(__ANDROID__)
 #include <android/hardware_buffer.h>
 #include <android/log.h>
@@ -36,9 +39,11 @@ namespace rnwgpu {
 
 #ifdef __APPLE__
 // Tags the CAMetalLayer with the colorspace matching the configured texture
-// format. Implemented in apple/MetalLayerColorSpace.mm.
+// format and the canvas's colorSpace. Implemented in
+// apple/MetalLayerColorSpace.mm.
 void applyCAMetalLayerColorSpace(void *nativeSurface,
-                                 wgpu::TextureFormat format);
+                                 wgpu::TextureFormat format,
+                                 CanvasColorSpace colorSpace);
 #endif
 
 struct NativeInfo {
@@ -123,12 +128,13 @@ struct AHBPool {
 // Ownership & threading model:
 // - A registry entry is created on first use (by whichever of JS/native gets
 //   there first) and lives exactly as long as its JS Canvas: contextIds are
-//   never reused. It is removed by the native view's teardown (MetalView
-//   dealloc / WebGPUViewManager.onDropViewInstance) when a surface is
-//   attached, or by RNWebGPU.destroyContext (the Canvas unmount cleanup) when
-//   none ever was — see RNWebGPU::destroyContext for why the split. Surface
-//   destruction alone (backgrounding, TextureView teardown) never removes an
-//   entry; it only detaches the surface.
+//   never reused, not even across a reload (see allocateContextId). It is
+//   removed by the native view's teardown (MetalView dealloc /
+//   WebGPUViewManager.onDropViewInstance) when a surface is attached, or by
+//   RNWebGPU.destroyContext (the Canvas unmount cleanup) when none ever was —
+//   see RNWebGPU::destroyContext for why the split. Surface destruction alone
+//   (backgrounding, TextureView teardown) never removes an entry; it only
+//   detaches the surface.
 // - Attaching a surface is LATCHED: the UI thread stores it as pending
 //   (attachSurface) and it is adopted at the next frame boundary — start of
 //   getCurrentTexture or end of presentFrame — on whichever thread renders
@@ -147,8 +153,20 @@ struct AHBPool {
 //   native surface exists.
 class SurfaceInfo {
 public:
-  SurfaceInfo(wgpu::Instance gpu, int width, int height)
-      : _gpu(std::move(gpu)), _width(width), _height(height) {}
+  // releaseSurfaceOnUnconfigure is for a surface on a window the caller
+  // handed in (see SurfaceRegistry::makeUnregisteredSurfaceInfo), which no
+  // view attaches or detaches: unconfigure() then destroys the Dawn surface
+  // rather than only unconfiguring it, and configure() makes a new one for
+  // the same window. On Android, a window keeps the buffers it handed to the
+  // swapchain until the VkSurfaceKHR is destroyed, which Surface::Unconfigure
+  // does not do (it parks the swapchain for the next Configure): a MediaCodec
+  // input surface would otherwise keep them until the context is garbage
+  // collected. The window itself is retained until the SurfaceInfo is
+  // destroyed.
+  SurfaceInfo(wgpu::Instance gpu, int width, int height,
+              bool releaseSurfaceOnUnconfigure = false)
+      : _gpu(std::move(gpu)), _width(width), _height(height),
+        _releaseSurfaceOnUnconfigure(releaseSurfaceOnUnconfigure) {}
 
   ~SurfaceInfo() {
 #if defined(__ANDROID__)
@@ -279,7 +297,7 @@ public:
         }
         configureSurfaceLocked(config);
 #ifdef __APPLE__
-        applyCAMetalLayerColorSpace(_nativeSurface, _config.format);
+        applyCAMetalLayerColorSpace(_nativeSurface, _config.format, _colorSpace);
 #endif
         if (blit) {
           presentBlit = blitOffscreenToSurfaceLocked();
@@ -316,10 +334,12 @@ public:
   // -------------------------------------------------------
 
   void configure(wgpu::SurfaceConfiguration &newConfig,
-                 std::vector<wgpu::TextureFormat> viewFormats) {
+                 std::vector<wgpu::TextureFormat> viewFormats,
+                 CanvasColorSpace colorSpace = CanvasColorSpace::SRGB) {
     applyPendingAttach(/* supersedeInFlightFrame = */ true);
     std::unique_lock<std::shared_mutex> lock(_mutex);
     _viewFormats = std::move(viewFormats);
+    _colorSpace = colorSpace;
     _config = newConfig;
     // The caller's viewFormats storage dies with the call; point the stored
     // configuration at our own copy.
@@ -346,6 +366,10 @@ public:
       _poolUnsupported = false;
     }
 #endif
+    if (_releaseSurfaceOnUnconfigure && !_surface && _nativeSurface) {
+      // unconfigure() destroyed the surface; make a new one for the window.
+      recreateSurfaceLocked();
+    }
     _configureLocked();
   }
 
@@ -365,10 +389,22 @@ public:
   void unconfigure() {
     std::unique_lock<std::shared_mutex> lock(_mutex);
     if (_surface) {
-      _surface.Unconfigure();
+      if (_releaseSurfaceOnUnconfigure) {
+        // Destroy the surface, and so its swapchain, while their device is
+        // still alive. The window is kept: configure() makes a new surface
+        // for it (see the constructor).
+        _surface = nullptr;
+#if defined(__ANDROID__)
+        // DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE
+        _surfaceDevice = nullptr;
+#endif
+      } else {
+        _surface.Unconfigure();
+      }
     }
     _texture = nullptr;
     _config = {};
+    _colorSpace = CanvasColorSpace::SRGB;
     _viewFormats.clear();
     _acquiredFromSurface = false;
     _frameEpoch++;
@@ -875,7 +911,7 @@ private:
     if (_surface) {
       configureSurfaceLocked(_config);
 #ifdef __APPLE__
-      applyCAMetalLayerColorSpace(_nativeSurface, _config.format);
+      applyCAMetalLayerColorSpace(_nativeSurface, _config.format, _colorSpace);
 #endif
     } else {
       _texture = createOffscreenTextureLocked();
@@ -906,26 +942,24 @@ private:
 #endif
   }
 
-#if defined(__ANDROID__)
-  // DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE
   // Replace _surface with a new, unconfigured surface for the same native
-  // window. Dropping the old one runs ~Surface, which detaches both the
-  // active and the recycled swapchain against their still-alive device.
+  // window: after unconfigure() destroyed it (see the constructor), or on
+  // Android for DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE, where
+  // dropping the old one runs ~Surface, which detaches both the active and
+  // the recycled swapchain against their still-alive device.
   void recreateSurfaceLocked() {
     _surface = nullptr;
+#if defined(__ANDROID__)
+    // DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE
     _surfaceDevice = nullptr;
+#endif
     // A frame acquired from the old surface can no longer be presented.
     _acquiredFromSurface = false;
     _frameEpoch++;
     if (_nativeSurface) {
-      wgpu::SurfaceSourceAndroidNativeWindow source;
-      source.window = _nativeSurface;
-      wgpu::SurfaceDescriptor descriptor;
-      descriptor.nextInChain = &source;
-      _surface = _gpu.CreateSurface(&descriptor);
+      _surface = WebGPURuntime::makeSurface(_gpu, _nativeSurface);
     }
   }
-#endif
 
 #if defined(__ANDROID__)
   // Drop every pool generation and the ready / in-flight slot bookkeeping.
@@ -1241,12 +1275,15 @@ private:
   // that _config.viewFormats points at.
   wgpu::SurfaceConfiguration _config;
   std::vector<wgpu::TextureFormat> _viewFormats;
+  CanvasColorSpace _colorSpace = CanvasColorSpace::SRGB;
   // Keeps the Dawn instance alive for as long as any canvas exists.
   wgpu::Instance _gpu;
   // Native view size in dp (surfaced as clientWidth/clientHeight on the JS
   // canvas).
   int _width;
   int _height;
+  // See the constructor.
+  bool _releaseSurfaceOnUnconfigure = false;
 
 #if defined(__ANDROID__)
   // Pool state. Guarded by _poolMutex (never nested under _mutex while
@@ -1296,6 +1333,15 @@ public:
   SurfaceRegistry(const SurfaceRegistry &) = delete;
   SurfaceRegistry &operator=(const SurfaceRegistry &) = delete;
 
+  // The id of a Canvas about to mount. Ids are handed out here, once for the
+  // life of the process, rather than counted by each JS runtime from the
+  // same start: this registry outlives a reload, and the views of the bundle
+  // being replaced are torn down (removeSurfaceInfo) on the UI thread with
+  // no ordering against the new bundle's first canvases. An id counted from
+  // the same start as its predecessor would let the predecessor's teardown
+  // detach and erase the entry of a live canvas.
+  int allocateContextId() { return _nextContextId.fetch_add(1); }
+
   std::shared_ptr<SurfaceInfo> getSurfaceInfo(int id) {
     std::shared_lock<std::shared_mutex> lock(_mutex);
     auto it = _registry.find(id);
@@ -1357,6 +1403,19 @@ public:
     _registry.erase(it);
   }
 
+  // A SurfaceInfo that is not in the registry, for a context presenting to a
+  // native window of the caller's (see
+  // RNWebGPU::MakeWebGPUCanvasContextFromNativeWindow): the context owns it,
+  // no view attaches to it, and it releases its surface on unconfigure (see
+  // the SurfaceInfo constructor). It is still tracked for
+  // releaseSurfacesForDevice.
+  std::shared_ptr<SurfaceInfo>
+  makeUnregisteredSurfaceInfo(wgpu::Instance gpu, int width, int height) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    return makeSurfaceInfoLocked(std::move(gpu), width, height,
+                                 /* releaseSurfaceOnUnconfigure = */ true);
+  }
+
   // DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE
   // See SurfaceInfo::releaseSurfaceForDevice. Lock order is registry ->
   // SurfaceInfo, matching every other path.
@@ -1382,8 +1441,9 @@ public:
   }
 
   // Drops all entries. Called when the RN instance tears down (dev reload):
-  // JS context ids restart from scratch, so surviving entries would alias new
-  // canvases onto dead surfaces.
+  // the canvases of the old bundle never run their JS cleanup, and nothing
+  // reaches their ids again (see allocateContextId), so the entries would
+  // otherwise stay for the life of the process.
   void clear() {
     std::unique_lock<std::shared_mutex> lock(_mutex);
     _registry.clear();
@@ -1410,15 +1470,25 @@ private:
       _retired.erase(retired);
     }
     if (!info) {
-      info = std::make_shared<SurfaceInfo>(gpu, width, height);
-      // DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE
-      pruneAllSurfacesLocked();
-      _allSurfaces.push_back(info);
+      info = makeSurfaceInfoLocked(std::move(gpu), width, height);
     }
     _registry[id] = info;
     return info;
   }
 
+  // Every SurfaceInfo is made here, so releaseSurfacesForDevice reaches it
+  // whether or not it is in _registry.
+  std::shared_ptr<SurfaceInfo>
+  makeSurfaceInfoLocked(wgpu::Instance gpu, int width, int height,
+                        bool releaseSurfaceOnUnconfigure = false) {
+    auto info = std::make_shared<SurfaceInfo>(std::move(gpu), width, height,
+                                              releaseSurfaceOnUnconfigure);
+    // DAWN_WORKAROUND_DEVICE_DESTROY_BEFORE_SURFACE_RELEASE
+    pruneAllSurfacesLocked();
+    _allSurfaces.push_back(info);
+    return info;
+  }
+
   void pruneRetiredLocked() {
     for (auto it = _retired.begin(); it != _retired.end();) {
       it = it->second.expired() ? _retired.erase(it) : ++it;
@@ -1436,6 +1506,7 @@ private:
   }
 
   mutable std::shared_mutex _mutex;
+  std::atomic<int> _nextContextId{1};
   std::unordered_map<int, std::shared_ptr<SurfaceInfo>> _registry;
   // The entries JS retired while a GPUCanvasContext still held their
   // SurfaceInfo (see removeSurfaceInfoIfDetached). Non-owning; pruned on

package/cpp/rnwgpu/WebGPURuntime.cpp

@@ -9,18 +9,32 @@ namespace rnwgpu {
 namespace {
 
 wgpu::Instance createInstance() {
-  // If a Graphite build of react-native-skia is loaded in this
+  // If a Graphite build of react-native-skia is already loaded in this
   // process, adopt its wgpu::Instance instead of creating our own, so
-  // Graphite's device and every JS-created device live on one instance. That
-  // makes pointer-based handoff (RNWebGPU.importDevice of Skia's device)
-  // sound: the async pump serves the shared instance, so callbacks on
-  // imported devices settle. Discovered at runtime via dlsym so there is no
-  // build-time coupling and native-module init order does not matter. Both
-  // packages must link the same single Dawn copy (they vendor the same
-  // artifact) for the handle to be meaningful.
+  // Graphite's device and every JS-created device live on one instance.
+  // Discovered at runtime via dlsym so there is no build-time coupling. The
+  // adoption is best-effort and decided once, when the instance is first
+  // used: on Android it only succeeds when librnskia.so is loaded before
+  // react-native-webgpu installs (see the RTLD_NOLOAD lookup below), so the
+  // native-module init order decides whether the instance is shared.
+  // RNWebGPU.importDevice does not depend on it: an imported device's async
+  // work is pumped on the instance that owns it (see async::RuntimeContext).
+  // Both packages must link the same single Dawn copy (they vendor the same
+  // artifact) for the handles they exchange to be meaningful.
   using GetInstanceFn = WGPUInstance (*)();
-  if (auto getSkiaInstance = reinterpret_cast<GetInstanceFn>(
-          dlsym(RTLD_DEFAULT, "rnskia_getWGPUInstance"))) {
+  void *getter = dlsym(RTLD_DEFAULT, "rnskia_getWGPUInstance");
+#ifdef __ANDROID__
+  // System.loadLibrary loads librnskia.so with RTLD_LOCAL, so RTLD_DEFAULT
+  // does not search it. RTLD_NOLOAD returns its handle only if it is already
+  // loaded, so this never loads Skia.
+  if (getter == nullptr) {
+    if (void *skia = dlopen("librnskia.so", RTLD_NOW | RTLD_NOLOAD)) {
+      getter = dlsym(skia, "rnskia_getWGPUInstance");
+      dlclose(skia);
+    }
+  }
+#endif
+  if (auto getSkiaInstance = reinterpret_cast<GetInstanceFn>(getter)) {
     if (WGPUInstance external = getSkiaInstance()) {
       wgpuInstanceAddRef(external);
       return wgpu::Instance::Acquire(external);
@@ -76,6 +90,11 @@ wgpu::Instance WebGPURuntime::instance() {
 }
 
 wgpu::Surface WebGPURuntime::makeSurface(void *nativeSurface) {
+  return makeSurface(instance(), nativeSurface);
+}
+
+wgpu::Surface WebGPURuntime::makeSurface(const wgpu::Instance &gpu,
+                                         void *nativeSurface) {
 #if defined(__ANDROID__)
   wgpu::SurfaceSourceAndroidNativeWindow source;
   source.window = nativeSurface;
@@ -85,7 +104,7 @@ wgpu::Surface WebGPURuntime::makeSurface(void *nativeSurface) {
 #endif
   wgpu::SurfaceDescriptor descriptor;
   descriptor.nextInChain = &source;
-  return instance().CreateSurface(&descriptor);
+  return gpu.CreateSurface(&descriptor);
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/WebGPURuntime.h

@@ -15,14 +15,19 @@ class WebGPURuntime {
 public:
   static WebGPURuntime &shared();
 
-  // The process-wide instance: Skia Graphite's when that is loaded, otherwise
-  // our own. Created on first use. Safe to call from any thread.
+  // The process-wide instance: Skia Graphite's when that is already loaded on
+  // first use, otherwise our own. Safe to call from any thread.
   wgpu::Instance instance();
 
   // Creates a surface on the shared instance for a CAMetalLayer (Apple) or an
   // ANativeWindow (Android). Safe to call from any thread.
   wgpu::Surface makeSurface(void *nativeSurface);
 
+  // The same on a given instance: a SurfaceInfo recreates its surface on the
+  // instance it was made with.
+  static wgpu::Surface makeSurface(const wgpu::Instance &gpu,
+                                   void *nativeSurface);
+
   WebGPURuntime(const WebGPURuntime &) = delete;
   WebGPURuntime &operator=(const WebGPURuntime &) = delete;
 

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -29,7 +29,8 @@ void GPUCanvasContext::configure(
   surfaceConfiguration.alphaMode = configuration->alphaMode;
 #endif
   surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
-  _surfaceInfo->configure(surfaceConfiguration, std::move(viewFormats));
+  _surfaceInfo->configure(surfaceConfiguration, std::move(viewFormats),
+                          configuration->colorSpace);
 }
 
 void GPUCanvasContext::unconfigure() { _surfaceInfo->unconfigure(); }

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -35,6 +35,16 @@ public:
         registry.getSurfaceInfoOrCreate(contextId, _gpu->get(), width, height);
   }
 
+  // A context presenting to a surface of its own rather than a view's, outside
+  // of the registry (see RNWebGPU::MakeWebGPUCanvasContextFromNativeWindow).
+  GPUCanvasContext(std::shared_ptr<GPU> gpu,
+                   std::shared_ptr<SurfaceInfo> surfaceInfo, int width,
+                   int height)
+      : NativeObject(CLASS_NAME), _surfaceInfo(std::move(surfaceInfo)),
+        _gpu(std::move(gpu)) {
+    _canvas = std::make_shared<Canvas>(nullptr, width, height);
+  }
+
 public:
   std::string getBrand() { return CLASS_NAME; }
 

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -104,6 +104,7 @@ namespace rnwgpu {
   V(AdapterPropertiesWGPU, "adapter-properties-wgpu")                          \
   V(SharedBufferMemoryFromWindowsHandle,                                       \
     "shared-buffer-memory-from-windows-handle")                                \
+  V(SharedBufferMemoryHostPointer, "shared-buffer-memory-host-pointer")        \
   V(SharedTextureMemoryD3D12Resource, "shared-texture-memory-d3d12-resource")  \
   V(ChromiumExperimentalSamplingResourceTable,                                 \
     "chromium-experimental-sampling-resource-table")                           \

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cmath>
 #include <memory>
 #include <string>
 #include <utility>
@@ -18,6 +19,7 @@
 #include "PlatformContext.h"
 #include "VideoFrame.h"
 #include "VideoPlayer.h"
+#include "WebGPURuntime.h"
 
 #include <ReactCommon/CallInvoker.h>
 
@@ -83,13 +85,58 @@ public:
     return ctx;
   }
 
+  // A canvas context presenting to a native window that is not a WebGPU
+  // view, e.g. the input Surface of a MediaCodec encoder: an ANativeWindow*
+  // (Android) or a CAMetalLayer* (Apple), passed as a BigInt. Unlike a view's,
+  // the context owns its surface, outside of the SurfaceRegistry, and the
+  // caller drives it from one thread at a time. The context retains the
+  // window for as long as it lives; unconfigure() releases the surface (and
+  // on Android the buffers the window handed to it) and configure() makes a
+  // new one for the window, see the SurfaceInfo constructor.
+  std::shared_ptr<GPUCanvasContext>
+  MakeWebGPUCanvasContextFromNativeWindow(void *window, float width,
+                                          float height) {
+    if (window == nullptr) {
+      throw std::runtime_error(
+          "MakeWebGPUCanvasContextFromNativeWindow: expected a non-null "
+          "ANativeWindow (Android) or CAMetalLayer (Apple) pointer (BigInt)");
+    }
+    if (!(std::isfinite(width) && std::isfinite(height) && width > 0 &&
+          height > 0)) {
+      throw std::runtime_error(
+          "MakeWebGPUCanvasContextFromNativeWindow: expected a positive "
+          "width and height");
+    }
+    auto &runtime = WebGPURuntime::shared();
+    // Unlike a view's, this surface has no offscreen fallback worth having:
+    // nothing would ever show up, so fail here.
+    auto surface = runtime.makeSurface(window);
+    if (surface == nullptr) {
+      throw std::runtime_error(
+          "MakeWebGPUCanvasContextFromNativeWindow: could not create a surface "
+          "for the window; is it a valid ANativeWindow (Android) or "
+          "CAMetalLayer (Apple)?");
+    }
+    auto info = SurfaceRegistry::getInstance().makeUnregisteredSurfaceInfo(
+        runtime.instance(), static_cast<int>(width), static_cast<int>(height));
+    // The window is retained last, once nothing left here can throw: the
+    // SurfaceInfo owns the reference from here on. Adopted by the context's
+    // configure() (see SurfaceInfo::configure).
+    info->attachSurface(window, std::move(surface),
+                        _platformContext->retainNativeWindow(window));
+    return std::make_shared<GPUCanvasContext>(_gpu, std::move(info), width,
+                                              height);
+  }
+
   // Wrap an externally created WGPUDevice (passed as a BigInt pointer, e.g.
   // Skia's Graphite device from Skia.getNativeDevice()) in a GPUDevice.
   // AddRefs the handle, so the original owner keeps its reference. Only sound
-  // because the process links a single Dawn copy and the GPU instance is
-  // shared with the exporter (see the GPU constructor): the calling runtime's
-  // pump serves the instance the device lives on, so its async callbacks
-  // settle normally.
+  // because the process links a single Dawn copy. The device's async
+  // callbacks are pumped on the instance that owns it (RuntimeContext is per
+  // runtime and per instance), which is not necessarily the shared one:
+  // WebGPURuntime adopts Skia's instance only when Skia's getter is reachable
+  // as the instance is first used (on Android, only once librnskia.so is
+  // loaded), and other exporters have their own.
   std::shared_ptr<GPUDevice> importDevice(jsi::Runtime &runtime,
                                           void *pointer) {
     if (pointer == nullptr) {
@@ -99,7 +146,8 @@ public:
     auto raw = reinterpret_cast<WGPUDevice>(pointer);
     wgpuDeviceAddRef(raw);
     wgpu::Device device = wgpu::Device::Acquire(raw);
-    auto ctx = async::RuntimeContext::getOrCreate(runtime, _gpu->get());
+    auto ctx = async::RuntimeContext::getOrCreate(
+        runtime, device.GetAdapter().GetInstance());
     return std::make_shared<GPUDevice>(device, ctx, "Imported Device");
   }
 
@@ -282,6 +330,12 @@ public:
     return _platformContext->writeTestVideoFile();
   }
 
+  // The id for a Canvas about to mount, unique for the life of the process
+  // (see SurfaceRegistry::allocateContextId).
+  int allocateContextId() {
+    return rnwgpu::SurfaceRegistry::getInstance().allocateContextId();
+  }
+
   std::shared_ptr<Canvas> getNativeSurface(int contextId) {
     auto &registry = rnwgpu::SurfaceRegistry::getInstance();
     auto info = registry.getSurfaceInfo(contextId);
@@ -319,12 +373,16 @@ public:
     installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
     installMethod(runtime, prototype, "createImageBitmap",
                   &RNWebGPU::createImageBitmap);
+    installMethod(runtime, prototype, "allocateContextId",
+                  &RNWebGPU::allocateContextId);
     installMethod(runtime, prototype, "getNativeSurface",
                   &RNWebGPU::getNativeSurface);
     installMethod(runtime, prototype, "destroyContext",
                   &RNWebGPU::destroyContext);
     installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
                   &RNWebGPU::MakeWebGPUCanvasContext);
+    installMethod(runtime, prototype, "MakeWebGPUCanvasContextFromNativeWindow",
+                  &RNWebGPU::MakeWebGPUCanvasContextFromNativeWindow);
     installMethod(runtime, prototype, "loadVideoFrame",
                   &RNWebGPU::loadVideoFrame);
     installMethod(runtime, prototype, "createTestVideoFrame",

package/cpp/rnwgpu/api/VideoFrame.h

@@ -21,8 +21,8 @@ namespace jsi = facebook::jsi;
 class VideoFrame : public NativeObject<VideoFrame> {
 public:
   // JS-facing brand. installConstructor() exposes this as
-  // globalThis[CLASS_NAME] and keys the NativeObjectRegistry / worklet
-  // serializer off it, so it must NOT be "VideoFrame": that would install our
+  // globalThis[CLASS_NAME], and the NativeObjectRegistry / worklet serializer
+  // are keyed off it, so it must NOT be "VideoFrame": that would install our
   // constructor over the WebCodecs `VideoFrame` global and shadow it at
   // runtime. "NativeVideoFrame" matches the public TypeScript type (see
   // src/types.ts) and keeps the two namespaces distinct. The C++ class stays

package/cpp/rnwgpu/api/descriptors/GPUCanvasConfiguration.h

@@ -5,6 +5,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "CanvasColorSpace.h"
 #include "JSIConverter.h"
 
 #include "GPUDevice.h"
@@ -20,6 +21,7 @@ struct GPUCanvasConfiguration {
   std::optional<std::vector<wgpu::TextureFormat>>
       viewFormats; // Iterable<GPUTextureFormat>
   wgpu::CompositeAlphaMode alphaMode = wgpu::CompositeAlphaMode::Opaque;
+  CanvasColorSpace colorSpace = CanvasColorSpace::SRGB;
 };
 
 } // namespace rnwgpu
@@ -63,6 +65,22 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
           result->alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
         }
       }
+      if (value.hasProperty(runtime, "colorSpace")) {
+        auto prop = value.getProperty(runtime, "colorSpace");
+        if (!prop.isUndefined()) {
+          auto name = prop.asString(runtime).utf8(runtime);
+          if (name == "display-p3") {
+            result->colorSpace = CanvasColorSpace::DisplayP3;
+          } else if (name != "srgb") {
+            throw jsi::JSError(
+                runtime, "Failed to execute 'configure' on 'GPUCanvasContext': "
+                         "The provided value '" +
+                             name +
+                             "' is not a valid enum value of type "
+                             "PredefinedColorSpace.");
+          }
+        }
+      }
     }
 
     return result;