react-native-wgpu 0.5.10 → 0.5.13

package/cpp/rnwgpu/api/VideoPlayer.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <variant>
+
+#include "NativeObject.h"
+#include "PlatformContext.h"
+#include "VideoFrame.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// JSI wrapper around a platform-specific IVideoPlayer. Hands out fresh
+// VideoFrame handles each time the underlying decoder produces a new frame.
+class VideoPlayer : public NativeObject<VideoPlayer> {
+public:
+  static constexpr const char *CLASS_NAME = "VideoPlayer";
+
+  explicit VideoPlayer(std::unique_ptr<IVideoPlayer> impl)
+      : NativeObject(CLASS_NAME), _impl(std::move(impl)) {}
+
+  std::string getBrand() { return CLASS_NAME; }
+
+  // Returns the latest decoded frame, or null if no new frame is ready yet.
+  // Callers should poll this from their render loop and skip rendering (or
+  // reuse the last frame's texture) when null.
+  std::variant<std::nullptr_t, std::shared_ptr<VideoFrame>>
+  copyLatestFrame() {
+    if (!_impl) {
+      return nullptr;
+    }
+    auto handle = _impl->copyLatestFrame();
+    if (handle.handle == nullptr) {
+      return nullptr;
+    }
+    return std::make_shared<VideoFrame>(std::move(handle));
+  }
+
+  void play() {
+    if (_impl) {
+      _impl->play();
+    }
+  }
+
+  void pause() {
+    if (_impl) {
+      _impl->pause();
+    }
+  }
+
+  void release() { _impl.reset(); }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &VideoPlayer::getBrand);
+    installMethod(runtime, prototype, "copyLatestFrame",
+                  &VideoPlayer::copyLatestFrame);
+    installMethod(runtime, prototype, "play", &VideoPlayer::play);
+    installMethod(runtime, prototype, "pause", &VideoPlayer::pause);
+    installMethod(runtime, prototype, "release", &VideoPlayer::release);
+  }
+
+private:
+  std::unique_ptr<IVideoPlayer> _impl;
+};
+
+} // namespace rnwgpu

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

@@ -21,7 +21,7 @@ struct GPUBindGroupEntry {
   std::shared_ptr<GPUSampler> sampler = nullptr;
   std::shared_ptr<GPUTextureView> textureView = nullptr;
   std::shared_ptr<GPUBufferBinding> buffer = nullptr;
-  // external textures
+  std::shared_ptr<GPUExternalTexture> externalTexture = nullptr;
 };
 
 } // namespace rnwgpu
@@ -46,6 +46,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
           } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
             result->textureView =
                 obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUExternalTexture>(runtime)) {
+            result->externalTexture =
+                obj.getNativeState<rnwgpu::GPUExternalTexture>(runtime);
           } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
             // Support passing GPUBuffer directly as resource (auto-wrap in
             // GPUBufferBinding)

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

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
+// so the mapping to the native chained struct is 1:1. Chained onto the
+// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
+struct GPUDawnTogglesDescriptor {
+  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
+  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "enabledToggles")) {
+        auto prop = value.getProperty(runtime, "enabledToggles");
+        result->enabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "disabledToggles")) {
+        auto prop = value.getProperty(runtime, "disabledToggles");
+        result->disabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -8,8 +8,10 @@
 #include "webgpu/webgpu_cpp.h"
 
 #include "JSIConverter.h"
+#include "RnFeatures.h"
 #include "WGPULogger.h"
 
+#include "GPUDawnTogglesDescriptor.h"
 #include "GPUQueueDescriptor.h"
 
 namespace jsi = facebook::jsi;
@@ -24,6 +26,9 @@ struct GPUDeviceDescriptor {
   std::optional<std::shared_ptr<GPUQueueDescriptor>>
       defaultQueue;                 // GPUQueueDescriptor
   std::optional<std::string> label; // string
+  // Non-standard Dawn-only device toggles, chained onto the wgpu::Device
+  // descriptor in GPUAdapter::requestDevice.
+  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
 };
 
 } // namespace rnwgpu
@@ -43,10 +48,20 @@ template <> struct JSIConverter<std::vector<wgpu::FeatureName>> {
     vector.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       jsi::Value elementValue = array.getValueAtIndex(runtime, i);
-      if (elementValue.isString()) {
-        vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
-            runtime, elementValue, outOfBounds));
+      if (!elementValue.isString()) {
+        continue;
       }
+      auto str = elementValue.asString(runtime).utf8(runtime);
+      // Expand react-native-wgpu's umbrella feature into the platform's
+      // backing Dawn features before they reach RequestDevice.
+      if (str == kRnNativeTextureFeature) {
+        for (auto f : rnNativeTextureBackingFeatures()) {
+          vector.emplace_back(f);
+        }
+        continue;
+      }
+      vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
+          runtime, elementValue, outOfBounds));
     }
     return vector;
   }

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

@@ -3,35 +3,34 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <variant>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Convertors.h"
-
 #include "JSIConverter.h"
-#include "WGPULogger.h"
+#include "VideoFrame.h"
 
 namespace jsi = facebook::jsi;
 
 namespace rnwgpu {
 
+// Mirror of GPUExternalTextureDescriptor from the WebGPU spec, but with our
+// VideoFrame as the (only) supported source. We don't expose colorSpace yet;
+// the C++ side picks dst-sRGB and identity gamut, which is the right default
+// for "render this video frame to a regular sRGB framebuffer".
+//
+// `rotation` / `mirrored` are a non-spec extension: camera frames (e.g. from
+// VisionCamera) arrive in the sensor's native orientation, which differs
+// between iOS (CVPixelBuffer) and Android (AHardwareBuffer). Dawn's
+// ExternalTextureDescriptor can bake a rotation + horizontal mirror into the
+// sampling transform, so the shader sees an upright frame without any extra
+// passes. `rotation` is in degrees and must be one of 0 / 90 / 180 / 270.
 struct GPUExternalTextureDescriptor {
-  // std::variant<std::shared_ptr<HTMLVideoElement>,
-  // std::shared_ptr<VideoFrame>>
-  //     source; // | HTMLVideoElement | VideoFrame
-  // std::optional<wgpu::DefinedColorSpace> colorSpace; // PredefinedColorSpace
-  std::optional<std::string> label; // string
+  std::shared_ptr<VideoFrame> source;
+  std::optional<std::string> label;
+  std::optional<double> rotation;
+  std::optional<bool> mirrored;
 };
 
-static bool conv(wgpu::ExternalTextureDescriptor &out,
-                 const std::shared_ptr<GPUExternalTextureDescriptor> &in) {
-  // TODO: implement
-  // return conv(out.source, in->source) && conv(out.colorSpace, in->colorSpace)
-  // &&
-  // return conv(out.label, in->label);
-  return false;
-}
 } // namespace rnwgpu
 
 namespace rnwgpu {
@@ -40,23 +39,15 @@ template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUExternalTextureDescriptor>();
+    auto result = std::make_shared<rnwgpu::GPUExternalTextureDescriptor>();
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "source")) {
         auto prop = value.getProperty(runtime, "source");
-        // result->source = JSIConverter<
-        //     std::variant<std::shared_ptr<HTMLVideoElement>,
-        //                  std::shared_ptr<VideoFrame>>>::fromJSI(runtime,
-        //                  prop,
-        //                                                         false);
-      }
-      if (value.hasProperty(runtime, "colorSpace")) {
-        auto prop = value.getProperty(runtime, "colorSpace");
-        if (!prop.isUndefined()) {
-          // result->colorSpace =
-          //     JSIConverter<std::optional<wgpu::definedColorSpace>>::fromJSI(
-          //         runtime, prop, false);
+        if (!prop.isUndefined() && !prop.isNull()) {
+          result->source =
+              JSIConverter<std::shared_ptr<rnwgpu::VideoFrame>>::fromJSI(
+                  runtime, prop, false);
         }
       }
       if (value.hasProperty(runtime, "label")) {
@@ -66,13 +57,24 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
               runtime, prop, false);
         }
       }
+      if (value.hasProperty(runtime, "rotation")) {
+        auto prop = value.getProperty(runtime, "rotation");
+        if (prop.isNumber()) {
+          result->rotation = prop.asNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "mirrored")) {
+        auto prop = value.getProperty(runtime, "mirrored");
+        if (prop.isBool()) {
+          result->mirrored = prop.getBool();
+        }
+      }
     }
-
     return result;
   }
   static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> /*arg*/) {
     throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
   }
 };

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Descriptor for GPUDevice.importSharedTextureMemory.
+//
+// `handle` is the raw native handle as a uintptr_t (passed as BigInt from JS):
+//   - Apple platforms: IOSurfaceRef
+//   - Android: AHardwareBuffer*
+//
+// Lifetime: the caller is responsible for keeping the underlying object alive
+// for as long as this shared memory is in use. The VideoFrame helper handles
+// this automatically when the handle came from PlatformContext.loadVideoFrame.
+struct GPUSharedTextureMemoryDescriptor {
+  void *handle = nullptr;
+  std::optional<std::string> label;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result =
+        std::make_shared<rnwgpu::GPUSharedTextureMemoryDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "handle")) {
+        auto prop = value.getProperty(runtime, "handle");
+        result->handle =
+            JSIConverter<void *>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor> /*arg*/) {
+    throw std::runtime_error(
+        "Invalid GPUSharedTextureMemoryDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -463,8 +463,6 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::PixelLocalStorageNonCoherent;
   } else if (inUnion == "unorm16-texture-formats") {
     *outEnum = wgpu::FeatureName::Unorm16TextureFormats;
-  } else if (inUnion == "snorm16-texture-formats") {
-    *outEnum = wgpu::FeatureName::Snorm16TextureFormats;
   } else if (inUnion == "multi-planar-format-extended-usages") {
     *outEnum = wgpu::FeatureName::MultiPlanarFormatExtendedUsages;
   } else if (inUnion == "multi-planar-format-p010") {
@@ -485,12 +483,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::AdapterPropertiesD3D;
   } else if (inUnion == "adapter-properties-vk") {
     *outEnum = wgpu::FeatureName::AdapterPropertiesVk;
-  } else if (inUnion == "r8unorm-storage") {
-    *outEnum = wgpu::FeatureName::R8UnormStorage;
   } else if (inUnion == "format-capabilities") {
     *outEnum = wgpu::FeatureName::DawnFormatCapabilities;
-  } else if (inUnion == "norm16-texture-formats") {
-    *outEnum = wgpu::FeatureName::Norm16TextureFormats;
   } else if (inUnion == "multi-planar-format-nv16") {
     *outEnum = wgpu::FeatureName::MultiPlanarFormatNv16;
   } else if (inUnion == "multi-planar-format-nv24") {
@@ -519,6 +513,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::SharedTextureMemoryEGLImage;
   } else if (inUnion == "shared-fence-vk-semaphore-opaque-fd") {
     *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD;
+  } else if (inUnion == "shared-fence-sync-fd") {
+    *outEnum = wgpu::FeatureName::SharedFenceSyncFD;
   } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") {
     *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle;
   } else if (inUnion == "shared-fence-dxgi-shared-handle") {
@@ -531,6 +527,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::StaticSamplers;
   } else if (inUnion == "ycbcr-vulkan-samplers") {
     *outEnum = wgpu::FeatureName::YCbCrVulkanSamplers;
+  } else if (inUnion == "opaque-ycbcr-android-for-external-texture") {
+    *outEnum = wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture;
   } else if (inUnion == "shader-module-compilation-options") {
     *outEnum = wgpu::FeatureName::ShaderModuleCompilationOptions;
   } else if (inUnion == "dawn-load-resolve-texture") {
@@ -629,9 +627,6 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Unorm16TextureFormats:
     *outUnion = "unorm16-texture-formats";
     break;
-  case wgpu::FeatureName::Snorm16TextureFormats:
-    *outUnion = "snorm16-texture-formats";
-    break;
   case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
     *outUnion = "multi-planar-format-extended-usages";
     break;
@@ -662,12 +657,6 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::AdapterPropertiesVk:
     *outUnion = "adapter-properties-vk";
     break;
-  case wgpu::FeatureName::R8UnormStorage:
-    *outUnion = "r8unorm-storage";
-    break;
-  case wgpu::FeatureName::Norm16TextureFormats:
-    *outUnion = "norm16-texture-formats";
-    break;
   case wgpu::FeatureName::MultiPlanarFormatNv16:
     *outUnion = "multi-planar-format-nv16";
     break;
@@ -710,6 +699,9 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
     *outUnion = "shared-fence-vk-semaphore-opaque-fd";
     break;
+  case wgpu::FeatureName::SharedFenceSyncFD:
+    *outUnion = "shared-fence-sync-fd";
+    break;
   case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
     *outUnion = "shared-fence-vk-semaphore-zircon-handle";
     break;
@@ -728,6 +720,9 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::YCbCrVulkanSamplers:
     *outUnion = "ycbcr-vulkan-samplers";
     break;
+  case wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture:
+    *outUnion = "opaque-ycbcr-android-for-external-texture";
+    break;
   case wgpu::FeatureName::ShaderModuleCompilationOptions:
     *outUnion = "shader-module-compilation-options";
     break;