react-native-webgpu 0.17.0 → 0.19.0

package/android/cpp/AndroidPlatformContext.h

@@ -3,6 +3,7 @@
 #include <android/bitmap.h>
 #include <android/data_space.h>
 #include <android/hardware_buffer.h>
+#include <android/native_window.h>
 #include <dlfcn.h>
 #include <jni.h>
 
@@ -469,6 +470,13 @@ public:
         "writeTestVideoFile is not yet implemented on Android.");
   }
 
+  std::function<void(void *)> retainNativeWindow(void *window) override {
+    ANativeWindow_acquire(static_cast<ANativeWindow *>(window));
+    return [](void *nativeWindow) {
+      ANativeWindow_release(static_cast<ANativeWindow *>(nativeWindow));
+    };
+  }
+
   VideoFrameHandle wrapNativeBuffer(void *pointer) override {
     if (!pointer) {
       throw std::runtime_error("wrapNativeBuffer: pointer is null");

package/apple/ApplePlatformContext.h

@@ -48,6 +48,8 @@ public:
 
   VideoFrameHandle wrapNativeBuffer(void *pointer) override;
 
+  std::function<void(void *)> retainNativeWindow(void *window) override;
+
 private:
   ViewLookup _viewLookup;
 };

package/apple/ApplePlatformContext.mm

@@ -556,6 +556,18 @@ VideoFrameHandle ApplePlatformContext::wrapNativeBuffer(void *pointer) {
   return wrapCVPixelBuffer(static_cast<CVPixelBufferRef>(pointer));
 }
 
+std::function<void(void *)>
+ApplePlatformContext::retainNativeWindow(void *window) {
+  CFRetain(window);
+  return [](void *layer) {
+    // As MetalView's: the releaser can run on the rendering thread, and
+    // CALayer teardown belongs on the main thread.
+    dispatch_async(dispatch_get_main_queue(), ^{
+      CFRelease(layer);
+    });
+  };
+}
+
 // The NV12 variant of createTestVideoFrame: a biplanar BT.709 limited-range
 // frame, red on the left half and green on the right, whose attachments
 // declare its color space the way the decoder's frames do, so that the

package/apple/MetalLayerColorSpace.mm

@@ -3,32 +3,44 @@
 #import <QuartzCore/CAMetalLayer.h>
 #import <QuartzCore/CATransaction.h>
 
+#include "CanvasColorSpace.h"
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
 
-// WebGPU canvas values are sRGB-encoded regardless of the texture format
-// (GPUCanvasConfiguration.colorSpace defaults to "srgb"), so the same shader
+// WebGPU canvas values are encoded with the sRGB transfer function regardless
+// of the texture format, and GPUCanvasConfiguration.colorSpace says which
+// primaries they are in: "srgb" (the default) or "display-p3". The same shader
 // output must display identically on bgra8unorm and rgba16float surfaces.
 // Core Animation interprets a float-format layer with a nil colorspace as
 // extended *linear* sRGB, which displays the same values noticeably brighter.
 // Tagging the layer as (gamma-encoded) extended sRGB matches the browser
-// behavior: identical colors, with the extra precision of float16.
+// behavior: identical colors, with the extra precision of float16. For
+// "display-p3" the layer is tagged Display P3 instead, or its extended range
+// variant on a float format, so the values reach a wide-gamut display without
+// being converted from sRGB first.
 void applyCAMetalLayerColorSpace(void *nativeSurface,
-                                 wgpu::TextureFormat format) {
+                                 wgpu::TextureFormat format,
+                                 CanvasColorSpace canvasColorSpace) {
   CALayer *layer = (__bridge CALayer *)nativeSurface;
   if (![layer isKindOfClass:[CAMetalLayer class]]) {
     return;
   }
   auto metalLayer = static_cast<CAMetalLayer *>(layer);
-  if (format == wgpu::TextureFormat::RGBA16Float) {
-    CGColorSpaceRef colorSpace =
-        CGColorSpaceCreateWithName(kCGColorSpaceExtendedSRGB);
+  const bool isFloat = format == wgpu::TextureFormat::RGBA16Float;
+  CFStringRef name = nullptr;
+  if (canvasColorSpace == CanvasColorSpace::DisplayP3) {
+    name = isFloat ? kCGColorSpaceExtendedDisplayP3 : kCGColorSpaceDisplayP3;
+  } else if (isFloat) {
+    name = kCGColorSpaceExtendedSRGB;
+  }
+  if (name != nullptr) {
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(name);
     metalLayer.colorspace = colorSpace;
     CGColorSpaceRelease(colorSpace);
   } else if (metalLayer.colorspace != nil) {
     // Restore the default (no color matching) when reconfiguring back to an
-    // 8-bit format.
+    // 8-bit sRGB canvas.
     metalLayer.colorspace = nil;
   }
   // The change must be set synchronously so the first present already sees

package/cpp/rnwgpu/CanvasColorSpace.h

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace rnwgpu {
+
+// GPUCanvasConfiguration.colorSpace (PredefinedColorSpace): how the canvas's
+// values are interpreted when it is composited.
+enum class CanvasColorSpace { SRGB, DisplayP3 };
+
+} // namespace rnwgpu

package/cpp/rnwgpu/PlatformContext.h

@@ -243,6 +243,12 @@ public:
   // safely release their own reference immediately after.
   virtual VideoFrameHandle wrapNativeBuffer(void *pointer) = 0;
 
+  // Retain a native window obtained from another library, to present to it
+  // (an ANativeWindow* on Android, a CAMetalLayer* on Apple platforms), and
+  // return the releaser that balances that reference once the surface is done
+  // with it. The releaser can run on any thread.
+  virtual std::function<void(void *)> retainNativeWindow(void *window) = 0;
+
   // Write a small procedurally-generated test video to a temporary location
   // and return its absolute path. Lets the SharedTextureMemory example play
   // a real decoded video without bundling an asset.

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -167,9 +167,9 @@ void RNWebGPUManager::flushPendingSurfaceTransition(
 }
 
 RNWebGPUManager::~RNWebGPUManager() {
-  // Drop all canvas registry entries: after a reload the JS side restarts its
-  // contextId counter, and stale entries would alias new canvases onto dead
-  // surfaces.
+  // Drop the canvas registry entries of this runtime's bundle: its canvases
+  // never run their JS cleanup, and their ids are not handed out again (see
+  // SurfaceRegistry::allocateContextId).
   SurfaceRegistry::getInstance().clear();
   if (PlatformContext::current() == _platformContext) {
     PlatformContext::setCurrent(nullptr);

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/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",