react-native-webgpu 0.14.2 → 0.15.1

package/cpp/dawn/common/ExternalTextureParams.h

@@ -0,0 +1,67 @@
+// Copyright 2026 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// DAWN_VENDORED_EXTERNAL_TEXTURE_PARAMS
+//
+// Vendored from Dawn's src/dawn/common/ExternalTextureParams.h, unchanged. The
+// functions it declares are compiled into the Dawn binaries that
+// react-native-webgpu-dawn ships (libwebgpu_dawn.so, libwebgpu_dawn.a), which
+// export them, but the package only ships Dawn's public headers. The copy is
+// pinned to the Dawn commit of the package in scripts/check-dawn.ts: on a Dawn
+// bump, diff it against the new commit's file and re-sync it.
+
+#ifndef SRC_DAWN_COMMON_EXTERNALTEXTUREPARAMS_H_
+#define SRC_DAWN_COMMON_EXTERNALTEXTUREPARAMS_H_
+
+#include <webgpu/webgpu_cpp.h>
+
+#include <array>
+
+namespace dawn {
+
+// Color space parameters that can be passed to an ExternalTexture.
+struct ExternalTextureColorSpaceParams {
+    // Stored row-major to save uniform buffer space. (so one full row after another)
+    // TODO(https://crbug.com/496604550): That's an implementation detail that should not be exposed
+    // in the API, Dawn can transpose internally.
+    std::array<float, 12> yuvToRgbConversionMatrix{};
+    std::array<float, 7> srcTransferFunction = {};
+    std::array<float, 7> dstTransferFunction = {};  // Really the inverse transfer function.
+    // Stored column major to match WGSL. (so one full column after another)
+    std::array<float, 9> gamutConversionMatrix{};
+};
+
+// Helper function to make parameters for an ExternalTextureDescriptor
+wgpu::Status ComputeExternalTextureParams(const wgpu::ColorSpaceDawn& srcColorSpace,
+                                          wgpu::PredefinedColorSpace dstColorSpace,
+                                          ExternalTextureColorSpaceParams* out);
+
+ExternalTextureColorSpaceParams GetNoopColorSpaceParams();
+
+}  // namespace dawn
+
+#endif  // SRC_DAWN_COMMON_EXTERNALTEXTUREPARAMS_H_

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,16 @@ 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;
+  // iOS: whether to flush pending layout and layer changes before drawing
+  // (drawViewHierarchyInRect's afterScreenUpdates), so a snapshot taken right
+  // after a state change reflects it; false draws the last committed frame
+  // without that round trip. Android renders the views' current display
+  // lists either way.
+  bool afterScreenUpdates = true;
 };
 
 class PlatformContext {
@@ -129,17 +173,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 +218,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();