react-native-webgpu 0.11.1 → 0.12.0

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -17,7 +17,7 @@
 
 #include "GPUFeatures.h"
 #include "JSIConverter.h"
-#include "RnFeatures.h"
+#include "NativeFrameFeatures.h"
 #include "WGPULogger.h"
 
 namespace rnwgpu {
@@ -25,29 +25,24 @@ namespace rnwgpu {
 async::AsyncTaskHandle GPUAdapter::requestDevice(
     jsi::Runtime &runtime,
     std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
-  // Enable the react-native-wgpu "native-texture" umbrella by default, mirroring
-  // the web where importExternalTexture is core and needs no feature request.
-  // We append the umbrella's backing Dawn features to requiredFeatures so the
-  // capability is on without the caller listing it. Two rules keep this safe:
-  //   - All-or-nothing: only inject when the adapter supports *every* backing
-  //     feature (same semantics as maybeSynthesizeRnNativeTextureFeature). On a
-  //     web/fallback adapter the backing set is empty or unsupported, so this is
-  //     a no-op and device creation is unaffected.
-  //   - Requesting a feature the adapter doesn't support makes RequestDevice
-  //     fail, hence the support check below.
-  // Callers can still pass "rnwebgpu/native-texture" explicitly; the dedupe
-  // keeps that idempotent.
+  // Native frame import (importSharedTextureMemory, importExternalTexture,
+  // copyExternalImageToTexture with a NativeVideoFrame) needs no feature
+  // request, like importExternalTexture on the web: the Dawn features behind
+  // it are added to requiredFeatures here, each one when the adapter supports
+  // it. Requesting a feature the adapter lacks would make RequestDevice fail,
+  // so a fallback adapter (emulators, the web) still gets a device, without
+  // the capability; the first import then reports what is missing.
   {
-    auto backing = rnNativeTextureBackingFeatures();
-    if (!backing.empty()) {
+    auto native = nativeFrameImportFeatures();
+    if (!native.empty()) {
       wgpu::SupportedFeatures supported;
       _instance.GetFeatures(&supported);
       std::unordered_set<wgpu::FeatureName> supportedSet(
           supported.features, supported.features + supported.featureCount);
-      bool allSupported = std::all_of(
-          backing.begin(), backing.end(),
-          [&](wgpu::FeatureName f) { return supportedSet.count(f) > 0; });
-      if (allSupported) {
+      for (auto f : native) {
+        if (supportedSet.count(f) == 0) {
+          continue;
+        }
         if (!descriptor.has_value()) {
           descriptor = std::make_shared<GPUDeviceDescriptor>();
         }
@@ -56,11 +51,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
           desc->requiredFeatures = std::vector<wgpu::FeatureName>{};
         }
         auto &features = desc->requiredFeatures.value();
-        for (auto f : backing) {
-          if (std::find(features.begin(), features.end(), f) ==
-              features.end()) {
-            features.push_back(f);
-          }
+        if (std::find(features.begin(), features.end(), f) == features.end()) {
+          features.push_back(f);
         }
       }
     }
@@ -101,8 +93,7 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
         if (std::find(features.begin(), features.end(),
                       wgpu::FeatureName::ImplicitDeviceSynchronization) ==
             features.end()) {
-          features.push_back(
-              wgpu::FeatureName::ImplicitDeviceSynchronization);
+          features.push_back(wgpu::FeatureName::ImplicitDeviceSynchronization);
         }
       }
     }
@@ -211,7 +202,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
             }
           }
         }
-// TODO: in the latest version of Dawn, this won't be needed (https://issues.chromium.org/issues/42241591)
+// TODO: in the latest version of Dawn, this won't be needed
+// (https://issues.chromium.org/issues/42241591)
 #if defined(TARGET_OS_SIMULATOR) && TARGET_OS_SIMULATOR
         // The iOS Simulator only advertises MTLFeatureSet_iOS_GPUFamily2, so
         // Dawn defaults disable_base_instance/disable_base_vertex on and then
@@ -311,17 +303,13 @@ std::unordered_set<std::string> GPUAdapter::getFeatures() {
   wgpu::SupportedFeatures supportedFeatures;
   _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  std::unordered_set<wgpu::FeatureName> enabled;
   for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
-    auto feature = supportedFeatures.features[i];
-    enabled.insert(feature);
     std::string name;
-    convertEnumToJSUnion(feature, &name);
+    convertEnumToJSUnion(supportedFeatures.features[i], &name);
     if (name != "") {
       result.insert(name);
     }
   }
-  maybeSynthesizeRnNativeTextureFeature(enabled, result);
   return result;
 }
 

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -15,7 +15,6 @@
 #include "GPUInternalError.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUValidationError.h"
-#include "RnFeatures.h"
 #include "SurfaceRegistry.h"
 
 namespace rnwgpu {
@@ -570,15 +569,11 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
   wgpu::SupportedFeatures supportedFeatures;
   _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  std::unordered_set<wgpu::FeatureName> enabled;
   for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
-    auto feature = supportedFeatures.features[i];
-    enabled.insert(feature);
     std::string name;
-    convertEnumToJSUnion(feature, &name);
+    convertEnumToJSUnion(supportedFeatures.features[i], &name);
     result.insert(name);
   }
-  maybeSynthesizeRnNativeTextureFeature(enabled, result);
   return result;
 }
 

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -8,8 +8,47 @@
 
 #include "GPUExternalTextureDescriptor.h"
 
+#if defined(__ANDROID__)
+#include <android/hardware_buffer.h>
+#endif
+
 namespace rnwgpu {
 
+#if defined(__ANDROID__)
+// Whether Dawn imports an AHardwareBuffer of this format as an
+// OpaqueYCbCrAndroid texture. Mirrors FormatFromAHardwareBufferFormat
+// (dawn/native/AHBFunctions.cpp): the color and depth formats with a WebGPU
+// equivalent import as that format; the YUV formats and the formats outside
+// the public enum, which drivers use for the camera and the video decoder,
+// import as OpaqueYCbCrAndroid.
+static bool isOpaqueYCbCrFormat(uint32_t format) {
+  switch (format) {
+  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+  case AHARDWAREBUFFER_FORMAT_BLOB:
+  case AHARDWAREBUFFER_FORMAT_D16_UNORM:
+  case AHARDWAREBUFFER_FORMAT_D24_UNORM:
+  case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
+  case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
+  case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
+  case AHARDWAREBUFFER_FORMAT_S8_UINT:
+  // Single-channel formats of the API 33 and 34 headers, by value so that
+  // older NDKs compile.
+  case 0x38: // AHARDWAREBUFFER_FORMAT_R8_UNORM
+  case 0x39: // AHARDWAREBUFFER_FORMAT_R16_UINT
+  case 0x3a: // AHARDWAREBUFFER_FORMAT_R16G16_UINT
+  case 0x3b: // AHARDWAREBUFFER_FORMAT_R10G10B10A10_UNORM
+    return false;
+  default:
+    return true;
+  }
+}
+#endif
+
 // Identity gamut (BT.709 -> sRGB, same primaries) as a 3x3 column-major matrix.
 static const float kIdentityGamutMatrix[9] = {
     1.0f, 0.0f, 0.0f, //
@@ -254,6 +293,28 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
       // sampled texel is already RGB.
       kYuvPassthroughMatrix);
 #elif defined(__ANDROID__)
+  // 0. A YUV frame imports as an OpaqueYCbCrAndroid texture, which Dawn only
+  //    accepts on a device with OpaqueYCbCrAndroidForExternalTexture.
+  //    requestDevice() enables the feature whenever the adapter supports it;
+  //    a device created by another library (importDevice) has to request it
+  //    itself. Fail with the cause here: Dawn's own report is a bare
+  //    "Unsupported texture format TextureFormat::OpaqueYCbCrAndroid" device
+  //    error, followed by the failure of every call made with the result.
+  if (!device.HasFeature(
+          wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture)) {
+    AHardwareBuffer_Desc ahbDesc{};
+    AHardwareBuffer_describe(static_cast<AHardwareBuffer *>(frame.handle),
+                             &ahbDesc);
+    if (isOpaqueYCbCrFormat(ahbDesc.format)) {
+      throw std::runtime_error(
+          "GPUExternalTexture::Create(): a YUV frame can only be imported on "
+          "a device with the 'opaque-ycbcr-android-for-external-texture' "
+          "feature. requestDevice() enables it whenever the adapter supports "
+          "it; a device imported from another library has to request it "
+          "itself.");
+    }
+  }
+
   // 1. Import the AHardwareBuffer as SharedTextureMemory. For YUV AHBs this
   //    yields a Dawn texture in the implementation-defined OpaqueYCbCrAndroid
   //    format; for RGBA AHBs, a regular single-plane texture.

package/cpp/rnwgpu/api/NativeFrameFeatures.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+// The Dawn features behind native frame import on the current platform:
+// importSharedTextureMemory, importExternalTexture and
+// copyExternalImageToTexture with a NativeVideoFrame. Like
+// importExternalTexture on the web, the capability needs no feature request:
+// requestDevice() enables each of these the adapter supports (see
+// GPUAdapter::requestDevice). A device created by another library and wrapped
+// with importDevice() has to request them itself for its frames to import.
+inline std::vector<wgpu::FeatureName> nativeFrameImportFeatures() {
+#if defined(__APPLE__)
+  return {
+      // IOSurface import, and the MTLSharedEvent fence that EndAccess exports
+      wgpu::FeatureName::SharedTextureMemoryIOSurface,
+      wgpu::FeatureName::SharedFenceMTLSharedEvent,
+      // The biplanar NV12 layout of camera frames
+      wgpu::FeatureName::DawnMultiPlanarFormats,
+  };
+#elif defined(__ANDROID__)
+  return {
+      // AHardwareBuffer import, and the sync-fd fence that EndAccess exports
+      wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
+      wgpu::FeatureName::SharedFenceSyncFD,
+      // The YUV buffers of the video decoder and of the camera: Dawn imports
+      // them as OpaqueYCbCrAndroid textures, a format it only accepts, and
+      // only samples as an external texture, with this feature
+      wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture,
+  };
+#else
+  return {};
+#endif
+}
+
+} // namespace rnwgpu

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

@@ -2,13 +2,13 @@
 
 #include <map>
 #include <memory>
+#include <stdexcept>
 #include <string>
 #include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
 #include "JSIConverter.h"
-#include "RnFeatures.h"
 #include "WGPULogger.h"
 
 #include "GPUDawnTogglesDescriptor.h"
@@ -57,13 +57,14 @@ template <> struct JSIConverter<std::vector<wgpu::FeatureName>> {
         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;
+      // The umbrella feature of earlier versions. Native frame import is on
+      // by default now and the name is gone; say so rather than reject it as
+      // an unknown feature.
+      if (str == "rnwebgpu/native-texture") {
+        throw std::runtime_error(
+            "requestDevice: the 'rnwebgpu/native-texture' feature has been "
+            "removed. Native frame import is enabled by default whenever the "
+            "adapter supports it; drop the name from requiredFeatures.");
       }
       vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
           runtime, elementValue, outOfBounds));
@@ -109,13 +110,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
       }
       if (value.hasProperty(runtime, "dawnToggles")) {
         auto prop = value.getProperty(runtime, "dawnToggles");
-        result->dawnToggles = JSIConverter<
-            std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(
-            runtime, prop, false);
+        result->dawnToggles = JSIConverter<std::optional<
+            std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(runtime, prop,
+                                                                 false);
       }
       if (value.hasProperty(runtime, "implicitDeviceSynchronization")) {
-        auto prop =
-            value.getProperty(runtime, "implicitDeviceSynchronization");
+        auto prop = value.getProperty(runtime, "implicitDeviceSynchronization");
         result->implicitDeviceSynchronization =
             JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/cpp/rnwgpu/api/RnFeatures.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-// Umbrella feature name owned by react-native-wgpu. Backed by a
-// platform-specific pair of Dawn features. The prefix is intentional: this
-// string is not part of the WebGPU spec, it is our API surface for the
-// "import a native surface as a sampleable texture" capability.
-inline constexpr const char *kRnNativeTextureFeature =
-    "rnwebgpu/native-texture";
-
-// Dawn features that back the umbrella on the current platform. Empty on
-// platforms where the capability is not available, in which case the umbrella
-// behaves as a no-op (it won't appear in adapter.features and asking for it
-// in requiredFeatures expands to nothing).
-inline std::vector<wgpu::FeatureName> rnNativeTextureBackingFeatures() {
-#if defined(__APPLE__)
-  return {wgpu::FeatureName::SharedTextureMemoryIOSurface,
-          wgpu::FeatureName::SharedFenceMTLSharedEvent};
-#elif defined(__ANDROID__)
-  return {wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
-          wgpu::FeatureName::SharedFenceSyncFD};
-#else
-  return {};
-#endif
-}
-
-// If every Dawn feature backing the umbrella is in `enabled`, add the
-// umbrella name to `out`. Used by adapter.features / device.features so JS
-// callers can see (and call .has on) the same name they pass in.
-inline void
-maybeSynthesizeRnNativeTextureFeature(
-    const std::unordered_set<wgpu::FeatureName> &enabled,
-    std::unordered_set<std::string> &out) {
-  auto backing = rnNativeTextureBackingFeatures();
-  if (backing.empty()) {
-    return;
-  }
-  for (auto f : backing) {
-    if (enabled.find(f) == enabled.end()) {
-      return;
-    }
-  }
-  out.insert(kRnNativeTextureFeature);
-}
-
-} // namespace rnwgpu