react-native-webgpu 0.5.18 → 0.6.1

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -2,12 +2,17 @@
 
 #include <algorithm>
 #include <cstdio>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
+#ifdef __APPLE__
+#include <TargetConditionals.h>
+#endif
+
 #include "Convertors.h"
 
 #include "GPUFeatures.h"
@@ -18,6 +23,7 @@
 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.
@@ -130,9 +136,15 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
 
   auto creationRuntime = getCreationRuntime();
-  return _async->postTask(
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync). The GPUDevice is also
+  // bound to this context, honoring the contract that a device belongs to the
+  // runtime that requested it.
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask(
       [this, aDescriptor, descriptor, label = std::move(label),
-       deviceLostBinding,
+       deviceLostBinding, context,
        creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
                         const async::AsyncTaskHandle::RejectFunction &reject) {
         // Build a local mutable copy so we can chain Dawn's device toggles.
@@ -150,21 +162,45 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
             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();
           }
+        }
+// 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
+        // rejects every draw with a non-zero firstInstance or baseVertex,
+        // both core WebGPU. The simulator forwards Metal calls to the host
+        // GPU, which does support base vertex/instance drawing, so force the
+        // toggles off. Device builds are unaffected: WebGPU-capable iPhones
+        // and iPads are all GPUFamily3+. These are device-stage toggles, so
+        // they must be chained here rather than on the instance descriptor
+        // (instance-stage toggle parsing silently drops them).
+        static const char *const kSimulatorDisabledToggles[] = {
+            "disable_base_instance", "disable_base_vertex"};
+        for (const char *name : kSimulatorDisabledToggles) {
+          const bool explicitlyEnabled = std::any_of(
+              enabledToggles.begin(), enabledToggles.end(),
+              [name](const char *t) { return std::strcmp(t, name) == 0; });
+          if (!explicitlyEnabled) {
+            disabledToggles.push_back(name);
+          }
+        }
+#endif
+        if (!enabledToggles.empty() || !disabledToggles.empty()) {
+          toggles.enabledToggleCount = enabledToggles.size();
+          toggles.enabledToggles = enabledToggles.data();
+          toggles.disabledToggleCount = disabledToggles.size();
+          toggles.disabledToggles = disabledToggles.data();
           deviceDesc.nextInChain = &toggles;
         }
         _instance.RequestDevice(
             &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
-            [context = _async, resolve, reject, label, creationRuntime,
+            [context, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device, wgpu::StringView message) {
               if (message.length) {

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -33,8 +33,9 @@ public:
 public:
   std::string getBrand() { return CLASS_NAME; }
 
-  async::AsyncTaskHandle
-  requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
+  async::AsyncTaskHandle requestDevice(
+      jsi::Runtime &runtime,
+      std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
 
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
@@ -42,8 +43,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUAdapter::getBrand);
-    installMethod(runtime, prototype, "requestDevice",
-                  &GPUAdapter::requestDevice);
+    installMethodWithRuntime(runtime, prototype, "requestDevice",
+                             &GPUAdapter::requestDevice);
     installGetter(runtime, prototype, "features", &GPUAdapter::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUAdapter::getLimits);
     installGetter(runtime, prototype, "info", &GPUAdapter::getInfo);

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -37,7 +37,8 @@ GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
 
 void GPUBuffer::destroy() { _instance.Destroy(); }
 
-async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
+async::AsyncTaskHandle GPUBuffer::mapAsync(jsi::Runtime &runtime,
+                                           uint64_t modeIn,
                                            std::optional<uint64_t> offset,
                                            std::optional<uint64_t> size) {
   Convertor conv;
@@ -51,7 +52,16 @@ async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
   auto bufferHandle = _instance;
   uint64_t resolvedOffset = offset.value_or(0);
 
-  return _async->postTask(
+  // Post to the CALLING runtime's context, not the one captured at buffer
+  // creation (_async): the buffer may have been created on another runtime and
+  // boxed across (e.g. device created on the main JS runtime, mapAsync called
+  // from a worklet). The returned Promise lives on the calling runtime, so it
+  // must be settled from that runtime's own thread — and postTask itself
+  // schedules the pump through its context's runtime (setTimeout), which is
+  // only safe for the runtime we are currently executing on.
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask(
       [bufferHandle, mode, resolvedOffset,
        rangeSize](const async::AsyncTaskHandle::ResolveFunction &resolve,
                   const async::AsyncTaskHandle::RejectFunction &reject) {

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -33,7 +33,7 @@ public:
 public:
   std::string getBrand() { return CLASS_NAME; }
 
-  async::AsyncTaskHandle mapAsync(uint64_t modeIn,
+  async::AsyncTaskHandle mapAsync(jsi::Runtime &runtime, uint64_t modeIn,
                                   std::optional<uint64_t> offset,
                                   std::optional<uint64_t> size);
   std::shared_ptr<ArrayBuffer> getMappedRange(std::optional<size_t> offset,
@@ -53,7 +53,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUBuffer::getBrand);
-    installMethod(runtime, prototype, "mapAsync", &GPUBuffer::mapAsync);
+    installMethodWithRuntime(runtime, prototype, "mapAsync",
+                             &GPUBuffer::mapAsync);
     installMethod(runtime, prototype, "getMappedRange",
                   &GPUBuffer::getMappedRange);
     installMethod(runtime, prototype, "unmap", &GPUBuffer::unmap);

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -1,7 +1,10 @@
 #include "GPUCanvasContext.h"
 #include "Convertors.h"
 #include "RNWebGPUManager.h"
+#include <algorithm>
 #include <memory>
+#include <utility>
+#include <vector>
 
 namespace rnwgpu {
 
@@ -10,37 +13,50 @@ void GPUCanvasContext::configure(
   Convertor conv;
   wgpu::SurfaceConfiguration surfaceConfiguration;
   surfaceConfiguration.device = configuration->device->get();
-  if (configuration->viewFormats.has_value()) {
-    if (!conv(surfaceConfiguration.viewFormats,
-              surfaceConfiguration.viewFormatCount,
-              configuration->viewFormats.value())) {
-      throw std::runtime_error("Error with SurfaceConfiguration");
-    }
-  }
   if (!conv(surfaceConfiguration.usage, configuration->usage) ||
       !conv(surfaceConfiguration.format, configuration->format)) {
     throw std::runtime_error("Error with SurfaceConfiguration");
   }
+  // viewFormats are deep-copied into SurfaceInfo (which outlives this call);
+  // Convertor-allocated arrays would dangle.
+  std::vector<wgpu::TextureFormat> viewFormats;
+  if (configuration->viewFormats.has_value()) {
+    viewFormats = configuration->viewFormats.value();
+  }
 
 #ifdef __APPLE__
   surfaceConfiguration.alphaMode = configuration->alphaMode;
 #endif
   surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
-  _surfaceInfo->configure(surfaceConfiguration);
+  _surfaceInfo->configure(surfaceConfiguration, std::move(viewFormats));
 }
 
-void GPUCanvasContext::unconfigure() {}
+void GPUCanvasContext::unconfigure() { _surfaceInfo->unconfigure(); }
 
 std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
+  if (!_surfaceInfo->isConfigured()) {
+    // Web parity: on the web this is an InvalidStateError, not a crash.
+    throw std::runtime_error(
+        "[WebGPU] getCurrentTexture() called on a canvas context that is not "
+        "configured; call context.configure() first");
+  }
+  // The drawing buffer tracks canvas.width/height (like on the web); resize it
+  // lazily when they changed. Sizes are clamped to 1 so a canvas that has not
+  // been laid out yet (0x0) keeps working.
   auto prevSize = _surfaceInfo->getConfig();
-  auto width = _canvas->getWidth();
-  auto height = _canvas->getHeight();
-  auto sizeHasChanged = prevSize.width != width || prevSize.height != height;
+  auto width = std::max(1, _canvas->getWidth());
+  auto height = std::max(1, _canvas->getHeight());
+  auto sizeHasChanged = prevSize.width != static_cast<uint32_t>(width) ||
+                        prevSize.height != static_cast<uint32_t>(height);
   if (sizeHasChanged) {
     _surfaceInfo->reconfigure(width, height);
   }
 
   auto texture = _surfaceInfo->getCurrentTexture();
+  if (texture == nullptr) {
+    throw std::runtime_error(
+        "[WebGPU] getCurrentTexture() failed to acquire a texture");
+  }
 
   auto size = _surfaceInfo->getSize();
   _canvas->setClientWidth(size.width);
@@ -52,13 +68,11 @@ std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
 }
 
 void GPUCanvasContext::present() {
-  // Present runs synchronously on the calling thread (the one that did
-  // getCurrentTexture / submit), preserving Dawn surface thread-affinity.
-  // Required on every runtime (main JS, Reanimated UI, dedicated worklet);
-  // offscreen surfaces have no wgpu::Surface so they no-op.
-  if (_surfaceInfo->hasSurface()) {
-    _surfaceInfo->presentFrame();
-  }
+  // presentFrame() is the end-of-frame boundary: it presents when this frame's
+  // texture was acquired from the on-screen surface (offscreen and dropped
+  // frames are skipped), clears the frame state, and adopts any surface that
+  // attached while the frame was in flight.
+  _surfaceInfo->presentFrame();
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -57,7 +57,9 @@ public:
   std::shared_ptr<GPUTexture> getCurrentTexture();
   // Present is explicit on every runtime (main JS, Reanimated UI, and dedicated
   // worklet runtimes). It runs synchronously on the calling thread, preserving
-  // Dawn surface thread-affinity; offscreen surfaces no-op.
+  // Dawn surface thread-affinity; frames rendered offscreen (no surface
+  // attached) are skipped. It is also the end-of-frame boundary at which a
+  // newly attached native surface is adopted (see SurfaceInfo).
   void present();
 
 private:

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -348,6 +348,7 @@ std::shared_ptr<GPUSharedFence> GPUDevice::importSharedFence(
 }
 
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
+    jsi::Runtime &runtime,
     std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {
   wgpu::ComputePipelineDescriptor desc{};
   Convertor conv;
@@ -360,12 +361,16 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
       descriptor->label.has_value() ? descriptor->label.value() : "");
   auto pipelineHolder = std::make_shared<GPUComputePipeline>(nullptr, label);
 
-  return _async->postTask([device = _instance, desc, descriptor,
-                           pipelineHolder](
-                              const async::AsyncTaskHandle::ResolveFunction
-                                  &resolve,
-                              const async::AsyncTaskHandle::RejectFunction
-                                  &reject) {
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask([device = _instance, desc, descriptor,
+                            pipelineHolder](
+                               const async::AsyncTaskHandle::ResolveFunction
+                                   &resolve,
+                               const async::AsyncTaskHandle::RejectFunction
+                                   &reject) {
     (void)descriptor;
     device.CreateComputePipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
@@ -389,6 +394,7 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
 }
 
 async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
+    jsi::Runtime &runtime,
     std::shared_ptr<GPURenderPipelineDescriptor> descriptor) {
   wgpu::RenderPipelineDescriptor desc{};
   Convertor conv;
@@ -402,12 +408,16 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
       descriptor->label.has_value() ? descriptor->label.value() : "");
   auto pipelineHolder = std::make_shared<GPURenderPipeline>(nullptr, label);
 
-  return _async->postTask([device = _instance, desc, descriptor,
-                           pipelineHolder](
-                              const async::AsyncTaskHandle::ResolveFunction
-                                  &resolve,
-                              const async::AsyncTaskHandle::RejectFunction
-                                  &reject) {
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask([device = _instance, desc, descriptor,
+                            pipelineHolder](
+                               const async::AsyncTaskHandle::ResolveFunction
+                                   &resolve,
+                               const async::AsyncTaskHandle::RejectFunction
+                                   &reject) {
     (void)descriptor;
     device.CreateRenderPipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
@@ -433,13 +443,18 @@ void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
   _instance.PushErrorScope(filter);
 }
 
-async::AsyncTaskHandle GPUDevice::popErrorScope() {
+async::AsyncTaskHandle GPUDevice::popErrorScope(jsi::Runtime &runtime) {
   auto device = _instance;
 
-  return _async->postTask([device](const async::AsyncTaskHandle::ResolveFunction
-                                       &resolve,
-                                   const async::AsyncTaskHandle::RejectFunction
-                                       &reject) {
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask([device](
+                               const async::AsyncTaskHandle::ResolveFunction
+                                   &resolve,
+                               const async::AsyncTaskHandle::RejectFunction
+                                   &reject) {
     device.PopErrorScope(
         wgpu::CallbackMode::AllowProcessEvents,
         [resolve, reject](wgpu::PopErrorScopeStatus status,

package/cpp/rnwgpu/api/GPUDevice.h

@@ -136,8 +136,10 @@ public:
   std::shared_ptr<GPURenderPipeline>
   createRenderPipeline(std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
   async::AsyncTaskHandle createComputePipelineAsync(
+      jsi::Runtime &runtime,
       std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
   async::AsyncTaskHandle createRenderPipelineAsync(
+      jsi::Runtime &runtime,
       std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
   std::shared_ptr<GPUCommandEncoder> createCommandEncoder(
       std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor);
@@ -146,7 +148,7 @@ public:
   std::shared_ptr<GPUQuerySet>
   createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor);
   void pushErrorScope(wgpu::ErrorFilter filter);
-  async::AsyncTaskHandle popErrorScope();
+  async::AsyncTaskHandle popErrorScope(jsi::Runtime &runtime);
 
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
@@ -192,10 +194,10 @@ public:
                   &GPUDevice::createComputePipeline);
     installMethod(runtime, prototype, "createRenderPipeline",
                   &GPUDevice::createRenderPipeline);
-    installMethod(runtime, prototype, "createComputePipelineAsync",
-                  &GPUDevice::createComputePipelineAsync);
-    installMethod(runtime, prototype, "createRenderPipelineAsync",
-                  &GPUDevice::createRenderPipelineAsync);
+    installMethodWithRuntime(runtime, prototype, "createComputePipelineAsync",
+                             &GPUDevice::createComputePipelineAsync);
+    installMethodWithRuntime(runtime, prototype, "createRenderPipelineAsync",
+                             &GPUDevice::createRenderPipelineAsync);
     installMethod(runtime, prototype, "createCommandEncoder",
                   &GPUDevice::createCommandEncoder);
     installMethod(runtime, prototype, "createRenderBundleEncoder",
@@ -204,8 +206,8 @@ public:
                   &GPUDevice::createQuerySet);
     installMethod(runtime, prototype, "pushErrorScope",
                   &GPUDevice::pushErrorScope);
-    installMethod(runtime, prototype, "popErrorScope",
-                  &GPUDevice::popErrorScope);
+    installMethodWithRuntime(runtime, prototype, "popErrorScope",
+                             &GPUDevice::popErrorScope);
     installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
     installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -1,5 +1,6 @@
 #include "GPUExternalTexture.h"
 
+#include <array>
 #include <cmath>
 #include <memory>
 #include <string>
@@ -56,44 +57,76 @@ static const float kIdentityTransferParams[7] = {
     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,  //
+// Identity passthrough for GPUExternalTexture.yuvToRgbMatrix: the sampled
+// texel is already RGB (Apple's biplanar path where Dawn converts in the
+// sampler transform, RGBA surfaces, or an Android AHB whose driver reports
+// RGB_IDENTITY). A 3x4 row-major matrix mapping [c.r, c.g, c.b, 1] to itself.
+static constexpr std::array<float, 12> kYuvPassthroughMatrix = {
+    1.0f, 0.0f, 0.0f, 0.0f, //
+    0.0f, 1.0f, 0.0f, 0.0f, //
+    0.0f, 0.0f, 1.0f, 0.0f, //
 };
 
-// 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;
+// Build a 3x4 row-major matrix mapping the *sampled* gamma-encoded
+// [Y, Cb, Cr, 1] (each normalized to [0,1]) to gamma-encoded R'G'B', from the
+// Vulkan-suggested YCbCr model + range of an Android external-format buffer.
+// Needed because Dawn's opaque-YCbCr sampling path hard-codes an RGB_IDENTITY
+// conversion (SamplerVk.cpp::GetYCbCrForTextureView, crbug.com/497675620), so
+// the shader receives raw Y/Cb/Cr and must convert itself.
+// The VkSamplerYcbcrModelConversion / VkSamplerYcbcrRange values are inlined
+// to avoid a Vulkan header dependency in this cross-platform file.
+[[maybe_unused]] static std::array<float, 12>
+makeYuvToRgbMatrix(uint32_t vkModel, uint32_t vkRange) {
+  constexpr uint32_t kModelRgbIdentity = 0; // VK_..._RGB_IDENTITY
+  constexpr uint32_t kModel709 = 2;         // VK_..._YCBCR_709
+  constexpr uint32_t kModel601 = 3;         // VK_..._YCBCR_601
+  constexpr uint32_t kModel2020 = 4;        // VK_..._YCBCR_2020
+  constexpr uint32_t kRangeItuNarrow = 1;   // VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
+
+  if (vkModel == kModelRgbIdentity) {
+    // The buffer content is RGB; nothing to convert.
+    return kYuvPassthroughMatrix;
+  }
+  float kr;
+  float kb;
+  switch (vkModel) {
+  case kModel709:
+    kr = 0.2126f;
+    kb = 0.0722f;
+    break;
+  case kModel2020:
+    kr = 0.2627f;
+    kb = 0.0593f;
+    break;
+  case kModel601:
   default:
-    return false;
+    // YCBCR_IDENTITY and unknown models: Android camera streams are BT.601 in
+    // practice, so that is the sane default.
+    kr = 0.299f;
+    kb = 0.114f;
+    break;
   }
+  const float kg = 1.0f - kr - kb;
+  const bool narrow = vkRange == kRangeItuNarrow;
+  const float yScale = narrow ? 255.0f / 219.0f : 1.0f;
+  const float cScale = narrow ? 255.0f / 224.0f : 1.0f;
+  const float yOffset = narrow ? 16.0f / 255.0f : 0.0f;
+  const float cOffset = 128.0f / 255.0f;
+  const float crR = 2.0f * (1.0f - kr) * cScale;
+  const float cbG = -2.0f * kb * (1.0f - kb) / kg * cScale;
+  const float crG = -2.0f * kr * (1.0f - kr) / kg * cScale;
+  const float cbB = 2.0f * (1.0f - kb) * cScale;
+  return {
+      yScale, 0.0f, crR,  -yScale * yOffset - crR * cOffset,         //
+      yScale, cbG,  crG,  -yScale * yOffset - (cbG + crG) * cOffset, //
+      yScale, cbB,  0.0f, -yScale * yOffset - cbB * cOffset,         //
+  };
 }
 
 // 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) {
+static wgpu::ExternalTextureRotation toExternalTextureRotation(double degrees) {
   int quadrant = static_cast<int>(std::lround(degrees / 90.0)) & 3;
   switch (quadrant) {
   case 1:
@@ -216,7 +249,11 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
 
   return std::make_shared<GPUExternalTexture>(
       std::move(external), std::move(memory), std::move(texture),
-      std::move(descriptor->source), std::move(label));
+      std::move(descriptor->source), std::move(label),
+      // Dawn's Metal path applies the YUV->RGB conversion (from
+      // frame.yuvToRgbMatrix above) inside the sampling transform, so the
+      // sampled texel is already RGB.
+      kYuvPassthroughMatrix);
 #elif defined(__ANDROID__)
   // 1. Import the AHardwareBuffer as SharedTextureMemory. For YUV AHBs this
   //    yields a Dawn texture in the implementation-defined OpaqueYCbCrAndroid
@@ -257,32 +294,39 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
         "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());
+  // 4. Resolve the YUV->RGB conversion the *shader* must apply. Dawn imports
+  //    every YUV / implementation-defined AHB format as OpaqueYCbCrAndroid
+  //    (AHBFunctions.cpp::FormatFromAHardwareBufferFormat) and samples it
+  //    through a Vulkan SamplerYcbcrConversion that is hard-coded to
+  //    RGB_IDENTITY (SamplerVk.cpp::GetYCbCrForTextureView,
+  //    crbug.com/497675620), so the sample always comes back as raw
+  //    [Y, Cb, Cr]. The driver's *suggested* model + range are captured at
+  //    import time though; read them back from the shared memory's properties
+  //    and derive the correct conversion matrix, exposed to JS as
+  //    GPUExternalTexture.yuvToRgbMatrix. Defined color formats (e.g. an RGBA
+  //    AHB -> RGBA8Unorm) sample as RGB directly and get the passthrough.
+  std::array<float, 12> yuvToRgbMatrix = kYuvPassthroughMatrix;
+  if (texture.GetFormat() == wgpu::TextureFormat::OpaqueYCbCrAndroid) {
+    wgpu::SharedTextureMemoryAHardwareBufferProperties ahbProps{};
+    wgpu::SharedTextureMemoryProperties props{};
+    props.nextInChain = &ahbProps;
+    if (memory.GetProperties(&props)) {
+      yuvToRgbMatrix = makeYuvToRgbMatrix(ahbProps.yCbCrInfo.vkYCbCrModel,
+                                          ahbProps.yCbCrInfo.vkYCbCrRange);
+    } else {
+      // Fall back to the Android camera norm rather than passthrough.
+      yuvToRgbMatrix = makeYuvToRgbMatrix(/* YCBCR_601 */ 3,
+                                          /* ITU_NARROW */ 1);
+    }
+  }
 
-  wgpu::TextureView plane0;
-  wgpu::TextureView plane1;
+  // 5. Build the ExternalTextureDescriptor: a single (opaque or RGB) plane
+  //    with identity transfer. The YUV->RGB conversion cannot run inside
+  //    Dawn's external-texture transform here: the single-plane branch of the
+  //    Tint transform ignores yuvToRgbConversionMatrix, which is why the
+  //    matrix is surfaced to the shader instead. The gamut/transfer arrays
+  //    must still be non-null: ComputeExternalTextureParams dereferences them
+  //    unconditionally.
   wgpu::ExternalTextureDescriptor extDesc{};
   if (!label.empty()) {
     extDesc.label = wgpu::StringView(label.c_str(), label.size());
@@ -291,24 +335,10 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
   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;
-  }
+  wgpu::TextureView 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));
@@ -324,7 +354,8 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
 
   return std::make_shared<GPUExternalTexture>(
       std::move(external), std::move(memory), std::move(texture),
-      std::move(descriptor->source), std::move(label));
+      std::move(descriptor->source), std::move(label),
+      std::move(yuvToRgbMatrix));
 #else
   throw std::runtime_error(
       "GPUExternalTexture::Create(): not yet implemented on this "