react-native-webgpu 0.5.11 → 0.5.13

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -1,5 +1,6 @@
 #include "GPUAdapter.h"
 
+#include <algorithm>
 #include <cstdio>
 #include <memory>
 #include <string>
@@ -11,12 +12,54 @@
 
 #include "GPUFeatures.h"
 #include "JSIConverter.h"
+#include "RnFeatures.h"
 #include "WGPULogger.h"
 
 namespace rnwgpu {
 
 async::AsyncTaskHandle GPUAdapter::requestDevice(
     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.
+  {
+    auto backing = rnNativeTextureBackingFeatures();
+    if (!backing.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) {
+        if (!descriptor.has_value()) {
+          descriptor = std::make_shared<GPUDeviceDescriptor>();
+        }
+        auto &desc = descriptor.value();
+        if (!desc->requiredFeatures.has_value()) {
+          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);
+          }
+        }
+      }
+    }
+  }
+
   wgpu::DeviceDescriptor aDescriptor;
   Convertor conv;
   if (!conv(aDescriptor, descriptor)) {
@@ -92,13 +135,39 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
        deviceLostBinding,
        creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
                         const async::AsyncTaskHandle::RejectFunction &reject) {
-        (void)descriptor;
+        // Build a local mutable copy so we can chain Dawn's device toggles.
+        // The toggle name strings are owned by `descriptor` (captured above),
+        // and the const char* / DawnTogglesDescriptor locals live for the
+        // whole synchronous RequestDevice call below, which is when Dawn reads
+        // the chained struct.
+        wgpu::DeviceDescriptor deviceDesc = aDescriptor;
+        wgpu::DawnTogglesDescriptor toggles{};
+        std::vector<const char *> enabledToggles;
+        std::vector<const char *> disabledToggles;
+        if (descriptor.has_value() && descriptor.value()->dawnToggles) {
+          const auto &dawnToggles = descriptor.value()->dawnToggles.value();
+          if (dawnToggles->enabledToggles) {
+            for (const auto &t : dawnToggles->enabledToggles.value()) {
+              enabledToggles.push_back(t.c_str());
+            }
+            toggles.enabledToggleCount = enabledToggles.size();
+            toggles.enabledToggles = enabledToggles.data();
+          }
+          if (dawnToggles->disabledToggles) {
+            for (const auto &t : dawnToggles->disabledToggles.value()) {
+              disabledToggles.push_back(t.c_str());
+            }
+            toggles.disabledToggleCount = disabledToggles.size();
+            toggles.disabledToggles = disabledToggles.data();
+          }
+          deviceDesc.nextInChain = &toggles;
+        }
         _instance.RequestDevice(
-            &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
+            &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
             [asyncRunner = _async, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device,
-                                wgpu::StringView message) mutable {
+                                wgpu::StringView message) {
               if (message.length) {
                 fprintf(stderr, "%s", message.data);
               }
@@ -111,36 +180,40 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
                 return;
               }
 
-              device.SetLoggingCallback([creationRuntime](
-                                            wgpu::LoggingType type,
-                                            wgpu::StringView msg) {
-                if (creationRuntime == nullptr) {
-                  return;
-                }
-                const char *logLevel = "";
-                switch (type) {
-                case wgpu::LoggingType::Warning:
-                  logLevel = "Warning";
-                  Logger::warnToJavascriptConsole(
-                      *creationRuntime, std::string(msg.data, msg.length));
-                  break;
-                case wgpu::LoggingType::Error:
-                  logLevel = "Error";
-                  Logger::errorToJavascriptConsole(
-                      *creationRuntime, std::string(msg.data, msg.length));
-                  break;
-                case wgpu::LoggingType::Verbose:
-                  logLevel = "Verbose";
-                  break;
-                case wgpu::LoggingType::Info:
-                  logLevel = "Info";
-                  break;
-                default:
-                  logLevel = "Unknown";
-                  Logger::logToConsole("%s: %.*s", logLevel,
-                                       static_cast<int>(msg.length), msg.data);
-                }
-              });
+              device.SetLoggingCallback(
+                  [](wgpu::LoggingType type, wgpu::StringView msg,
+                     jsi::Runtime *creationRuntime) {
+                    if (creationRuntime == nullptr) {
+                      return;
+                    }
+                    const char *logLevel = "";
+                    switch (type) {
+                    case wgpu::LoggingType::Warning:
+                      logLevel = "Warning";
+                      Logger::warnToJavascriptConsole(
+                          *creationRuntime,
+                          std::string(msg.data, msg.length));
+                      break;
+                    case wgpu::LoggingType::Error:
+                      logLevel = "Error";
+                      Logger::errorToJavascriptConsole(
+                          *creationRuntime,
+                          std::string(msg.data, msg.length));
+                      break;
+                    case wgpu::LoggingType::Verbose:
+                      logLevel = "Verbose";
+                      break;
+                    case wgpu::LoggingType::Info:
+                      logLevel = "Info";
+                      break;
+                    default:
+                      logLevel = "Unknown";
+                      Logger::logToConsole("%s: %.*s", logLevel,
+                                           static_cast<int>(msg.length),
+                                           msg.data);
+                    }
+                  },
+                  creationRuntime);
 
               auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
                                                             asyncRunner, label);
@@ -163,14 +236,17 @@ 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);
     if (name != "") {
       result.insert(name);
     }
   }
+  maybeSynthesizeRnNativeTextureFeature(enabled, result);
   return result;
 }
 

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -13,6 +13,7 @@
 #include "GPUInternalError.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUValidationError.h"
+#include "RnFeatures.h"
 
 namespace rnwgpu {
 
@@ -234,8 +235,55 @@ std::shared_ptr<GPUPipelineLayout> GPUDevice::createPipelineLayout(
 
 std::shared_ptr<GPUExternalTexture> GPUDevice::importExternalTexture(
     std::shared_ptr<GPUExternalTextureDescriptor> descriptor) {
+  // The import / begin-access / descriptor-build logic, plus the matching
+  // EndAccess, all live on GPUExternalTexture so the begin/end lifecycle stays
+  // in one translation unit (see GPUExternalTexture.cpp).
+  return GPUExternalTexture::Create(_instance, std::move(descriptor));
+}
+
+std::shared_ptr<GPUSharedTextureMemory> GPUDevice::importSharedTextureMemory(
+    std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor) {
+  if (!descriptor || descriptor->handle == nullptr) {
+    throw std::runtime_error("GPUDevice::importSharedTextureMemory(): handle "
+                             "must be a non-null native pointer");
+  }
+
+  wgpu::SharedTextureMemoryDescriptor desc{};
+  std::string label = descriptor->label.value_or("");
+  if (!label.empty()) {
+    desc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+
+#if defined(__APPLE__)
+  wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc{};
+  platformDesc.ioSurface = descriptor->handle;
+  // Default off: enabling it propagates StorageBinding into properties.usage,
+  // which then forces memory.createTexture() (no-descriptor form) to validate
+  // the format against storage capabilities. bgra8unorm (the standard
+  // CVPixelBuffer format) only supports storage when the device opts into the
+  // bgra8unorm-storage feature, so unconditionally setting this here breaks
+  // the common sample-only case.
+  platformDesc.allowStorageBinding = false;
+  desc.nextInChain = &platformDesc;
+#elif defined(__ANDROID__)
+  wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc{};
+  platformDesc.handle = descriptor->handle;
+  desc.nextInChain = &platformDesc;
+#else
   throw std::runtime_error(
-      "GPUDevice::importExternalTexture(): Not implemented");
+      "GPUDevice::importSharedTextureMemory(): unsupported platform");
+#endif
+
+  auto memory = _instance.ImportSharedTextureMemory(&desc);
+  if (memory == nullptr) {
+    throw std::runtime_error("GPUDevice::importSharedTextureMemory(): "
+                             "ImportSharedTextureMemory returned null - is the "
+                             "'shared-texture-memory-iosurface' (Apple) or "
+                             "'shared-texture-memory-ahardware-buffer' "
+                             "(Android) feature enabled on the device?");
+  }
+  return std::make_shared<GPUSharedTextureMemory>(std::move(memory),
+                                                  std::move(label));
 }
 
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
@@ -262,7 +310,7 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
         [pipelineHolder, resolve,
          reject](wgpu::CreatePipelineAsyncStatus status,
-                 wgpu::ComputePipeline pipeline, const char *msg) mutable {
+                 wgpu::ComputePipeline pipeline, wgpu::StringView msg) {
           if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
             pipelineHolder->_instance = pipeline;
             resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
@@ -271,7 +319,8 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
             });
           } else {
             std::string error =
-                msg ? std::string(msg) : "Failed to create compute pipeline";
+                msg.length ? std::string(msg.data, msg.length)
+                           : "Failed to create compute pipeline";
             reject(std::move(error));
           }
         });
@@ -303,7 +352,7 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
         [pipelineHolder, resolve,
          reject](wgpu::CreatePipelineAsyncStatus status,
-                 wgpu::RenderPipeline pipeline, const char *msg) mutable {
+                 wgpu::RenderPipeline pipeline, wgpu::StringView msg) {
           if (status == wgpu::CreatePipelineAsyncStatus::Success && pipeline) {
             pipelineHolder->_instance = pipeline;
             resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
@@ -312,7 +361,8 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
             });
           } else {
             std::string error =
-                msg ? std::string(msg) : "Failed to create render pipeline";
+                msg.length ? std::string(msg.data, msg.length)
+                           : "Failed to create render pipeline";
             reject(std::move(error));
           }
         });
@@ -386,12 +436,15 @@ 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);
     result.insert(name);
   }
+  maybeSynthesizeRnNativeTextureFeature(enabled, result);
   return result;
 }
 

package/cpp/rnwgpu/api/GPUDevice.h

@@ -45,6 +45,8 @@
 #include "GPURenderPipelineDescriptor.h"
 #include "GPUSampler.h"
 #include "GPUSamplerDescriptor.h"
+#include "GPUSharedTextureMemory.h"
+#include "GPUSharedTextureMemoryDescriptor.h"
 #include "GPUShaderModule.h"
 #include "GPUShaderModuleDescriptor.h"
 #include "GPUSupportedLimits.h"
@@ -116,6 +118,8 @@ public:
       std::optional<std::shared_ptr<GPUSamplerDescriptor>> descriptor);
   std::shared_ptr<GPUExternalTexture> importExternalTexture(
       std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
+  std::shared_ptr<GPUSharedTextureMemory> importSharedTextureMemory(
+      std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor);
   std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -169,6 +173,8 @@ public:
                   &GPUDevice::createSampler);
     installMethod(runtime, prototype, "importExternalTexture",
                   &GPUDevice::importExternalTexture);
+    installMethod(runtime, prototype, "importSharedTextureMemory",
+                  &GPUDevice::importSharedTextureMemory);
     installMethod(runtime, prototype, "createBindGroupLayout",
                   &GPUDevice::createBindGroupLayout);
     installMethod(runtime, prototype, "createPipelineLayout",

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -0,0 +1,335 @@
+#include "GPUExternalTexture.h"
+
+#include <cmath>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "GPUExternalTextureDescriptor.h"
+
+namespace rnwgpu {
+
+// Identity gamut (BT.709 -> sRGB, same primaries) as a 3x3 column-major matrix.
+static const float kIdentityGamutMatrix[9] = {
+    1.0f, 0.0f, 0.0f, //
+    0.0f, 1.0f, 0.0f, //
+    0.0f, 0.0f, 1.0f, //
+};
+
+// Piecewise gamma transfer-function parameters Dawn expects:
+// for |x| < D: y = sign(x) * (C * |x| + F)
+// else        : y = sign(x) * (pow(A * |x| + B, G) + E)
+// sRGB decode (encoded -> linear).
+static const float kSrgbDecodeParams[7] = {
+    2.4f,            // G
+    1.0f / 1.055f,   // A
+    0.055f / 1.055f, // B
+    1.0f / 12.92f,   // C
+    0.04045f,        // D
+    0.0f,            // E
+    0.0f,            // F
+};
+// sRGB encode (linear -> encoded).
+static const float kSrgbEncodeParams[7] = {
+    1.0f / 2.4f, // G
+    1.055f,      // A
+    0.0f,        // B
+    12.92f,      // C
+    0.0031308f,  // D
+    -0.055f,     // E
+    0.0f,        // F
+};
+
+// Identity transfer (y = x). Used when the sampled surface is already in the
+// render target's color space: a single-plane BGRA IOSurface, or the Android
+// opaque-YCbCr path where the Vulkan sampler already produced RGB. Dawn
+// dereferences the transfer-function arrays unconditionally
+// (ComputeExternalTextureParams), so these must be non-null even when no
+// conversion is wanted.
+static const float kIdentityTransferParams[7] = {
+    1.0f, // G
+    1.0f, // A
+    0.0f, // B
+    0.0f, // C
+    0.0f, // D
+    0.0f, // E
+    0.0f, // F
+};
+
+// BT.709 limited-range YUV -> R'G'B' as a 3x4 row-major matrix mapping
+// [Y, Cb, Cr, 1] to gamma-encoded R'G'B' (NOT linear; the sRGB decode in
+// srcTransferFunctionParameters linearizes afterwards). Same values the Apple
+// NV12 path computes from the CVPixelBuffer; used for Android buffers that
+// arrive as a *defined* biplanar format (where we split the planes and convert
+// ourselves) rather than an opaque external-format AHB. Camera streams are
+// limited-range BT.709 in the overwhelming majority of cases; full-range /
+// BT.601 would need different coefficients (refine from the buffer's suggested
+// range if it matters).
+[[maybe_unused]] static const float kBT709LimitedToRgb[12] = {
+    1.164383f, 0.000000f, 1.792741f, -0.972945f,  //
+    1.164383f, -0.213249f, -0.532909f, 0.301517f, //
+    1.164383f, 2.112402f, 0.000000f, -1.133402f,  //
+};
+
+// True for the multi-planar Y + CbCr formats whose planes we can view as
+// Plane0Only (luma) / Plane1Only (chroma) and convert with an explicit matrix.
+// Excludes OpaqueYCbCrAndroid (external format, no plane views) and triplanar
+// formats (would need a third plane). Only referenced on Android.
+[[maybe_unused]] static bool isBiplanarYuvFormat(wgpu::TextureFormat format) {
+  switch (format) {
+  case wgpu::TextureFormat::R8BG8Biplanar420Unorm:
+  case wgpu::TextureFormat::R8BG8Biplanar422Unorm:
+  case wgpu::TextureFormat::R8BG8Biplanar444Unorm:
+  case wgpu::TextureFormat::R10X6BG10X6Biplanar420Unorm:
+  case wgpu::TextureFormat::R10X6BG10X6Biplanar422Unorm:
+  case wgpu::TextureFormat::R10X6BG10X6Biplanar444Unorm:
+    return true;
+  default:
+    return false;
+  }
+}
+
+// Map a rotation in degrees (0 / 90 / 180 / 270) to Dawn's enum. Anything that
+// isn't a clean multiple of 90 snaps to the nearest quadrant; Dawn only
+// supports those four steps for external textures.
+static wgpu::ExternalTextureRotation
+toExternalTextureRotation(double degrees) {
+  int quadrant = static_cast<int>(std::lround(degrees / 90.0)) & 3;
+  switch (quadrant) {
+  case 1:
+    return wgpu::ExternalTextureRotation::Rotate90Degrees;
+  case 2:
+    return wgpu::ExternalTextureRotation::Rotate180Degrees;
+  case 3:
+    return wgpu::ExternalTextureRotation::Rotate270Degrees;
+  default:
+    return wgpu::ExternalTextureRotation::Rotate0Degrees;
+  }
+}
+
+std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
+    wgpu::Device device,
+    std::shared_ptr<GPUExternalTextureDescriptor> descriptor) {
+  if (!descriptor || !descriptor->source) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): descriptor.source (VideoFrame) "
+        "is required");
+  }
+  const auto &source = descriptor->source;
+  const auto &frame = source->handle();
+  if (frame.handle == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): VideoFrame has been released");
+  }
+
+#if defined(__APPLE__)
+  // 1. Import the IOSurface as SharedTextureMemory. For NV12 surfaces this
+  //    yields a biplanar texture; for BGRA, a single-plane one.
+  wgpu::SharedTextureMemoryDescriptor memDesc{};
+  std::string label = descriptor->label.value_or("external-texture");
+  if (!label.empty()) {
+    memDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+  wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc{};
+  platformDesc.ioSurface = frame.handle;
+  // ExternalTexture views are sampled-only; storage binding isn't needed and
+  // for biplanar formats it would fail validation.
+  platformDesc.allowStorageBinding = false;
+  memDesc.nextInChain = &platformDesc;
+  auto memory = device.ImportSharedTextureMemory(&memDesc);
+  if (memory == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): ImportSharedTextureMemory "
+        "returned null. Is 'shared-texture-memory-iosurface' enabled?");
+  }
+
+  // 2. Create the texture from the surface. We pass the right format
+  //    explicitly so Dawn picks the multi-planar variant on NV12.
+  bool isYuv = frame.pixelFormat == VideoPixelFormat::NV12;
+  auto texture = memory.CreateTexture();
+  if (texture == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): CreateTexture returned null");
+  }
+
+  // 3. Begin access on the underlying memory. The matching EndAccess runs when
+  //    the GPUExternalTexture is destroyed (explicitly via destroy() or at GC).
+  wgpu::SharedTextureMemoryBeginAccessDescriptor begin{};
+  begin.initialized = true;
+  begin.concurrentRead = false;
+  if (!memory.BeginAccess(texture, &begin)) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): BeginAccess failed");
+  }
+
+  // 4. Build plane views. For NV12 we need plane0 = R8 luma and plane1 = RG8
+  //    chroma; for BGRA we only set plane0.
+  wgpu::TextureView plane0;
+  wgpu::TextureView plane1;
+  {
+    wgpu::TextureViewDescriptor v{};
+    v.aspect =
+        isYuv ? wgpu::TextureAspect::Plane0Only : wgpu::TextureAspect::All;
+    plane0 = texture.CreateView(&v);
+  }
+  if (isYuv) {
+    wgpu::TextureViewDescriptor v{};
+    v.aspect = wgpu::TextureAspect::Plane1Only;
+    plane1 = texture.CreateView(&v);
+  }
+
+  // 5. Build the ExternalTextureDescriptor. We hand Dawn explicit YUV→RGB and
+  //    sRGB transfer-function parameters so the sampler does the full color
+  //    conversion in hardware.
+  wgpu::ExternalTextureDescriptor extDesc{};
+  if (!label.empty()) {
+    extDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+  extDesc.plane0 = plane0;
+  extDesc.gamutConversionMatrix = kIdentityGamutMatrix;
+  if (isYuv) {
+    extDesc.plane1 = plane1;
+    extDesc.yuvToRgbConversionMatrix = frame.yuvToRgbMatrix;
+    extDesc.srcTransferFunctionParameters = kSrgbDecodeParams;
+    extDesc.dstTransferFunctionParameters = kSrgbEncodeParams;
+  } else {
+    // BGRA is already RGB in the target color space; pass it through. Dawn
+    // dereferences these arrays unconditionally, so they must be non-null.
+    extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
+    extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
+  }
+  extDesc.cropOrigin = {0, 0};
+  extDesc.cropSize = {frame.width, frame.height};
+  extDesc.apparentSize = {frame.width, frame.height};
+  extDesc.mirrored = descriptor->mirrored.value_or(false);
+  extDesc.rotation =
+      toExternalTextureRotation(descriptor->rotation.value_or(0));
+
+  auto external = device.CreateExternalTexture(&extDesc);
+  if (external == nullptr) {
+    wgpu::SharedTextureMemoryEndAccessState state{};
+    (void)memory.EndAccess(texture, &state);
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): CreateExternalTexture returned "
+        "null");
+  }
+
+  return std::make_shared<GPUExternalTexture>(
+      std::move(external), std::move(memory), std::move(texture),
+      std::move(descriptor->source), std::move(label));
+#elif defined(__ANDROID__)
+  // 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.
+  wgpu::SharedTextureMemoryDescriptor memDesc{};
+  std::string label = descriptor->label.value_or("external-texture");
+  if (!label.empty()) {
+    memDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+  wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc{};
+  platformDesc.handle = frame.handle;
+  memDesc.nextInChain = &platformDesc;
+  auto memory = device.ImportSharedTextureMemory(&memDesc);
+  if (memory == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): ImportSharedTextureMemory "
+        "returned null. Is 'shared-texture-memory-ahardware-buffer' enabled?");
+  }
+
+  // 2. Create the texture. No descriptor: Dawn picks the right format
+  //    (OpaqueYCbCrAndroid for YUV, R8 / RGBA8 / ... for color AHBs).
+  auto texture = memory.CreateTexture();
+  if (texture == nullptr) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): CreateTexture returned null");
+  }
+
+  // 3. Begin access. Vulkan requires us to advertise the incoming VkImage
+  //    layout (UNDEFINED is fine for the first acquisition of an AHB whose
+  //    contents we expect Dawn to read as-is).
+  wgpu::SharedTextureMemoryBeginAccessDescriptor begin{};
+  begin.initialized = true;
+  begin.concurrentRead = false;
+  wgpu::SharedTextureMemoryVkImageLayoutBeginState beginLayout{};
+  begin.nextInChain = &beginLayout;
+  if (!memory.BeginAccess(texture, &begin)) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): BeginAccess failed");
+  }
+
+  // 4. Build the ExternalTextureDescriptor. There are two cases depending on
+  //    how Dawn imported the AHB (see SharedTextureMemoryVk.cpp):
+  //
+  //    a. *External* format (camera buffers whose layout has no Vulkan
+  //       equivalent) -> OpaqueYCbCrAndroid, a single opaque plane. Sampling
+  //       routes through a Vulkan SamplerYcbcrConversion whose model Dawn
+  //       copies verbatim from the AHB's suggestedYcbcrModel. We pass a single
+  //       plane + identity transfer and let that conversion (if any) run. NOTE:
+  //       when the driver reports RGB_IDENTITY the sample comes back as raw
+  //       Y/Cb/Cr; there is no public hook to override the model on this path.
+  //
+  //    b. *Defined* biplanar format (e.g. R8BG8Biplanar420Unorm, exposed by the
+  //       dawn-multi-planar-formats feature) -> we split Plane0Only (luma) /
+  //       Plane1Only (chroma) and hand Dawn an explicit BT.709 matrix + sRGB
+  //       transfer, exactly like the iOS NV12 path. This makes numPlanes == 2
+  //       so the matrix is actually applied (the single-plane branch in Dawn's
+  //       Tint transform ignores yuvToRgbConversionMatrix).
+  //
+  //    Either way we must pass non-null gamut/transfer arrays:
+  //    ComputeExternalTextureParams dereferences them unconditionally
+  //    (kIdentityTransferParams is defined at file scope).
+  const bool isBiplanar = frame.pixelFormat == VideoPixelFormat::NV12 &&
+                          isBiplanarYuvFormat(texture.GetFormat());
+
+  wgpu::TextureView plane0;
+  wgpu::TextureView plane1;
+  wgpu::ExternalTextureDescriptor extDesc{};
+  if (!label.empty()) {
+    extDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+  extDesc.cropOrigin = {0, 0};
+  extDesc.cropSize = {frame.width, frame.height};
+  extDesc.apparentSize = {frame.width, frame.height};
+  extDesc.gamutConversionMatrix = kIdentityGamutMatrix;
+  if (isBiplanar) {
+    wgpu::TextureViewDescriptor v0{};
+    v0.aspect = wgpu::TextureAspect::Plane0Only;
+    plane0 = texture.CreateView(&v0);
+    wgpu::TextureViewDescriptor v1{};
+    v1.aspect = wgpu::TextureAspect::Plane1Only;
+    plane1 = texture.CreateView(&v1);
+    extDesc.plane0 = plane0;
+    extDesc.plane1 = plane1;
+    extDesc.yuvToRgbConversionMatrix = kBT709LimitedToRgb;
+    extDesc.srcTransferFunctionParameters = kSrgbDecodeParams;
+    extDesc.dstTransferFunctionParameters = kSrgbEncodeParams;
+  } else {
+    plane0 = texture.CreateView();
+    extDesc.plane0 = plane0;
+    extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
+    extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
+  }
+  extDesc.mirrored = descriptor->mirrored.value_or(false);
+  extDesc.rotation =
+      toExternalTextureRotation(descriptor->rotation.value_or(0));
+
+  auto external = device.CreateExternalTexture(&extDesc);
+  if (external == nullptr) {
+    wgpu::SharedTextureMemoryEndAccessState state{};
+    (void)memory.EndAccess(texture, &state);
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): CreateExternalTexture returned "
+        "null");
+  }
+
+  return std::make_shared<GPUExternalTexture>(
+      std::move(external), std::move(memory), std::move(texture),
+      std::move(descriptor->source), std::move(label));
+#else
+  throw std::runtime_error(
+      "GPUExternalTexture::Create(): not yet implemented on this "
+      "platform");
+#endif
+}
+
+} // namespace rnwgpu