react-native-webgpu 0.11.1 → 0.11.2

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -25,18 +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:
+  // 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.
+  //     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.
+  // The optional features (rnNativeTextureOptionalFeatures) ride along one by
+  // one, each only when the adapter supports it: on Android the YUV frames of
+  // the decoder and of the camera cannot be imported without
+  // OpaqueYCbCrAndroidForExternalTexture, while RGBA buffers need nothing
+  // beyond the backing set.
   {
     auto backing = rnNativeTextureBackingFeatures();
     if (!backing.empty()) {
@@ -44,9 +50,10 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
       _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; });
+      bool allSupported =
+          std::all_of(backing.begin(), backing.end(), [&](wgpu::FeatureName f) {
+            return supportedSet.count(f) > 0;
+          });
       if (allSupported) {
         if (!descriptor.has_value()) {
           descriptor = std::make_shared<GPUDeviceDescriptor>();
@@ -62,6 +69,13 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
             features.push_back(f);
           }
         }
+        for (auto f : rnNativeTextureOptionalFeatures()) {
+          if (supportedSet.count(f) > 0 &&
+              std::find(features.begin(), features.end(), f) ==
+                  features.end()) {
+            features.push_back(f);
+          }
+        }
       }
     }
   }
@@ -101,8 +115,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 +224,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

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/RnFeatures.h

@@ -31,11 +31,24 @@ inline std::vector<wgpu::FeatureName> rnNativeTextureBackingFeatures() {
 #endif
 }
 
+// Dawn features that complete the umbrella on the current platform. They are
+// requested by default when the adapter supports them, but they are not part
+// of the all-or-nothing backing set: on Android, Dawn imports the YUV buffers
+// of the video decoder and of the camera as OpaqueYCbCrAndroid textures, a
+// format it only accepts, and only samples as an external texture, with
+// OpaqueYCbCrAndroidForExternalTexture; RGBA buffers import without it.
+inline std::vector<wgpu::FeatureName> rnNativeTextureOptionalFeatures() {
+#if defined(__ANDROID__)
+  return {wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture};
+#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(
+inline void maybeSynthesizeRnNativeTextureFeature(
     const std::unordered_set<wgpu::FeatureName> &enabled,
     std::unordered_set<std::string> &out) {
   auto backing = rnNativeTextureBackingFeatures();

package/package.json

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