react-native-wgpu 0.5.11 → 0.5.13

package/apple/AppleVideoPlayer.mm

@@ -0,0 +1,314 @@
+#include "AppleVideoPlayer.h"
+
+#import <AVFoundation/AVFoundation.h>
+#import <CoreVideo/CoreVideo.h>
+
+#include <stdexcept>
+
+namespace rnwgpu {
+
+namespace {
+
+// 3x4 row-major matrices mapping [Y, Cb, Cr, 1] to gamma-encoded R'G'B' (NOT
+// linear): YCbCr is derived from gamma-encoded RGB, so this conversion stays in
+// the encoded domain. The sRGB decode in srcTransferFunctionParameters
+// linearizes afterward (see GPUExternalTexture.cpp). Limited-range (video
+// range) means luma is 16..235, chroma is 16..240 (8-bit).
+// Reference: https://en.wikipedia.org/wiki/YCbCr (BT.601 / BT.709).
+static constexpr 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, //
+};
+static constexpr float kBT601LimitedToRgb[12] = {
+    1.164383f, 0.000000f, 1.596027f, -0.874202f, //
+    1.164383f, -0.391762f, -0.812968f, 0.531668f, //
+    1.164383f, 2.017232f, 0.000000f, -1.085631f, //
+};
+static constexpr float kBT2020LimitedToRgb[12] = {
+    1.164383f, 0.000000f, 1.678674f, -0.915688f, //
+    1.164383f, -0.187326f, -0.650424f, 0.347459f, //
+    1.164383f, 2.141772f, 0.000000f, -1.148145f, //
+};
+
+// Pick the right YUV→RGB matrix from the pixel buffer's color attachments.
+// Falls back to BT.709 limited range (the right call for ≥720p H.264, which
+// is what AVPlayer hands us for Big Buck Bunny and most streamed media).
+static void fillYuvMatrix(CVPixelBufferRef pixelBuffer, float out[12]) {
+  CFTypeRef matrixKey = CVBufferGetAttachment(
+      pixelBuffer, kCVImageBufferYCbCrMatrixKey, nullptr);
+  const float *src = kBT709LimitedToRgb;
+  if (matrixKey) {
+    auto matrix = (CFStringRef)matrixKey;
+    if (CFEqual(matrix, kCVImageBufferYCbCrMatrix_ITU_R_601_4) ||
+        CFEqual(matrix, kCVImageBufferYCbCrMatrix_SMPTE_240M_1995)) {
+      src = kBT601LimitedToRgb;
+    } else if (CFEqual(matrix, kCVImageBufferYCbCrMatrix_ITU_R_2020)) {
+      src = kBT2020LimitedToRgb;
+    }
+  }
+  for (int i = 0; i < 12; ++i) {
+    out[i] = src[i];
+  }
+}
+
+// Map a CVPixelBuffer's pixel format to our VideoPixelFormat enum.
+static VideoPixelFormat pixelFormatFromCVPixelBuffer(
+    CVPixelBufferRef pixelBuffer) {
+  OSType type = CVPixelBufferGetPixelFormatType(pixelBuffer);
+  switch (type) {
+    case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+    case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+      return VideoPixelFormat::NV12;
+    default:
+      return VideoPixelFormat::BGRA8;
+  }
+}
+
+class AppleVideoPlayer : public IVideoPlayer {
+public:
+  AppleVideoPlayer(AVPlayer *player, AVPlayerItemVideoOutput *output,
+                   id loopObserver)
+      : _player(player), _output(output), _loopObserver(loopObserver) {}
+
+  ~AppleVideoPlayer() override {
+    if (_loopObserver) {
+      [[NSNotificationCenter defaultCenter] removeObserver:_loopObserver];
+      _loopObserver = nil;
+    }
+    [_player pause];
+    _player = nil;
+    _output = nil;
+  }
+
+  VideoFrameHandle copyLatestFrame() override {
+    CMTime currentTime = [_output itemTimeForHostTime:CACurrentMediaTime()];
+    if (![_output hasNewPixelBufferForItemTime:currentTime]) {
+      return {};
+    }
+    // copyPixelBufferForItemTime returns a +1 retained CVPixelBuffer; we then
+    // hand it to wrapCVPixelBuffer which adds another retain. Balance with a
+    // CFRelease here so we don't leak.
+    CVPixelBufferRef pixelBuffer =
+        [_output copyPixelBufferForItemTime:currentTime
+                         itemTimeForDisplay:nullptr];
+    if (!pixelBuffer) {
+      return {};
+    }
+    try {
+      auto handle = wrapCVPixelBuffer(pixelBuffer);
+      CFRelease(pixelBuffer);
+      return handle;
+    } catch (...) {
+      CFRelease(pixelBuffer);
+      throw;
+    }
+  }
+
+  void play() override { [_player play]; }
+  void pause() override { [_player pause]; }
+
+private:
+  AVPlayer *_player;
+  AVPlayerItemVideoOutput *_output;
+  id _loopObserver;
+};
+
+} // namespace
+
+VideoFrameHandle wrapCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
+  if (!pixelBuffer) {
+    throw std::runtime_error("wrapCVPixelBuffer: pointer is null");
+  }
+  IOSurfaceRef ioSurface = CVPixelBufferGetIOSurface(pixelBuffer);
+  if (!ioSurface) {
+    throw std::runtime_error(
+        "wrapCVPixelBuffer: pixel buffer is not IOSurface-backed (was the "
+        "camera/video pipeline configured for Metal/IOSurface output?)");
+  }
+
+  // Retain the pixel buffer so the caller can release theirs immediately.
+  CFRetain(pixelBuffer);
+
+  VideoFrameHandle handle;
+  handle.handle = (void *)ioSurface;
+  handle.width = static_cast<uint32_t>(CVPixelBufferGetWidth(pixelBuffer));
+  handle.height = static_cast<uint32_t>(CVPixelBufferGetHeight(pixelBuffer));
+  handle.pixelFormat = pixelFormatFromCVPixelBuffer(pixelBuffer);
+  if (handle.pixelFormat == VideoPixelFormat::NV12) {
+    fillYuvMatrix(pixelBuffer, handle.yuvToRgbMatrix);
+  }
+  handle.deleter = [pixelBuffer]() { CFRelease(pixelBuffer); };
+  return handle;
+}
+
+std::unique_ptr<IVideoPlayer>
+createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
+  NSString *nsPath = [NSString stringWithUTF8String:path.c_str()];
+  NSURL *url;
+  if ([nsPath hasPrefix:@"http://"] || [nsPath hasPrefix:@"https://"] ||
+      [nsPath hasPrefix:@"file://"]) {
+    url = [NSURL URLWithString:nsPath];
+  } else {
+    url = [NSURL fileURLWithPath:nsPath];
+  }
+
+  AVPlayerItem *item = [AVPlayerItem playerItemWithURL:url];
+  if (!item) {
+    throw std::runtime_error("createAppleVideoPlayer: failed to create "
+                             "AVPlayerItem");
+  }
+
+  // NV12 (kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange) lets us hand the
+  // IOSurface straight to Dawn as a multi-planar texture for
+  // importExternalTexture. BGRA is the "decode + convert" path for the
+  // single-plane SharedTextureMemory demo.
+  OSType pixelFormat = format == VideoPixelFormat::NV12
+                          ? kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+                          : kCVPixelFormatType_32BGRA;
+  NSDictionary *outputSettings = @{
+    (NSString *)kCVPixelBufferPixelFormatTypeKey : @(pixelFormat),
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
+    (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,
+  };
+  AVPlayerItemVideoOutput *output = [[AVPlayerItemVideoOutput alloc]
+      initWithPixelBufferAttributes:outputSettings];
+  [item addOutput:output];
+
+  AVPlayer *player = [AVPlayer playerWithPlayerItem:item];
+  player.actionAtItemEnd = AVPlayerActionAtItemEndNone;
+
+  // Loop on end-of-stream by seeking back to zero.
+  __weak AVPlayer *weakPlayer = player;
+  id loopObserver = [[NSNotificationCenter defaultCenter]
+      addObserverForName:AVPlayerItemDidPlayToEndTimeNotification
+                  object:item
+                   queue:[NSOperationQueue mainQueue]
+              usingBlock:^(NSNotification * /*note*/) {
+                [weakPlayer seekToTime:kCMTimeZero];
+                [weakPlayer play];
+              }];
+
+  return std::make_unique<AppleVideoPlayer>(player, output, loopObserver);
+}
+
+std::string writeAppleTestVideoFile() {
+  NSString *tmpDir = NSTemporaryDirectory();
+  NSString *outputPath =
+      [tmpDir stringByAppendingPathComponent:@"rnwgpu-test-video.mp4"];
+  NSURL *outputURL = [NSURL fileURLWithPath:outputPath];
+
+  // If the file already exists, reuse it. This makes the example zero-cost on
+  // subsequent runs.
+  if ([[NSFileManager defaultManager] fileExistsAtPath:outputPath]) {
+    return [outputPath UTF8String];
+  }
+
+  NSError *error = nil;
+  AVAssetWriter *writer = [AVAssetWriter assetWriterWithURL:outputURL
+                                                   fileType:AVFileTypeMPEG4
+                                                      error:&error];
+  if (error || !writer) {
+    throw std::runtime_error(
+        std::string("writeTestVideoFile: AVAssetWriter init failed: ") +
+        [[error localizedDescription] UTF8String]);
+  }
+
+  const int kWidth = 256;
+  const int kHeight = 256;
+  const int kFps = 30;
+  const int kSeconds = 3;
+  const int kTotalFrames = kFps * kSeconds;
+
+  NSDictionary *videoSettings = @{
+    AVVideoCodecKey : AVVideoCodecTypeH264,
+    AVVideoWidthKey : @(kWidth),
+    AVVideoHeightKey : @(kHeight),
+  };
+  AVAssetWriterInput *writerInput =
+      [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo
+                                         outputSettings:videoSettings];
+  writerInput.expectsMediaDataInRealTime = NO;
+
+  NSDictionary *bufferAttrs = @{
+    (NSString *)kCVPixelBufferPixelFormatTypeKey :
+        @(kCVPixelFormatType_32BGRA),
+    (NSString *)kCVPixelBufferWidthKey : @(kWidth),
+    (NSString *)kCVPixelBufferHeightKey : @(kHeight),
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
+  };
+  AVAssetWriterInputPixelBufferAdaptor *adaptor =
+      [AVAssetWriterInputPixelBufferAdaptor
+          assetWriterInputPixelBufferAdaptorWithAssetWriterInput:writerInput
+                                     sourcePixelBufferAttributes:bufferAttrs];
+  [writer addInput:writerInput];
+
+  if (![writer startWriting]) {
+    throw std::runtime_error(
+        std::string("writeTestVideoFile: startWriting failed: ") +
+        [[writer.error localizedDescription] UTF8String]);
+  }
+  [writer startSessionAtSourceTime:kCMTimeZero];
+
+  for (int i = 0; i < kTotalFrames; ++i) {
+    // Spin briefly if the input is not ready (the adaptor pool fills up).
+    while (!writerInput.isReadyForMoreMediaData) {
+      [NSThread sleepForTimeInterval:0.005];
+    }
+
+    CVPixelBufferRef pixelBuffer = NULL;
+    CVReturn err = CVPixelBufferPoolCreatePixelBuffer(
+        kCFAllocatorDefault, adaptor.pixelBufferPool, &pixelBuffer);
+    if (err != kCVReturnSuccess || !pixelBuffer) {
+      throw std::runtime_error("writeTestVideoFile: pool exhausted");
+    }
+
+    CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+    uint8_t *base =
+        static_cast<uint8_t *>(CVPixelBufferGetBaseAddress(pixelBuffer));
+    size_t rowBytes = CVPixelBufferGetBytesPerRow(pixelBuffer);
+    // Procedural pattern: scrolling diagonal stripes + per-frame color shift.
+    int phase = i * 6;
+    for (int y = 0; y < kHeight; ++y) {
+      uint8_t *row = base + y * rowBytes;
+      for (int x = 0; x < kWidth; ++x) {
+        uint8_t r = static_cast<uint8_t>((x + phase) & 0xFF);
+        uint8_t g = static_cast<uint8_t>((y + phase * 2) & 0xFF);
+        uint8_t b =
+            static_cast<uint8_t>(((x + y + phase) & 0x40) ? 220 : 30);
+        row[x * 4 + 0] = b;
+        row[x * 4 + 1] = g;
+        row[x * 4 + 2] = r;
+        row[x * 4 + 3] = 0xFF;
+      }
+    }
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+
+    CMTime pts = CMTimeMake(i, kFps);
+    if (![adaptor appendPixelBuffer:pixelBuffer withPresentationTime:pts]) {
+      CFRelease(pixelBuffer);
+      throw std::runtime_error(
+          std::string("writeTestVideoFile: appendPixelBuffer failed: ") +
+          [[writer.error localizedDescription] UTF8String]);
+    }
+    CFRelease(pixelBuffer);
+  }
+
+  [writerInput markAsFinished];
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+  [writer finishWritingWithCompletionHandler:^{
+    dispatch_semaphore_signal(sem);
+  }];
+  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+
+  if (writer.status != AVAssetWriterStatusCompleted) {
+    throw std::runtime_error(
+        std::string("writeTestVideoFile: writer finished with status ") +
+        std::to_string(static_cast<long>(writer.status)) + ": " +
+        [[writer.error localizedDescription] UTF8String]);
+  }
+
+  return [outputPath UTF8String];
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/ArrayBuffer.h

@@ -1,6 +1,8 @@
 #pragma once
 #include <jsi/jsi.h>
 
+#include <cmath>
+#include <cstdint>
 #include <memory>
 
 #include "JSIConverter.h"
@@ -47,16 +49,58 @@ template <> struct JSIConverter<std::shared_ptr<ArrayBuffer>> {
         if (bufferProp.isObject() &&
             bufferProp.getObject(runtime).isArrayBuffer(runtime)) {
           auto buff = bufferProp.getObject(runtime);
-          auto bytesPerElements =
-              obj.getProperty(runtime, "BYTES_PER_ELEMENT").asNumber();
           auto arrayBuffer = buff.getArrayBuffer(runtime);
-          auto byteOffset = static_cast<size_t>(
-              obj.getProperty(runtime, "byteOffset").asNumber());
-          auto byteLength = static_cast<size_t>(
-              obj.getProperty(runtime, "byteLength").asNumber());
+          const size_t bufferSize = arrayBuffer.size(runtime);
+
+          // byteOffset / byteLength are user-readable JS properties, not values
+          // the engine guarantees (unlike Dawn's node binding, which reads them
+          // off the engine's typed-array view). Read them as doubles so we can
+          // reject negative, non-integral, NaN/Inf, or oversized values before
+          // they wrap around when cast to size_t.
+          const double byteOffsetValue =
+              obj.getProperty(runtime, "byteOffset").asNumber();
+          const double byteLengthValue =
+              obj.getProperty(runtime, "byteLength").asNumber();
+
+          auto isValidByteIndex = [](double value) {
+            return std::isfinite(value) && value >= 0.0 &&
+                   value <= static_cast<double>(SIZE_MAX) &&
+                   std::floor(value) == value;
+          };
+          if (!isValidByteIndex(byteOffsetValue) ||
+              !isValidByteIndex(byteLengthValue)) {
+            throw std::runtime_error(
+                "ArrayBuffer::fromJSI: invalid byteOffset/byteLength");
+          }
+
+          const size_t byteOffset = static_cast<size_t>(byteOffsetValue);
+          const size_t byteLength = static_cast<size_t>(byteLengthValue);
+
+          // Overflow-safe bounds check: byteOffset + byteLength <= bufferSize.
+          if (byteOffset > bufferSize ||
+              byteLength > bufferSize - byteOffset) {
+            throw std::runtime_error(
+                "ArrayBuffer::fromJSI: view bounds [byteOffset, byteOffset + "
+                "byteLength) exceed the backing ArrayBuffer size");
+          }
+
+          // BYTES_PER_ELEMENT is absent on a DataView; default to 1. A spoofed
+          // object could report 0 (or a negative/NaN value), so clamp to a
+          // minimum of 1 to avoid a later division by zero in writeBuffer.
+          size_t bytesPerElements = 1;
+          if (obj.hasProperty(runtime, "BYTES_PER_ELEMENT")) {
+            auto bpe = obj.getProperty(runtime, "BYTES_PER_ELEMENT");
+            if (bpe.isNumber()) {
+              const double value = bpe.asNumber();
+              if (std::isfinite(value) && value >= 1.0) {
+                bytesPerElements = static_cast<size_t>(value);
+              }
+            }
+          }
+
           return std::make_shared<ArrayBuffer>(
               arrayBuffer.data(runtime) + byteOffset, byteLength,
-              static_cast<size_t>(bytesPerElements));
+              bytesPerElements);
         }
       }
     }

package/cpp/rnwgpu/PlatformContext.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <span>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "webgpu/webgpu_cpp.h"
@@ -17,6 +18,53 @@ struct ImageData {
   wgpu::TextureFormat format;
 };
 
+// Pixel layout of a VideoFrame. Determines whether the underlying surface is
+// a single RGBA plane or a biplanar Y / CbCr pair.
+enum class VideoPixelFormat {
+  // Single-plane 8-bit BGRA (default; what RGBA-style sampling expects).
+  BGRA8,
+  // Biplanar 4:2:0 8-bit Y + interleaved CbCr (NV12). Used for the
+  // importExternalTexture path; needs the YUV→RGB conversion matrix below.
+  NV12,
+};
+
+// A native handle to a video frame that can be imported into a
+// GPUSharedTextureMemory.
+//
+//   - handle is an IOSurfaceRef on Apple platforms
+//   - handle is an AHardwareBuffer* on Android
+//
+// The deleter is responsible for releasing the underlying backing object
+// (CVPixelBuffer / AHardwareBuffer) and must be called exactly once. The
+// VideoFrame JS wrapper handles this on destruction.
+struct VideoFrameHandle {
+  void *handle = nullptr;
+  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] = {};
+  std::function<void()> deleter;
+};
+
+// Platform-implemented video source that hands out fresh IOSurface /
+// AHardwareBuffer-backed frames as a video plays.
+class IVideoPlayer {
+public:
+  virtual ~IVideoPlayer() = default;
+
+  // Returns the latest decoded frame, or an empty handle (handle == nullptr)
+  // when no new frame is ready yet. Each non-empty return retains its backing
+  // surface; the VideoFrame wrapper releases it on destruction.
+  virtual VideoFrameHandle copyLatestFrame() = 0;
+
+  virtual void play() = 0;
+  virtual void pause() = 0;
+};
+
 class PlatformContext {
 public:
   PlatformContext() = default;
@@ -41,6 +89,39 @@ public:
   createImageBitmapFromDataAsync(std::span<const uint8_t> data,
                                  std::function<void(ImageData)> onSuccess,
                                  std::function<void(std::string)> onError) = 0;
+
+  // Decode the first video frame of `path` (a local file path) into a
+  // native, GPU-shareable surface. Used by the SharedTextureMemory example;
+  // not intended as a long-term media-loading API.
+  virtual VideoFrameHandle loadVideoFrame(const std::string &path) = 0;
+
+  // 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;
+
+  // Open a video file at `path` for playback. The returned player yields
+  // IOSurface / AHardwareBuffer-backed frames via copyLatestFrame().
+  //
+  // `format` selects the requested pixel layout. BGRA8 is the easiest target
+  // for a regular sampled GPUTexture; NV12 is the right shape for the
+  // importExternalTexture path (zero-copy biplanar YUV).
+  virtual std::unique_ptr<IVideoPlayer>
+  createVideoPlayer(const std::string &path, VideoPixelFormat format) = 0;
+
+  // Wrap a CVPixelBufferRef (Apple) or AHardwareBuffer* (Android) pointer
+  // obtained from another library (typically VisionCamera's
+  // Frame.getNativeBuffer().pointer) as one of our VideoFrame handles.
+  //
+  // We CFRetain / AHardwareBuffer_acquire on the way in, so callers can
+  // safely release their own reference immediately after.
+  virtual VideoFrameHandle wrapNativeBuffer(void *pointer) = 0;
+
+  // Write a small procedurally-generated test video to a temporary location
+  // and return its absolute path. Lets the SharedTextureMemory example play
+  // a real decoded video without bundling an asset.
+  virtual std::string writeTestVideoFile() = 0;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -31,12 +31,15 @@
 #include "GPURenderPassEncoder.h"
 #include "GPURenderPipeline.h"
 #include "GPUSampler.h"
+#include "GPUSharedTextureMemory.h"
 #include "GPUShaderModule.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "GPUTextureView.h"
 #include "GPUUncapturedErrorEvent.h"
 #include "GPUValidationError.h"
+#include "VideoFrame.h"
+#include "VideoPlayer.h"
 
 // Enums
 #include "GPUBufferUsage.h"
@@ -64,6 +67,12 @@ RNWebGPUManager::RNWebGPUManager(
   auto rnWebGPU =
       std::make_shared<RNWebGPU>(gpu, _platformContext, _jsCallInvoker);
   _gpu = gpu->get();
+
+  // RNWebGPU needs its brand registered in NativeObjectRegistry so the boxing
+  // path can install the prototype on worklet runtimes. installConstructor
+  // does that registration but also sets globalThis.RNWebGPU = ctor, so we
+  // call it FIRST and then overwrite the global with the actual instance.
+  RNWebGPU::installConstructor(*_jsRuntime);
   _jsRuntime->global().setProperty(*_jsRuntime, "RNWebGPU",
                                    RNWebGPU::create(*_jsRuntime, rnWebGPU));
 
@@ -97,10 +106,13 @@ RNWebGPUManager::RNWebGPUManager(
   GPURenderPassEncoder::installConstructor(*_jsRuntime);
   GPURenderPipeline::installConstructor(*_jsRuntime);
   GPUSampler::installConstructor(*_jsRuntime);
+  GPUSharedTextureMemory::installConstructor(*_jsRuntime);
   GPUShaderModule::installConstructor(*_jsRuntime);
   GPUSupportedLimits::installConstructor(*_jsRuntime);
   GPUTexture::installConstructor(*_jsRuntime);
   GPUTextureView::installConstructor(*_jsRuntime);
+  VideoFrame::installConstructor(*_jsRuntime);
+  VideoPlayer::installConstructor(*_jsRuntime);
 
   // Install constant objects as plain JS objects with own properties
   _jsRuntime->global().setProperty(*_jsRuntime, "GPUBufferUsage",

package/cpp/rnwgpu/api/Convertors.h

@@ -252,13 +252,24 @@ public:
 
   [[nodiscard]] bool Convert(wgpu::BindGroupLayoutEntry &out,
                              const GPUBindGroupLayoutEntry &in) {
-    return Convert(out.binding, in.binding) &&
-           Convert(out.visibility, in.visibility) &&
-           Convert(out.buffer, in.buffer) && Convert(out.sampler, in.sampler) &&
-           Convert(out.texture, in.texture) &&
-           Convert(out.storageTexture, in.storageTexture);
-    // no external textures here
-    //&& Convert(out.externalTexture, in.externalTexture);
+    out = {};
+    if (!Convert(out.binding, in.binding) ||
+        !Convert(out.visibility, in.visibility) ||
+        !Convert(out.buffer, in.buffer) || !Convert(out.sampler, in.sampler) ||
+        !Convert(out.texture, in.texture) ||
+        !Convert(out.storageTexture, in.storageTexture)) {
+      return false;
+    }
+    if (in.externalTexture.has_value() &&
+        in.externalTexture.value() != nullptr) {
+      // External texture layouts bind via a chained struct rather than a
+      // direct field on BindGroupLayoutEntry. The chained struct must outlive
+      // the BindGroupLayoutEntry until Device::CreateBindGroupLayout returns,
+      // so we allocate it on the Convertor's arena.
+      auto *chain = Allocate<wgpu::ExternalTextureBindingLayout>();
+      out.nextInChain = chain;
+    }
+    return true;
   }
 
   [[nodiscard]] bool Convert(wgpu::BlendComponent &out,
@@ -422,9 +433,11 @@ public:
   }
 
   [[nodiscard]] bool Convert(wgpu::ExternalTextureBindingLayout &out,
-                             const GPUExternalTextureBindingLayout &in) {
-    // no external textures at the moment
-    return false;
+                             const GPUExternalTextureBindingLayout & /*in*/) {
+    // ExternalTextureBindingLayout carries no fields of its own; its presence
+    // (as a chained struct) is what marks the entry as an external texture.
+    out = {};
+    return true;
   }
 
   [[nodiscard]] bool Convert(wgpu::ConstantEntry &out, const std::string &key,
@@ -729,7 +742,16 @@ public:
       out.buffer = buffer->get();
       return true;
     }
-    // Not external textures at the moment
+    if (in.externalTexture != nullptr) {
+      // External textures bind via a chained struct rather than a direct field
+      // on BindGroupEntry. The chained struct must outlive the
+      // BindGroupEntry until Device::CreateBindGroup returns, so we allocate
+      // it on the Convertor's arena.
+      auto *chain = Allocate<wgpu::ExternalTextureBindingEntry>();
+      chain->externalTexture = in.externalTexture->get();
+      out.nextInChain = chain;
+      return true;
+    }
     return false;
   }
 

package/cpp/rnwgpu/api/GPU.cpp

@@ -20,6 +20,33 @@ GPU::GPU(jsi::Runtime &runtime) : NativeObject(CLASS_NAME) {
 
   wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
   instanceDesc.requiredLimits = &limits;
+
+  // Expose Dawn's experimental adapter features. Several features needed by
+  // our Android external-texture path (YCbCrVulkanSamplers,
+  // OpaqueYCbCrAndroidForExternalTexture) are tagged Experimental in Dawn's
+  // feature table and are otherwise filtered out of adapter.features by
+  // PhysicalDeviceBase::GetSupportedFeatures. The allow_unsafe_apis toggle
+  // disables that filter so the features become visible;
+  // expose_wgsl_experimental_features is the parallel toggle for WGSL language
+  // features.
+  //
+  // Trade-off: these are instance-level Dawn toggles, so they apply to every
+  // adapter/device created from this instance, not just the external-texture
+  // path. There is no finer-grained, per-feature mechanism to surface these.
+  // The exposure is acceptable because the toggle only *un-hides* experimental
+  // features in adapter.features; it does not enable any of them. Nothing
+  // experimental becomes active unless application code explicitly lists that
+  // feature in requiredFeatures at device creation, so the default behavior of
+  // a device that asks for no experimental features is unchanged.
+  static const char *const kEnabledToggles[] = {
+      "allow_unsafe_apis",
+      "expose_wgsl_experimental_features",
+  };
+  wgpu::DawnTogglesDescriptor toggles;
+  toggles.enabledToggleCount = std::size(kEnabledToggles);
+  toggles.enabledToggles = kEnabledToggles;
+  instanceDesc.nextInChain = &toggles;
+
   _instance = wgpu::CreateInstance(&instanceDesc);
 
   auto dispatcher = std::make_shared<async::JSIMicrotaskDispatcher>(runtime);