react-native-webgpu 0.15.1 → 0.16.0

package/cpp/rnwgpu/api/GPUNativeBufferTexture.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUNativeBufferWrapper.h"
+#include "GPUTexture.h"
+#include "VideoFrame.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// A native color buffer (an RGBA / R8 / ... AHardwareBuffer, a BGRA IOSurface)
+// imported once as a regular texture, with the access window of each use
+// explicit: GPUHardwareBufferTexture of Dawn's Android layer. Created by
+// GPUDevice.createNativeBufferTexture().
+class GPUNativeBufferTexture
+    : public GPUNativeBufferWrapper<GPUNativeBufferTexture, GPUTexture> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUNativeBufferTexture";
+
+  GPUNativeBufferTexture(wgpu::Device device, wgpu::SharedTextureMemory memory,
+                         std::shared_ptr<GPUTexture> texture,
+                         std::shared_ptr<VideoFrame> source, std::string label)
+      : GPUNativeBufferWrapper(std::move(device), std::move(memory),
+                               texture->get(), texture, std::move(source),
+                               std::move(label)) {}
+
+  // The texture that aliases the buffer. Bind it only between beginAccess()
+  // and endAccess().
+  std::shared_ptr<GPUTexture> getTexture() { return _wrapped; }
+
+  // Releases the texture and the import (see NativeBufferAccess::destroy).
+  void destroy() {
+    _access.destroy();
+    _wrapped->destroy();
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    defineWrapperPrototype(runtime, prototype);
+    installGetter(runtime, prototype, "texture",
+                  &GPUNativeBufferTexture::getTexture);
+    installMethod(runtime, prototype, "destroy",
+                  &GPUNativeBufferTexture::destroy);
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUNativeBufferWrapper.cpp

@@ -0,0 +1,144 @@
+#include "GPUNativeBufferWrapper.h"
+
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "DestroyedError.h"
+#include "GPUSharedFence.h"
+#include "GPUSharedFenceState.h"
+#include "NativeFrameImport.h"
+
+namespace rnwgpu {
+
+NativeBufferAccess::NativeBufferAccess(const char *className,
+                                       wgpu::Device device,
+                                       wgpu::SharedTextureMemory memory,
+                                       wgpu::Texture texture,
+                                       std::shared_ptr<VideoFrame> source,
+                                       std::string label)
+    : _className(className), _device(std::move(device)),
+      _memory(std::move(memory)), _texture(std::move(texture)),
+      _source(std::move(source)), _label(std::move(label)) {}
+
+// The garbage-collection fallback: releases without reporting, there is no
+// one left to report to.
+NativeBufferAccess::~NativeBufferAccess() { release(false); }
+
+void NativeBufferAccess::setLabel(const std::string &label) {
+  _label = label;
+  if (_memory) {
+    _memory.SetLabel(_label.c_str());
+  }
+}
+
+void NativeBufferAccess::injectDestroyedError(const char *method) {
+  reportDestroyedUse(_device, _className, _label, method);
+}
+
+void NativeBufferAccess::beginAccess(jsi::Runtime &runtime,
+                                     const jsi::Value *args, size_t count) {
+  const std::string caller = std::string(_className) + "::beginAccess";
+  // Fails like an access Dawn rejects: a validation error, then the throw.
+  if (!_memory) {
+    injectDestroyedError("beginAccess");
+    throw jsi::JSError(runtime, caller + "(): the wrapper was destroyed");
+  }
+  // Built in lockstep so fenceCount covers both arrays, and kept in locals so
+  // the raw pointers outlive the synchronous BeginAccess() below.
+  std::vector<wgpu::SharedFence> fences;
+  std::vector<uint64_t> signaledValues;
+  if (count > 0 && !args[0].isUndefined() && !args[0].isNull()) {
+    auto states = JSIConverter<
+        std::vector<std::shared_ptr<GPUSharedFenceState>>>::fromJSI(runtime,
+                                                                    args[0],
+                                                                    false);
+    for (const auto &state : states) {
+      if (!state || !state->fence) {
+        continue;
+      }
+      auto fence = state->fence->get();
+      if (!fence) {
+        state->fence->injectDestroyedError("beginAccess");
+        throw jsi::JSError(runtime, caller + "(): a fence was destroyed");
+      }
+      fences.push_back(std::move(fence));
+      signaledValues.push_back(state->signaledValue);
+    }
+  }
+  try {
+    native_frame::beginAccess(_memory, _texture, true, fences, signaledValues,
+                              caller.c_str());
+  } catch (const std::exception &e) {
+    throw jsi::JSError(runtime, e.what());
+  }
+  _accessOpen = true;
+}
+
+jsi::Value NativeBufferAccess::endAccess(jsi::Runtime &runtime) {
+  const std::string caller = std::string(_className) + "::endAccess";
+  if (!_memory) {
+    injectDestroyedError("endAccess");
+    throw jsi::JSError(runtime, caller + "(): the wrapper was destroyed");
+  }
+  wgpu::SharedTextureMemoryEndAccessState state{};
+  try {
+    native_frame::endAccess(_memory, _texture, &state, caller.c_str());
+  } catch (const std::exception &e) {
+    throw jsi::JSError(runtime, e.what());
+  }
+  _accessOpen = false;
+
+  wgpu::SharedFence fence;
+  uint64_t signaledValue = 0;
+  bool hasFence = false;
+  try {
+    hasFence = native_frame::mergeFences(_device, state, &fence, &signaledValue,
+                                         caller.c_str());
+  } catch (const std::exception &e) {
+    throw jsi::JSError(runtime, e.what());
+  }
+  if (!hasFence) {
+    return jsi::Value::null();
+  }
+  jsi::Object result(runtime);
+  result.setProperty(
+      runtime, "fence",
+      GPUSharedFence::create(runtime, std::make_shared<GPUSharedFence>(
+                                          _device, std::move(fence), "")));
+  result.setProperty(runtime, "signaledValue",
+                     jsi::BigInt::fromUint64(runtime, signaledValue));
+  return result;
+}
+
+void NativeBufferAccess::destroy() { release(true); }
+
+void NativeBufferAccess::release(bool reportOpenAccess) {
+  if (!_memory) {
+    return;
+  }
+  if (_accessOpen) {
+    if (reportOpenAccess) {
+      // Dawn's contract is an endAccess() for every beginAccess(). Report the
+      // misuse, and end the access anyway: the wrapper owns the texture, so
+      // an access left open would keep the buffer from its producer for good.
+      auto message = "Destroyed " + describeDestroyed(_className, _label) +
+                     " with an access still open: call endAccess() first. The "
+                     "access was ended; its fence is lost.";
+      _device.InjectError(wgpu::ErrorType::Validation, message.c_str());
+    }
+    native_frame::endAccess(_memory, _texture);
+    _accessOpen = false;
+  }
+  if (_texture) {
+    _texture.Destroy();
+  }
+  _texture = nullptr;
+  _memory = nullptr;
+  _source = nullptr;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUNativeBufferWrapper.h

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <jsi/jsi.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "NativeObject.h"
+#include "VideoFrame.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// What GPUNativeBufferTexture and GPUNativeBufferExternalTexture share:
+// the import of a native buffer, done once, the access window around each use
+// and the release. The counterpart of GPUHardwareBufferWrapper in Dawn's
+// Android layer (tools/android/webgpu), whose JNI side owns the same objects:
+// the shared texture memory, the texture, the buffer reference.
+//
+// A decoder or a camera renders into the same few buffers in turn: importing
+// each one once and bracketing every frame with beginAccess() / endAccess()
+// is what Dawn's layer does, and saves the import (and the pipeline recreation
+// behind a new external texture) that importExternalTexture() pays per frame.
+class NativeBufferAccess {
+public:
+  NativeBufferAccess(const char *className, wgpu::Device device,
+                     wgpu::SharedTextureMemory memory, wgpu::Texture texture,
+                     std::shared_ptr<VideoFrame> source, std::string label);
+  ~NativeBufferAccess();
+
+  NativeBufferAccess(const NativeBufferAccess &) = delete;
+  NativeBufferAccess &operator=(const NativeBufferAccess &) = delete;
+
+  // beginAccess(fences?): begins an access to the buffer's texture, after the
+  // GPU waited for the optional GPUSharedFenceState[] (the producer's fence
+  // for the frame: NativeVideoFrame.acquireFenceFd imported with
+  // importSharedFence, or the fences a native module hands over). The frame
+  // is taken as initialized, as Dawn's layer does. Throws (after a validation
+  // error) on a destroyed wrapper or fence, and if Dawn rejects the access.
+  void beginAccess(jsi::Runtime &runtime, const jsi::Value *args, size_t count);
+
+  // endAccess(): ends the access and returns the one fence that signals once
+  // the GPU work of the access is done, as { fence, signaledValue }, or null
+  // when there is none. Hand it to the buffer's producer before it reuses the
+  // buffer, or destroy it.
+  jsi::Value endAccess(jsi::Runtime &runtime);
+
+  // Releases the import now rather than when the JS object is garbage
+  // collected: the texture, the memory and the frame that keeps the buffer
+  // alive. An access still open is a validation error; it is ended (its fence
+  // is lost) so the producer gets its buffer back. A later use is a validation
+  // error and a throw.
+  void destroy();
+
+  bool destroyed() const { return _memory == nullptr; }
+
+  const std::string &label() const { return _label; }
+  void setLabel(const std::string &label);
+
+private:
+  void release(bool reportOpenAccess);
+  void injectDestroyedError(const char *method);
+
+  const char *_className;
+  wgpu::Device _device;
+  wgpu::SharedTextureMemory _memory;
+  wgpu::Texture _texture;
+  // Keeps the native buffer (and, on Android, its acquire fence) alive for as
+  // long as the import is.
+  std::shared_ptr<VideoFrame> _source;
+  std::string _label;
+  bool _accessOpen = false;
+};
+
+// The JS side GPUNativeBufferTexture and GPUNativeBufferExternalTexture share:
+// beginAccess(), endAccess(), the label and the brand, around a
+// NativeBufferAccess and the object it wraps (a GPUTexture, a
+// GPUExternalTexture), which takes the label too. Each class installs the
+// getter of its wrapped object and its destroy(), whose order differs.
+template <typename Derived, typename Wrapped>
+class GPUNativeBufferWrapper : public NativeObject<Derived> {
+public:
+  GPUNativeBufferWrapper(wgpu::Device device, wgpu::SharedTextureMemory memory,
+                         wgpu::Texture texture,
+                         std::shared_ptr<Wrapped> wrapped,
+                         std::shared_ptr<VideoFrame> source, std::string label)
+      : NativeObject<Derived>(Derived::CLASS_NAME),
+        _access(Derived::CLASS_NAME, std::move(device), std::move(memory),
+                std::move(texture), std::move(source), std::move(label)),
+        _wrapped(std::move(wrapped)) {}
+
+  std::string getBrand() { return Derived::CLASS_NAME; }
+
+  jsi::Value beginAccess(jsi::Runtime &runtime, const jsi::Value &,
+                         const jsi::Value *args, size_t count) {
+    _access.beginAccess(runtime, args, count);
+    return jsi::Value::undefined();
+  }
+
+  jsi::Value endAccess(jsi::Runtime &runtime, const jsi::Value &,
+                       const jsi::Value *, size_t) {
+    return _access.endAccess(runtime);
+  }
+
+  std::string getLabel() { return _access.label(); }
+  void setLabel(const std::string &label) {
+    _access.setLabel(label);
+    _wrapped->setLabel(label);
+  }
+
+protected:
+  using HostMethod = jsi::Value (Derived::*)(jsi::Runtime &, const jsi::Value &,
+                                             const jsi::Value *, size_t);
+
+  static void defineWrapperPrototype(jsi::Runtime &runtime,
+                                     jsi::Object &prototype) {
+    using Base = NativeObject<Derived>;
+    Base::installGetter(runtime, prototype, "__brand",
+                        static_cast<std::string (Derived::*)()>(
+                            &GPUNativeBufferWrapper::getBrand));
+    Base::installMethod(
+        runtime, prototype, "beginAccess",
+        static_cast<HostMethod>(&GPUNativeBufferWrapper::beginAccess));
+    Base::installMethod(
+        runtime, prototype, "endAccess",
+        static_cast<HostMethod>(&GPUNativeBufferWrapper::endAccess));
+    Base::installGetterSetter(
+        runtime, prototype, "label",
+        static_cast<std::string (Derived::*)()>(
+            &GPUNativeBufferWrapper::getLabel),
+        static_cast<void (Derived::*)(const std::string &)>(
+            &GPUNativeBufferWrapper::setLabel));
+  }
+
+  NativeBufferAccess _access;
+  std::shared_ptr<Wrapped> _wrapped;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

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

package/cpp/rnwgpu/api/GPUQueue.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "Unions.h"

package/cpp/rnwgpu/api/GPUSharedFence.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "NativeObject.h"
 

package/cpp/rnwgpu/api/GPUSharedTextureMemory.cpp

@@ -4,9 +4,12 @@
 #include <memory>
 #include <stdexcept>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "Convertors.h"
 #include "DestroyedError.h"
+#include "NativeFrameImport.h"
 
 namespace rnwgpu {
 
@@ -87,9 +90,6 @@ void GPUSharedTextureMemory::beginAccess(
     throw std::runtime_error(
         "GPUSharedTextureMemory::beginAccess(): the memory was destroyed");
   }
-  wgpu::SharedTextureMemoryBeginAccessDescriptor desc{};
-  desc.initialized = initialized;
-  desc.concurrentRead = false;
 
   // Built in lockstep so fenceCount covers both arrays, and kept in locals so
   // the raw pointers outlive the synchronous BeginAccess() below.
@@ -109,36 +109,11 @@ void GPUSharedTextureMemory::beginAccess(
       }
     }
   }
-  if (!rawFences.empty()) {
-    desc.fenceCount = rawFences.size();
-    desc.fences = rawFences.data();
-    desc.signaledValueCount = values.size();
-    desc.signaledValues = values.data();
-  } else {
-    desc.fenceCount = 0;
-    desc.fences = nullptr;
-    desc.signaledValueCount = 0;
-    desc.signaledValues = nullptr;
-  }
-
-#if defined(__ANDROID__)
-  // Dawn's Vulkan backend (AHardwareBuffer) validates that the begin-access
-  // descriptor chains a SharedTextureMemoryVkImageLayoutBeginState specifying
-  // the VkImageLayout to acquire the image into. UNDEFINED (= 0) on both ends
-  // is the canonical "no prior GPU producer" pattern: Dawn performs an
-  // external-queue acquire from VK_QUEUE_FAMILY_EXTERNAL which preserves the
-  // AHB contents, then transitions to whatever layout the texture's actual
-  // usage requires.
-  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkLayout{};
-  vkLayout.oldLayout = 0;
-  vkLayout.newLayout = 0;
-  desc.nextInChain = &vkLayout;
-#endif
 
-  auto status = _instance.BeginAccess(texture->get(), &desc);
-  if (status != wgpu::Status::Success) {
-    throw std::runtime_error("GPUSharedTextureMemory::beginAccess() failed");
-  }
+  // The access descriptor (and, on Vulkan, the layout the image is acquired
+  // in) is the one of every native frame import: see NativeFrameImport.cpp.
+  native_frame::beginAccess(_instance, texture->get(), initialized, rawFences,
+                            values, "GPUSharedTextureMemory::beginAccess");
   _accessed.push_back(texture->get());
 }
 
@@ -159,18 +134,11 @@ jsi::Value GPUSharedTextureMemory::endAccess(jsi::Runtime &runtime,
   auto texture = GPUTexture::fromValue(runtime, args[0]);
 
   wgpu::SharedTextureMemoryEndAccessState state{};
-
-#if defined(__ANDROID__)
-  // Dawn's Vulkan backend writes the released old/new VkImageLayouts back into
-  // a chained SharedTextureMemoryVkImageLayoutEndState; validation requires
-  // the chain even when the caller doesn't read the values.
-  wgpu::SharedTextureMemoryVkImageLayoutEndState vkLayout{};
-  state.nextInChain = &vkLayout;
-#endif
-
-  auto status = _instance.EndAccess(texture->get(), &state);
-  if (status != wgpu::Status::Success) {
-    throw jsi::JSError(runtime, "GPUSharedTextureMemory::endAccess() failed");
+  try {
+    native_frame::endAccess(_instance, texture->get(), &state,
+                            "GPUSharedTextureMemory::endAccess");
+  } catch (const std::exception &e) {
+    throw jsi::JSError(runtime, e.what());
   }
   auto ended = texture->get();
   _accessed.erase(std::remove_if(_accessed.begin(), _accessed.end(),

package/cpp/rnwgpu/api/GPUSharedTextureMemory.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "NativeObject.h"

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 #include <variant>
 
 #include "JSIConverter.h"

package/cpp/rnwgpu/api/GPUValidationError.h

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