react-native-webgpu 0.15.1 → 0.16.0

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -59,7 +59,7 @@ struct Size {
 using NativeSurfaceReleaser = std::function<void(void *)>;
 
 #if defined(__ANDROID__)
-// --- AHB-pool presentation mode (WebGPUHardwareBufferView)
+// --- AHB-pool presentation mode (WebGPUNativeBufferView)
 // -----------------------------
 //
 // A third presentation backend (besides the on-screen wgpu::Surface swapchain
@@ -71,7 +71,7 @@ using NativeSurfaceReleaser = std::function<void(void *)>;
 // like the swapchain, so the canvas texture always matches the app's other
 // attachments (e.g. its depth texture).
 
-#define RNWGPU_LOG_TAG "WebGPUHardwareBufferView"
+#define RNWGPU_LOG_TAG "WebGPUNativeBufferView"
 // Failure / anomaly reporting only (never per-frame).
 #define RNWGPU_POOL_WARN(...)                                                  \
   __android_log_print(ANDROID_LOG_WARN, RNWGPU_LOG_TAG, __VA_ARGS__)
@@ -435,7 +435,7 @@ public:
   bool hasNativeSurface() {
     std::shared_lock<std::shared_mutex> lock(_mutex);
 #if defined(__ANDROID__)
-    // A WebGPUHardwareBufferView in pool mode owns presentation the same way a
+    // A WebGPUNativeBufferView in pool mode owns presentation the same way a
     // surface-backed view does, and retires the entry on its own teardown.
     if (_poolMode.load()) {
       return true;
@@ -548,16 +548,27 @@ public:
     if (device) {
       dawn::native::metal::WaitForCommandsToBeScheduled(device.Get());
     }
+#endif
+#if defined(__ANDROID__)
+    std::function<void()> framePresented;
 #endif
     {
       std::unique_lock<std::shared_mutex> lock(_mutex);
       if (_surface && _acquiredFromSurface) {
         _surface.Present();
+#if defined(__ANDROID__)
+        framePresented = _framePresented;
+#endif
       }
       _acquiredFromSurface = false;
       _frameInFlight = false;
       _frameEpoch++;
     }
+#if defined(__ANDROID__)
+    if (framePresented) {
+      framePresented();
+    }
+#endif
     applyPendingAttach();
   }
 
@@ -691,6 +702,16 @@ public:
     std::lock_guard<std::mutex> poolLock(_poolMutex);
     _poolFrameReady = std::move(cb);
   }
+
+  // Invoked from the presenting thread (never under _mutex) after each frame
+  // presentFrame() shows on the attached surface; the blit of the last
+  // offscreen frame onto a newly attached surface does not count. The view
+  // uses it to vote the display's refresh rate while the canvas animates
+  // (see SurfaceFrameRateVote.java). Pass nullptr to unregister.
+  void setFramePresentedCallback(std::function<void()> cb) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _framePresented = std::move(cb);
+  }
 #endif
 
 private:
@@ -704,7 +725,7 @@ private:
     {
       std::unique_lock<std::shared_mutex> lock(_mutex);
 #if defined(__ANDROID__)
-      // Leaving pool mode (the WebGPUHardwareBufferView detached): drop the
+      // Leaving pool mode (the WebGPUNativeBufferView detached): drop the
       // pool. A configured context keeps rendering into the offscreen
       // fallback, exactly like the surface path.
       if (_poolMode.load()) {
@@ -1239,6 +1260,9 @@ private:
   static constexpr int kPoolSize =
       5; // 2 held + 1 rendering + 1 waiting + 1 ready
 
+  // See setFramePresentedCallback(); read under _mutex, called outside it.
+  std::function<void()> _framePresented;
+
   std::atomic<bool> _poolMode{false};
   std::mutex _poolMutex;
   std::condition_variable _freeCv;    // a slot returned to Free

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -1,5 +1,6 @@
 #include "GPUDevice.h"
 
+#include <cstdio>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -15,6 +16,7 @@
 #include "GPUInternalError.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUValidationError.h"
+#include "NativeFrameImport.h"
 #include "SurfaceRegistry.h"
 
 namespace rnwgpu {
@@ -130,6 +132,14 @@ std::shared_ptr<GPUSupportedLimits> GPUDevice::getLimits() {
   return std::make_shared<GPUSupportedLimits>(limits);
 }
 
+std::shared_ptr<GPUAdapterInfo> GPUDevice::getAdapterInfo() {
+  wgpu::AdapterInfo info = {};
+  if (_instance.GetAdapterInfo(&info) != wgpu::Status::Success) {
+    throw std::runtime_error("failed to get the device's adapter info");
+  }
+  return std::make_shared<GPUAdapterInfo>(info);
+}
+
 std::shared_ptr<GPUQueue> GPUDevice::getQueue() {
   auto result = _instance.GetQueue();
   return std::make_shared<GPUQueue>(_instance, result, _async, _videoFrameBlit,
@@ -413,6 +423,92 @@ std::shared_ptr<GPUSharedFence> GPUDevice::importSharedFence(
                                           std::move(label));
 }
 
+std::shared_ptr<GPUNativeBufferTexture> GPUDevice::createNativeBufferTexture(
+    std::shared_ptr<VideoFrame> source,
+    std::optional<std::shared_ptr<GPUNativeBufferTextureDescriptor>>
+        descriptor) {
+  static constexpr const char *kCaller = "GPUDevice::createNativeBufferTexture";
+  if (!source) {
+    throw std::runtime_error("GPUDevice::createNativeBufferTexture(): "
+                             "source (NativeVideoFrame) is required");
+  }
+  std::string label;
+  std::optional<double> usage;
+  if (descriptor.has_value() && *descriptor) {
+    label = (*descriptor)->label.value_or("");
+    usage = (*descriptor)->usage;
+  }
+  auto memory =
+      native_frame::importMemory(_instance, source->handle(), label, kCaller);
+  wgpu::Texture texture;
+  if (usage.has_value()) {
+    // Dawn's layer describes the texture from the memory's properties, with
+    // the caller's usage. An unsupported usage is a validation error and an
+    // error texture, as with createTexture().
+    wgpu::SharedTextureMemoryProperties properties{};
+    (void)memory.GetProperties(&properties);
+    wgpu::TextureDescriptor desc{};
+    if (!label.empty()) {
+      desc.label = wgpu::StringView(label.c_str(), label.size());
+    }
+    desc.usage = static_cast<wgpu::TextureUsage>(static_cast<uint64_t>(*usage));
+    desc.dimension = wgpu::TextureDimension::e2D;
+    desc.size = properties.size;
+    desc.format = properties.format;
+    desc.mipLevelCount = 1;
+    desc.sampleCount = 1;
+    texture = memory.CreateTexture(&desc);
+  } else {
+    texture = memory.CreateTexture();
+  }
+  if (texture == nullptr) {
+    throw std::runtime_error("GPUDevice::createNativeBufferTexture(): "
+                             "CreateTexture returned null");
+  }
+  auto wrapped = std::make_shared<GPUTexture>(std::move(texture), label);
+  return std::make_shared<GPUNativeBufferTexture>(
+      _instance, std::move(memory), std::move(wrapped), std::move(source),
+      std::move(label));
+}
+
+std::shared_ptr<GPUNativeBufferExternalTexture>
+GPUDevice::createNativeBufferExternalTexture(
+    std::shared_ptr<VideoFrame> source,
+    std::optional<std::shared_ptr<GPUExternalTextureDescriptor>> descriptor) {
+  static constexpr const char *kCaller =
+      "GPUDevice::createNativeBufferExternalTexture";
+  if (!source) {
+    throw std::runtime_error(
+        "GPUDevice::createNativeBufferExternalTexture(): source "
+        "(NativeVideoFrame) is required");
+  }
+  std::shared_ptr<GPUExternalTextureDescriptor> options =
+      descriptor.has_value() && *descriptor
+          ? *descriptor
+          : std::make_shared<GPUExternalTextureDescriptor>();
+  const auto &frame = source->handle();
+  std::string label = options->label.value_or("external-texture");
+  // The import, the texture and the external texture, once per buffer. No
+  // access begins here: the wrapper's beginAccess() / endAccess() bracket
+  // each use.
+  auto memory = native_frame::importMemory(_instance, frame, label, kCaller);
+  auto texture = memory.CreateTexture();
+  if (texture == nullptr) {
+    throw std::runtime_error(
+        "GPUDevice::createNativeBufferExternalTexture(): CreateTexture "
+        "returned null");
+  }
+  auto external = native_frame::createExternalTexture(
+      _instance, memory, texture, frame, *options, label, kCaller);
+  // Non-owning: the wrapper owns the import (see GPUExternalTexture's
+  // constructor).
+  auto externalTexture = std::make_shared<GPUExternalTexture>(
+      std::move(external), nullptr, nullptr, nullptr, label);
+  return std::make_shared<GPUNativeBufferExternalTexture>(
+      _instance, std::move(memory), std::move(texture),
+      std::move(externalTexture), std::move(source), std::move(label));
+}
+
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
     jsi::Runtime &runtime,
     std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {

package/cpp/rnwgpu/api/GPUDevice.h

@@ -20,6 +20,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUAdapterInfo.h"
 #include "GPUBindGroup.h"
 #include "GPUBindGroupDescriptor.h"
 #include "GPUBindGroupLayout.h"
@@ -34,6 +35,9 @@
 #include "GPUError.h"
 #include "GPUExternalTexture.h"
 #include "GPUExternalTextureDescriptor.h"
+#include "GPUNativeBufferExternalTexture.h"
+#include "GPUNativeBufferTexture.h"
+#include "GPUNativeBufferTextureDescriptor.h"
 #include "GPUPipelineLayout.h"
 #include "GPUPipelineLayoutDescriptor.h"
 #include "GPUQuerySet.h"
@@ -124,6 +128,17 @@ public:
       std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor);
   std::shared_ptr<GPUSharedFence>
   importSharedFence(std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
+  // Import a native buffer once and bracket each use with beginAccess /
+  // endAccess: the counterparts of createTexture / createExternalTexture in
+  // GPUAndroidHardwareBufferUtil of Dawn's Android layer.
+  std::shared_ptr<GPUNativeBufferTexture> createNativeBufferTexture(
+      std::shared_ptr<VideoFrame> source,
+      std::optional<std::shared_ptr<GPUNativeBufferTextureDescriptor>>
+          descriptor);
+  std::shared_ptr<GPUNativeBufferExternalTexture>
+  createNativeBufferExternalTexture(
+      std::shared_ptr<VideoFrame> source,
+      std::optional<std::shared_ptr<GPUExternalTextureDescriptor>> descriptor);
   std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -153,6 +168,7 @@ public:
 
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
+  std::shared_ptr<GPUAdapterInfo> getAdapterInfo();
   std::shared_ptr<GPUQueue> getQueue();
   jsi::Value getLost(jsi::Runtime &runtime, const jsi::Object &wrapper);
   void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
@@ -183,6 +199,10 @@ public:
                   &GPUDevice::importSharedTextureMemory);
     installMethod(runtime, prototype, "importSharedFence",
                   &GPUDevice::importSharedFence);
+    installMethod(runtime, prototype, "createNativeBufferTexture",
+                  &GPUDevice::createNativeBufferTexture);
+    installMethod(runtime, prototype, "createNativeBufferExternalTexture",
+                  &GPUDevice::createNativeBufferExternalTexture);
     installMethod(runtime, prototype, "createBindGroupLayout",
                   &GPUDevice::createBindGroupLayout);
     installMethod(runtime, prototype, "createPipelineLayout",
@@ -211,6 +231,8 @@ public:
                              &GPUDevice::popErrorScope);
     installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
+    installGetter(runtime, prototype, "adapterInfo",
+                  &GPUDevice::getAdapterInfo);
     installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);
     // `lost` is installed manually: the getter needs the wrapper object
     // itself, because the promise (and its resolve function) are cached as

package/cpp/rnwgpu/api/GPUError.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <utility>
 
 #include "NativeObject.h"
 

package/cpp/rnwgpu/api/GPUExtent2D.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+#include <stdexcept>
+
+#include "JSIConverter.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+// A 2D size, as an object ({ width, height }) or an array ([width, height]),
+// the two forms the spec gives GPUExtent3D. Both members are required in
+// either form: a crop size with a missing one would be empty.
+struct GPUExtent2D {
+  double width = 0;
+  double height = 0;
+};
+
+template <> struct JSIConverter<std::shared_ptr<GPUExtent2D>> {
+  static std::shared_ptr<GPUExtent2D>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<GPUExtent2D>();
+    if (!outOfBounds && arg.isObject()) {
+      if (arg.getObject(runtime).isArray(runtime)) {
+        auto array = arg.getObject(runtime).asArray(runtime);
+        if (array.size(runtime) < 2) {
+          throw std::runtime_error(
+              "Expected an array of size 2 for GPUExtent2D");
+        }
+        result->width = array.getValueAtIndex(runtime, 0).asNumber();
+        result->height = array.getValueAtIndex(runtime, 1).asNumber();
+      } else {
+        auto object = arg.getObject(runtime);
+        auto width = object.getProperty(runtime, "width");
+        auto height = object.getProperty(runtime, "height");
+        if (!width.isNumber() || !height.isNumber()) {
+          throw std::runtime_error(
+              "Expected numbers for the width and height of GPUExtent2D");
+        }
+        result->width = width.asNumber();
+        result->height = height.asNumber();
+      }
+    } else {
+      throw std::runtime_error("Expected an object for GPUExtent2D");
+    }
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<GPUExtent2D> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+
+} // namespace rnwgpu