react-native-webgpu 0.14.2 → 0.15.0

package/cpp/rnwgpu/PlatformContext.h

@@ -3,6 +3,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <span>
 #include <string>
 #include <utility>
@@ -36,6 +37,20 @@ enum class VideoPixelFormat {
   NV12,
 };
 
+// The color space of a YUV frame, as its producer reports it: the YCbCr matrix
+// and range that encode the samples, and the primaries and transfer function of
+// the RGB they encode. Each member is optional: what the producer does not know
+// (a camera buffer carries no color metadata, a container may record only some
+// of it) is resolved at import time (GPUExternalTexture::Create) from the
+// buffer and the platform's norm. Dawn converts the samples to RGB in the
+// destination color space while sampling the external texture.
+struct VideoFrameColorSpace {
+  std::optional<wgpu::ColorSpacePrimariesDawn> primaries;
+  std::optional<wgpu::ColorSpaceTransferDawn> transfer;
+  std::optional<wgpu::ColorSpaceYCbCrRangeDawn> range;
+  std::optional<wgpu::ColorSpaceYCbCrMatrixDawn> matrix;
+};
+
 // A native handle to a video frame that can be imported into a
 // GPUSharedTextureMemory.
 //
@@ -50,14 +65,33 @@ struct VideoFrameHandle {
   uint32_t width = 0;
   uint32_t height = 0;
   VideoPixelFormat pixelFormat = VideoPixelFormat::BGRA8;
-  // 3x4 row-major matrix mapping [Y, U, V, 1] → linear [R, G, B]. Pre-computed
-  // at decode time from CVPixelBuffer attachments (kCVImageBufferYCbCrMatrixKey
-  // + range), with a BT.709 limited-range default. Only meaningful when
-  // pixelFormat == NV12.
-  float yuvToRgbMatrix[12] = {};
+  // The color space of the samples. Only meaningful when pixelFormat == NV12:
+  // from the CVPixelBuffer attachments on Apple platforms, from the Image's
+  // data space (API 33) or the container's color info on Android.
+  VideoFrameColorSpace colorSpace;
+  // Android: the acquire fence of the frame as a sync file descriptor, or -1.
+  // The producer (video decoder, camera) may still be writing the buffer when
+  // the consumer gets it; the GPU work that reads the frame waits on this fence
+  // (imported as a shared-fence-sync-fd into BeginAccess). Owned by the handle:
+  // the deleter closes it. Importing it into Dawn duplicates it, so the frame
+  // can be imported more than once.
+  int acquireFenceFd = -1;
   std::function<void()> deleter;
 };
 
+// The samples of the NV12 test frame of createTestVideoFrame: pure red and
+// pure green in BT.709 limited range (Y 16..235, Cb/Cr 16..240), so the frame
+// converts back to exactly those colors in sRGB. Shared by both platforms so
+// the e2e spec sees the same frame on each.
+namespace test_yuv_frame {
+constexpr uint8_t kRedY = 63;
+constexpr uint8_t kRedCb = 102;
+constexpr uint8_t kRedCr = 240;
+constexpr uint8_t kGreenY = 173;
+constexpr uint8_t kGreenCb = 42;
+constexpr uint8_t kGreenCr = 26;
+} // namespace test_yuv_frame
+
 // Platform-implemented video source that hands out fresh IOSurface /
 // AHardwareBuffer-backed frames as a video plays, with the playback controls
 // of an HTMLMediaElement (times in seconds).
@@ -110,6 +144,10 @@ struct ViewSnapshotRequest {
   double sourceHeight = 0;
   uint32_t width = 0;
   uint32_t height = 0;
+  // Whether the caller can draw a GPU frame (a VideoFrameHandle) into the
+  // destination itself. A platform that renders the view into a GPU buffer
+  // then hands that buffer over instead of reading the pixels back.
+  bool allowFrame = false;
 };
 
 class PlatformContext {
@@ -129,17 +167,24 @@ public:
     return currentSlot();
   }
 
-  // Rasterize a native view into CPU pixels (see ViewSnapshotRequest). The
-  // implementation hops to the platform UI thread, so this is asynchronous:
-  // exactly one of onSuccess / onError is invoked, from an arbitrary thread
+  // Rasterize a native view (see ViewSnapshotRequest). The implementation hops
+  // to the platform UI thread, so this is asynchronous: exactly one of
+  // onPixels / onFrame / onError is invoked, from an arbitrary thread
   // (typically the UI thread). Callers must not touch JSI in the callbacks.
   //
-  // The returned ImageData is tightly packed (no row padding), 4 bytes per
-  // pixel, `format` is rgba8unorm or bgra8unorm depending on what the platform
-  // rasterizer produces natively, and `premultiplied` reports its alpha
-  // representation.
+  // onPixels receives the view as CPU pixels: tightly packed (no row
+  // padding), 4 bytes per pixel, `format` rgba8unorm or bgra8unorm depending
+  // on what the platform rasterizer produces natively, and `premultiplied`
+  // reporting its alpha representation.
+  //
+  // onFrame, only when the request allows it, receives the GPU buffer the
+  // platform rendered the view into (Android 13 and above: the
+  // HardwareRenderer's AHardwareBuffer, with the fence that signals when the
+  // drawing is done), as an RGBA frame of premultiplied pixels. The receiver
+  // owns the frame and releases it through its deleter.
   virtual void snapshotView(const ViewSnapshotRequest &request,
-                            std::function<void(ImageData)> onSuccess,
+                            std::function<void(ImageData)> onPixels,
+                            std::function<void(VideoFrameHandle)> onFrame,
                             std::function<void(std::string)> onError) = 0;
 
   virtual ImageData createImageBitmap(std::string blobId, double offset,
@@ -167,9 +212,13 @@ public:
 
   // Create a synthetic, GPU-shareable IOSurface/AHardwareBuffer filled with a
   // generated test pattern. Avoids the need to bundle a video asset for the
-  // SharedTextureMemory example.
-  virtual VideoFrameHandle createTestVideoFrame(uint32_t width,
-                                                uint32_t height) = 0;
+  // SharedTextureMemory example. BGRA8 is an RGB gradient; NV12 is a biplanar
+  // YUV frame, BT.709 limited range, red on the left half and green on the
+  // right, which exercises the color conversion of importExternalTexture.
+  // Throws a message containing "unsupported" where the platform cannot
+  // allocate or fill the YUV layout (Android before API 29).
+  virtual VideoFrameHandle createTestVideoFrame(uint32_t width, uint32_t height,
+                                                VideoPixelFormat format) = 0;
 
   // Open a video file at `path` for playback. The returned player yields
   // IOSurface / AHardwareBuffer-backed frames via copyLatestFrame().

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -12,6 +12,9 @@
 #ifdef __APPLE__
 #include <TargetConditionals.h>
 #endif
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
 
 #include "Convertors.h"
 
@@ -158,7 +161,14 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
         message.length > 0 ? std::string(message.data, message.length) : "";
     std::string fullMessage =
         msg.length() > 0 ? std::string(errorType) + ": " + msg : "no message";
+#ifdef __ANDROID__
+    // stderr goes nowhere in an Android app; logcat is where the message can
+    // be read (and where CI collects it).
+    __android_log_print(ANDROID_LOG_ERROR, "WebGPU", "Uncaptured error: %s",
+                        fullMessage.c_str());
+#else
     fprintf(stderr, "%s\n", fullMessage.c_str());
+#endif
 
     // Look up the GPUDevice from the registry and notify it
     if (auto gpuDevice = GPUDevice::lookupDevice(device.Get())) {
@@ -224,6 +234,31 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
             disabledToggles.push_back(name);
           }
         }
+#endif
+#if defined(__ANDROID__)
+        // Dawn checks the memory a VkImage needs for an imported
+        // AHardwareBuffer against the allocation size the driver reports for
+        // the buffer, and some drivers report it wrong: Dawn itself skips the
+        // check on Samsung, Qualcomm and Huawei drivers
+        // (https://crbug.com/333424893). The emulator (gfxstream) reports 0
+        // for the buffers HWUI draws into, which rejects every view snapshot
+        // and SurfaceControl import there, so skip it on all of Android unless
+        // the caller disables the toggle. Dawn drops unknown toggle names, so a
+        // build without this toggle is unaffected.
+        static const char *const kAndroidEnabledToggles[] = {
+            "ignore_imported_ahardwarebuffer_vulkan_image_size"};
+        for (const char *name : kAndroidEnabledToggles) {
+          const auto named = [name](const char *t) {
+            return std::strcmp(t, name) == 0;
+          };
+          const bool explicitlyDisabled = std::any_of(
+              disabledToggles.begin(), disabledToggles.end(), named);
+          const bool alreadyEnabled =
+              std::any_of(enabledToggles.begin(), enabledToggles.end(), named);
+          if (!explicitlyDisabled && !alreadyEnabled) {
+            enabledToggles.push_back(name);
+          }
+        }
 #endif
         if (!enabledToggles.empty() || !disabledToggles.empty()) {
           toggles.enabledToggleCount = enabledToggles.size();

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -3,13 +3,18 @@
 #include <array>
 #include <cmath>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "GPUExternalTextureDescriptor.h"
 
+#include "dawn/common/ExternalTextureParams.h"
+
 #if defined(__ANDROID__)
 #include <android/hardware_buffer.h>
+#include <android/log.h>
+#include <poll.h>
 #endif
 
 namespace rnwgpu {
@@ -49,117 +54,80 @@ static bool isOpaqueYCbCrFormat(uint32_t format) {
 }
 #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, //
-    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
-};
-
-// 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, //
-};
-
-// 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;
+// The color space of a YUV frame with every member known. The producer reports
+// what it knows (VideoFrameHandle.colorSpace); the matrix and range it leaves
+// out come from `fallbackMatrix` / `fallbackRange`, the platform's best guess
+// for the buffer, and the rest follows from the matrix: the primaries of the
+// standard that defines it, and the SMPTE 170M transfer function that BT.601,
+// BT.709 and BT.2020 SDR video is encoded with. An identity matrix means the
+// samples are RGB already, which the identity transfer leaves untouched.
+static wgpu::ColorSpaceDawn
+resolveColorSpace(const VideoFrameColorSpace &reported,
+                  wgpu::ColorSpaceYCbCrMatrixDawn fallbackMatrix,
+                  wgpu::ColorSpaceYCbCrRangeDawn fallbackRange) {
+  wgpu::ColorSpaceDawn colorSpace{};
+  colorSpace.yCbCrMatrix = reported.matrix.value_or(fallbackMatrix);
+  colorSpace.yCbCrRange = reported.range.value_or(fallbackRange);
+  if (reported.primaries.has_value()) {
+    colorSpace.primaries = *reported.primaries;
+  } else {
+    switch (colorSpace.yCbCrMatrix) {
+    case wgpu::ColorSpaceYCbCrMatrixDawn::Rec601:
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::Rec601;
+      break;
+    case wgpu::ColorSpaceYCbCrMatrixDawn::Rec2020:
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::Rec2020;
+      break;
+    default:
+      // BT.709 shares the sRGB primaries (Dawn's helper only knows them under
+      // that name).
+      colorSpace.primaries = wgpu::ColorSpacePrimariesDawn::SRGB;
+      break;
+    }
   }
-  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:
-    // 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;
+  if (reported.transfer.has_value()) {
+    colorSpace.transfer = *reported.transfer;
+  } else {
+    colorSpace.transfer =
+        colorSpace.yCbCrMatrix == wgpu::ColorSpaceYCbCrMatrixDawn::Identity
+            ? wgpu::ColorSpaceTransferDawn::Identity
+            : wgpu::ColorSpaceTransferDawn::SMPTE_170M;
   }
-  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,         //
-  };
+  return colorSpace;
+}
+
+// The ExternalTextureDescriptor parameters that convert samples in `source` to
+// RGB in the color space the descriptor asks for ("srgb" by default,
+// "display-p3"): the YCbCr matrix, the range, the source transfer function,
+// the gamut conversion and the destination transfer function. Dawn applies
+// them while sampling the external texture. The helper is Dawn's own, the one
+// Chromium feeds video frames through.
+static dawn::ExternalTextureColorSpaceParams
+colorSpaceParams(const wgpu::ColorSpaceDawn &source,
+                 const std::optional<std::string> &destination) {
+  auto target = destination.has_value() && *destination == "display-p3"
+                    ? wgpu::PredefinedColorSpace::DisplayP3
+                    : wgpu::PredefinedColorSpace::SRGB;
+  dawn::ExternalTextureColorSpaceParams params;
+  if (dawn::ComputeExternalTextureParams(source, target, &params) !=
+      wgpu::Status::Success) {
+    throw std::runtime_error(
+        "GPUExternalTexture::Create(): the color space of the frame cannot be "
+        "converted to '" +
+        destination.value_or("srgb") + "'");
+  }
+  return params;
+}
+
+// Dawn dereferences the four arrays unconditionally, so a descriptor always
+// carries a full set, the no-op one for frames that are RGB already.
+static void
+applyColorSpaceParams(wgpu::ExternalTextureDescriptor &descriptor,
+                      const dawn::ExternalTextureColorSpaceParams &params) {
+  descriptor.yuvToRgbConversionMatrix = params.yuvToRgbConversionMatrix.data();
+  descriptor.srcTransferFunctionParameters = params.srcTransferFunction.data();
+  descriptor.dstTransferFunctionParameters = params.dstTransferFunction.data();
+  descriptor.gamutConversionMatrix = params.gamutConversionMatrix.data();
 }
 
 // Map a rotation in degrees (0 / 90 / 180 / 270) to Dawn's enum. Anything that
@@ -250,26 +218,27 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
     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.
+  // 5. Build the ExternalTextureDescriptor. Dawn converts the YUV planes to
+  //    RGB in the destination color space while sampling, with the matrix,
+  //    range, transfer function and gamut of the frame's color space (from the
+  //    CVPixelBuffer attachments; BT.709 limited range, the norm for HD video,
+  //    where they are missing). A BGRA frame is RGB already: no-op parameters.
+  dawn::ExternalTextureColorSpaceParams params =
+      isYuv ? colorSpaceParams(
+                  resolveColorSpace(frame.colorSpace,
+                                    wgpu::ColorSpaceYCbCrMatrixDawn::Rec709,
+                                    wgpu::ColorSpaceYCbCrRangeDawn::Narrow),
+                  descriptor->colorSpace)
+            : dawn::GetNoopColorSpaceParams();
   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;
   }
+  applyColorSpaceParams(extDesc, params);
   extDesc.cropOrigin = {0, 0};
   extDesc.cropSize = {frame.width, frame.height};
   extDesc.apparentSize = {frame.width, frame.height};
@@ -287,11 +256,7 @@ 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),
-      // 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);
+      std::move(descriptor->source), std::move(label));
 #elif defined(__ANDROID__)
   // 0. A YUV frame imports as an OpaqueYCbCrAndroid texture, which Dawn only
   //    accepts on a device with OpaqueYCbCrAndroidForExternalTexture.
@@ -344,49 +309,103 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
   // 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).
+  //
+  //    The producer of the frame (the video decoder, the camera) may still be
+  //    writing it: ImageReader hands a buffer out as soon as it is queued, and
+  //    only waits on the producer's fence for CPU access. The fence travels
+  //    with the frame as a sync fd; imported as a shared fence, BeginAccess
+  //    makes the GPU wait on it before any work that samples the texture.
+  //    Dawn duplicates the descriptor on import; the frame keeps its own.
   wgpu::SharedTextureMemoryBeginAccessDescriptor begin{};
   begin.initialized = true;
   begin.concurrentRead = false;
   wgpu::SharedTextureMemoryVkImageLayoutBeginState beginLayout{};
   begin.nextInChain = &beginLayout;
+  wgpu::SharedFence acquireFence;
+  const uint64_t kBinaryFenceSignaled = 1;
+  if (frame.acquireFenceFd >= 0) {
+    if (device.HasFeature(wgpu::FeatureName::SharedFenceSyncFD)) {
+      wgpu::SharedFenceSyncFDDescriptor fdDesc{};
+      fdDesc.handle = frame.acquireFenceFd;
+      wgpu::SharedFenceDescriptor fenceDesc{};
+      fenceDesc.nextInChain = &fdDesc;
+      acquireFence = device.ImportSharedFence(&fenceDesc);
+      if (acquireFence) {
+        begin.fenceCount = 1;
+        begin.fences = &acquireFence;
+        begin.signaledValueCount = 1;
+        begin.signaledValues = &kBinaryFenceSignaled;
+      }
+    } else {
+      // A device without shared-fence-sync-fd (imported from another library
+      // that did not request it) cannot wait on the GPU: wait here instead. A
+      // sync fd becomes readable once it signals.
+      pollfd pfd{};
+      pfd.fd = frame.acquireFenceFd;
+      pfd.events = POLLIN;
+      int polled = poll(&pfd, 1, 3000);
+      if (polled <= 0) {
+        __android_log_print(ANDROID_LOG_WARN, "GPUExternalTexture",
+                            "the acquire fence of the frame did not signal "
+                            "within 3s; sampling it anyway");
+      }
+    }
+  }
   if (memory.BeginAccess(texture, &begin) != wgpu::Status::Success) {
     throw std::runtime_error(
         "GPUExternalTexture::Create(): BeginAccess failed");
   }
 
-  // 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;
+  // 4. The color conversion. Dawn imports every YUV AHardwareBuffer as an
+  //    OpaqueYCbCrAndroid texture and samples it through a Vulkan YCbCr
+  //    sampler whose own conversion is the identity (SamplerVk.cpp), so the
+  //    sample is raw Y, Cb, Cr; the external texture then applies the
+  //    descriptor's YCbCr matrix, transfer functions and gamut conversion
+  //    while sampling (Dawn's YUV AHB specialization), the same way it does
+  //    for the biplanar textures of the other backends. The frame's color
+  //    space comes from its producer (Image.getDataSpace on API 33, the
+  //    container's color info before that); what it leaves unknown falls back
+  //    to the YCbCr model and range the driver suggests for the buffer, read
+  //    from the shared memory's properties, and to BT.601 limited range, the
+  //    camera norm, when the driver has no opinion. A color-format AHB (RGBA8,
+  //    R8, ...) samples as RGB directly: no-op parameters.
+  dawn::ExternalTextureColorSpaceParams params =
+      dawn::GetNoopColorSpaceParams();
   if (texture.GetFormat() == wgpu::TextureFormat::OpaqueYCbCrAndroid) {
+    auto fallbackMatrix = wgpu::ColorSpaceYCbCrMatrixDawn::Rec601;
+    auto fallbackRange = wgpu::ColorSpaceYCbCrRangeDawn::Narrow;
     wgpu::SharedTextureMemoryAHardwareBufferProperties ahbProps{};
     wgpu::SharedTextureMemoryProperties props{};
     props.nextInChain = &ahbProps;
     if (memory.GetProperties(&props) == wgpu::Status::Success) {
-      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);
+      // VkSamplerYcbcrModelConversion / VkSamplerYcbcrRange values, inlined
+      // to keep this cross-platform file free of Vulkan headers.
+      switch (ahbProps.yCbCrInfo.vkYCbCrModel) {
+      case 0: // VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: RGB data
+        fallbackMatrix = wgpu::ColorSpaceYCbCrMatrixDawn::Identity;
+        fallbackRange = wgpu::ColorSpaceYCbCrRangeDawn::Identity;
+        break;
+      case 2: // VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709
+        fallbackMatrix = wgpu::ColorSpaceYCbCrMatrixDawn::Rec709;
+        break;
+      case 4: // VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
+        fallbackMatrix = wgpu::ColorSpaceYCbCrMatrixDawn::Rec2020;
+        break;
+      default: // YCBCR_601, YCBCR_IDENTITY and unknown models
+        break;
+      }
+      if (fallbackMatrix != wgpu::ColorSpaceYCbCrMatrixDawn::Identity) {
+        fallbackRange = ahbProps.yCbCrInfo.vkYCbCrRange == 0
+                            ? wgpu::ColorSpaceYCbCrRangeDawn::Full
+                            : wgpu::ColorSpaceYCbCrRangeDawn::Narrow;
+      }
     }
+    params = colorSpaceParams(
+        resolveColorSpace(frame.colorSpace, fallbackMatrix, fallbackRange),
+        descriptor->colorSpace);
   }
 
-  // 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.
+  // 5. Build the ExternalTextureDescriptor: a single (opaque or RGB) plane.
   wgpu::ExternalTextureDescriptor extDesc{};
   if (!label.empty()) {
     extDesc.label = wgpu::StringView(label.c_str(), label.size());
@@ -394,11 +413,9 @@ std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
   extDesc.cropOrigin = {0, 0};
   extDesc.cropSize = {frame.width, frame.height};
   extDesc.apparentSize = {frame.width, frame.height};
-  extDesc.gamutConversionMatrix = kIdentityGamutMatrix;
   wgpu::TextureView plane0 = texture.CreateView();
   extDesc.plane0 = plane0;
-  extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
-  extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
+  applyColorSpaceParams(extDesc, params);
   extDesc.mirrored = descriptor->mirrored.value_or(false);
   extDesc.rotation =
       toExternalTextureRotation(descriptor->rotation.value_or(0));
@@ -413,8 +430,7 @@ 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(yuvToRgbMatrix));
+      std::move(descriptor->source), std::move(label));
 #else
   throw std::runtime_error(
       "GPUExternalTexture::Create(): not yet implemented on this "

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -38,12 +38,10 @@ public:
   // the producer (e.g. AVPlayer) can reclaim the IOSurface.
   GPUExternalTexture(wgpu::ExternalTexture instance,
                      wgpu::SharedTextureMemory memory, wgpu::Texture texture,
-                     std::shared_ptr<VideoFrame> source, std::string label,
-                     std::array<float, 12> yuvToRgbMatrix)
+                     std::shared_ptr<VideoFrame> source, std::string label)
       : NativeObject(CLASS_NAME), _instance(std::move(instance)),
         _memory(std::move(memory)), _texture(std::move(texture)),
-        _source(std::move(source)), _label(std::move(label)),
-        _yuvToRgbMatrix(yuvToRgbMatrix) {}
+        _source(std::move(source)), _label(std::move(label)) {}
 
   ~GPUExternalTexture() override { destroy(); }
 
@@ -93,25 +91,11 @@ public:
     }
   }
 
-  // Non-spec extension. A 3x4 row-major matrix mapping the *sampled* texel
-  // [c.r, c.g, c.b, 1] to gamma-encoded R'G'B'. When Dawn's sampler already
-  // produces RGB (Apple's biplanar path, RGBA surfaces), this is the identity
-  // passthrough; on the Android opaque-YCbCr path the sample comes back as raw
-  // [Y, Cb, Cr] (Dawn hard-codes an RGB_IDENTITY Vulkan conversion, see
-  // crbug.com/497675620) and this matrix is derived from the driver's
-  // suggested YCbCr model + range for the buffer. Shaders can therefore apply
-  // it unconditionally after textureSampleBaseClampToEdge.
-  std::vector<double> getYuvToRgbMatrix() {
-    return std::vector<double>(_yuvToRgbMatrix.begin(), _yuvToRgbMatrix.end());
-  }
-
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUExternalTexture::getBrand);
     installGetterSetter(runtime, prototype, "label",
                         &GPUExternalTexture::getLabel,
                         &GPUExternalTexture::setLabel);
-    installGetter(runtime, prototype, "yuvToRgbMatrix",
-                  &GPUExternalTexture::getYuvToRgbMatrix);
     installMethod(runtime, prototype, "destroy", &GPUExternalTexture::destroy);
   }
 
@@ -140,7 +124,6 @@ private:
   wgpu::Texture _texture;
   std::shared_ptr<VideoFrame> _source;
   std::string _label;
-  std::array<float, 12> _yuvToRgbMatrix;
 };
 
 } // namespace rnwgpu