react-native-webgpu 0.14.1 → 0.15.0

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

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -256,6 +256,26 @@ void GPUQueue::copyExternalImageToTexture(
   }
 }
 
+// Releases a frame the platform handed over that is not going to be drawn.
+static void releaseFrame(VideoFrameHandle &frame) {
+  if (frame.deleter) {
+    frame.deleter();
+    frame.deleter = nullptr;
+  }
+  frame.handle = nullptr;
+}
+
+// A rejected JS promise. A resolve factory cannot reject the task's promise
+// itself; resolving it with this value makes it adopt the rejection.
+static jsi::Value rejectedPromise(jsi::Runtime &runtime,
+                                  const std::string &message) {
+  auto promiseConstructor =
+      runtime.global().getPropertyAsObject(runtime, "Promise");
+  auto reject = promiseConstructor.getPropertyAsFunction(runtime, "reject");
+  jsi::JSError error(runtime, message);
+  return reject.callWithThis(runtime, promiseConstructor, error.value());
+}
+
 async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
     jsi::Runtime &runtime, std::shared_ptr<GPUDrawElementImageSource> source,
     std::shared_ptr<GPUDrawElementImageDestination> destination) {
@@ -337,6 +357,18 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
         "a positive width and height");
   }
 
+  // With RENDER_ATTACHMENT as well, a platform that renders the view into a
+  // GPU buffer (Android 13 and above, through HardwareRenderer) hands that
+  // buffer over instead of reading the pixels back, and the view is drawn into
+  // the destination on the GPU (VideoFrameBlit), which writes the color aspect
+  // of the first layer. An omitted aspect means "all" (dst.aspect itself stays
+  // at Dawn's Undefined default, which WriteTexture reads the same way).
+  request.allowFrame =
+      (texture.GetUsage() & wgpu::TextureUsage::RenderAttachment) != 0 &&
+      info->aspect.value_or(wgpu::TextureAspect::All) ==
+          wgpu::TextureAspect::All &&
+      dst.origin.z == 0;
+
   // Destination size (pixels). Omitted means the source rectangle's natural
   // pixel size (points times the device pixel ratio), which the platform
   // computes; the bounds check then happens once the pixels are back.
@@ -372,13 +404,15 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
   auto context =
       async::RuntimeContext::getOrCreate(runtime, _async->instance());
   auto queue = _instance;
+  auto device = _device;
+  auto blit = _videoFrameBlit;
   // Keeps the destination texture alive until the write is issued.
   auto gpuTexture = info->texture;
   return context->postTask(
       [platform, request, dst, mipWidth, mipHeight, destinationIsBgra,
-       destinationPremultiplied, queue,
-       gpuTexture](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                   const async::AsyncTaskHandle::RejectFunction &reject) {
+       destinationPremultiplied, device, queue, gpuTexture,
+       blit](const async::AsyncTaskHandle::ResolveFunction &resolve,
+             const async::AsyncTaskHandle::RejectFunction &reject) {
         platform->snapshotView(
             request,
             [resolve, reject, dst, mipWidth, mipHeight, destinationIsBgra,
@@ -432,6 +466,67 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
                 return jsi::Value::undefined();
               });
             },
+            [resolve, reject, dst, mipWidth, mipHeight,
+             destinationPremultiplied, device, queue, gpuTexture,
+             blit](VideoFrameHandle frame) mutable {
+              // Arbitrary (UI) thread: validate without touching JSI. A frame
+              // that is not drawn is released here.
+              if (frame.handle == nullptr || frame.width == 0 ||
+                  frame.height == 0) {
+                releaseFrame(frame);
+                reject("drawElementImageToTexture: the view produced no "
+                       "pixels (is it mounted with a non-zero size?)");
+                return;
+              }
+              if (frame.width >
+                      mipWidth - std::min<uint32_t>(dst.origin.x, mipWidth) ||
+                  frame.height >
+                      mipHeight - std::min<uint32_t>(dst.origin.y, mipHeight)) {
+                auto message =
+                    "drawElementImageToTexture: the view's natural pixel "
+                    "size (" +
+                    std::to_string(frame.width) + "x" +
+                    std::to_string(frame.height) +
+                    ") does not fit in the destination texture at "
+                    "destination.origin; pass destination.size to scale "
+                    "it, or create a larger texture";
+                releaseFrame(frame);
+                reject(std::move(message));
+                return;
+              }
+              resolve([frame = std::move(frame), dst, destinationPremultiplied,
+                       device, queue, gpuTexture,
+                       blit](jsi::Runtime &runtime) mutable -> jsi::Value {
+                // Owning runtime's thread. Draw the buffer into the
+                // destination region on the GPU: importing it as an external
+                // texture makes the GPU wait on the renderer's fence first,
+                // and the blit converts the renderer's premultiplied pixels to
+                // straight alpha unless the destination asks for premultiplied
+                // ones. The frame is released once the draw is submitted (Dawn
+                // keeps its own reference to the buffer for in-flight work).
+                auto videoFrame =
+                    std::make_shared<VideoFrame>(std::move(frame));
+                VideoFrameBlit::Request blitRequest;
+                blitRequest.frame = videoFrame;
+                blitRequest.width = videoFrame->handle().width;
+                blitRequest.height = videoFrame->handle().height;
+                blitRequest.alpha = destinationPremultiplied
+                                        ? VideoFrameBlit::Alpha::Premultiplied
+                                        : VideoFrameBlit::Alpha::Straight;
+                blitRequest.texture = dst.texture;
+                blitRequest.mipLevel = dst.mipLevel;
+                blitRequest.dstX = dst.origin.x;
+                blitRequest.dstY = dst.origin.y;
+                try {
+                  blit->copy(device, queue, blitRequest);
+                } catch (const std::exception &error) {
+                  videoFrame->release();
+                  return rejectedPromise(runtime, error.what());
+                }
+                videoFrame->release();
+                return jsi::Value::undefined();
+              });
+            },
             [reject](std::string error) { reject(std::move(error)); });
       });
 }

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -2,6 +2,8 @@
 
 #include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "NativeObject.h"
 
@@ -248,10 +250,14 @@ public:
     return std::make_shared<VideoFrame>(std::move(frame));
   }
 
-  std::shared_ptr<VideoFrame> createTestVideoFrame(double width,
-                                                   double height) {
+  std::shared_ptr<VideoFrame>
+  createTestVideoFrame(double width, double height,
+                       std::optional<std::string> pixelFormat) {
+    auto format = (pixelFormat && pixelFormat.value() == "nv12")
+                      ? VideoPixelFormat::NV12
+                      : VideoPixelFormat::BGRA8;
     auto frame = _platformContext->createTestVideoFrame(
-        static_cast<uint32_t>(width), static_cast<uint32_t>(height));
+        static_cast<uint32_t>(width), static_cast<uint32_t>(height), format);
     return std::make_shared<VideoFrame>(std::move(frame));
   }
 
@@ -296,6 +302,9 @@ public:
   //   simulated unmount re-runs JS effects without unmounting native views,
   //   and removing the entry then would orphan the still-attached surface.
   // - No native surface: the JS side is the last owner and removes the entry.
+  //   The SurfaceInfo stays reachable by id for as long as a GPUCanvasContext
+  //   holds it, so a surface attaching after StrictMode's early cleanup still
+  //   lands in the context the first effect run made.
   // The check-and-erase runs atomically under the registry lock
   // (removeSurfaceInfoIfDetached), serialized against the UI thread's
   // find-or-create + attach (SurfaceRegistry::attachSurface), so a concurrent