react-native-webgpu 0.10.5 → 0.11.1

package/apple/ApplePlatformContext.h

@@ -1,15 +1,25 @@
 #pragma once
 
 #include "PlatformContext.h"
+#include <functional>
 #include <string>
 
 namespace rnwgpu {
 
 class ApplePlatformContext : public PlatformContext {
 public:
-  ApplePlatformContext();
+  // Resolves a React tag to its native view (an unretained
+  // UIView* / NSView* bridged to void*, or nullptr). Called on the main thread
+  // only. Provided by WebGPUModule from React Native's view registry.
+  using ViewLookup = std::function<void *(int)>;
+
+  explicit ApplePlatformContext(ViewLookup viewLookup = nullptr);
   ~ApplePlatformContext() = default;
 
+  void snapshotView(const ViewSnapshotRequest &request,
+                    std::function<void(ImageData)> onSuccess,
+                    std::function<void(std::string)> onError) override;
+
   wgpu::Surface makeSurface(wgpu::Instance instance, void *surface, int width,
                             int height) override;
 
@@ -39,6 +49,9 @@ public:
   std::string writeTestVideoFile() override;
 
   VideoFrameHandle wrapNativeBuffer(void *pointer) override;
+
+private:
+  ViewLookup _viewLookup;
 };
 
 } // namespace rnwgpu

package/apple/ApplePlatformContext.mm

@@ -10,10 +10,15 @@
 #import <ReactCommon/RCTTurboModule.h>
 
 #include "AppleVideoPlayer.h"
+#import "RNWGUIKit.h"
 
 #include "RNWebGPUManager.h"
 #include "WebGPUModule.h"
 
+#include <cmath>
+#include <string>
+#include <utility>
+
 namespace rnwgpu {
 
 void checkIfUsingSimulatorWithAPIValidation() {
@@ -30,10 +35,180 @@ void checkIfUsingSimulatorWithAPIValidation() {
 #endif
 }
 
-ApplePlatformContext::ApplePlatformContext() {
+ApplePlatformContext::ApplePlatformContext(ViewLookup viewLookup)
+    : _viewLookup(std::move(viewLookup)) {
   checkIfUsingSimulatorWithAPIValidation();
 }
 
+namespace {
+
+// Rasterize `request` on the main thread into tightly packed, premultiplied
+// BGRA8 pixels. Throws std::runtime_error with a user-facing message.
+ImageData snapshotViewOnMainThread(const ApplePlatformContext::ViewLookup &lookup,
+                                   const ViewSnapshotRequest &request) {
+  if (!lookup) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: no view registry is available");
+  }
+  RNWGPlatformView *view = (__bridge RNWGPlatformView *)lookup(request.viewTag);
+  if (view == nil) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: no native view found for tag " +
+        std::to_string(request.viewTag) +
+        " (is the view mounted, and rendered with collapsable={false}?)");
+  }
+  const CGRect bounds = view.bounds;
+  if (bounds.size.width <= 0 || bounds.size.height <= 0) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view has no size yet");
+  }
+
+  // Source rectangle in points (view space); the whole view by default.
+  const double sourceX = request.sourceX;
+  const double sourceY = request.sourceY;
+  const double sourceWidth =
+      request.sourceWidth > 0 ? request.sourceWidth : bounds.size.width;
+  const double sourceHeight =
+      request.sourceHeight > 0 ? request.sourceHeight : bounds.size.height;
+
+  // Natural pixel size: points times the screen scale the view is shown at.
+#if !TARGET_OS_OSX
+  CGFloat scale = view.window.screen.scale;
+  if (scale <= 0) {
+    scale = UIScreen.mainScreen.scale;
+  }
+#else
+  CGFloat scale = view.window.backingScaleFactor;
+  if (scale <= 0) {
+    scale = NSScreen.mainScreen.backingScaleFactor;
+  }
+#endif
+  const uint32_t width =
+      request.width > 0
+          ? request.width
+          : static_cast<uint32_t>(std::llround(sourceWidth * scale));
+  const uint32_t height =
+      request.height > 0
+          ? request.height
+          : static_cast<uint32_t>(std::llround(sourceHeight * scale));
+  if (width == 0 || height == 0) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the source rectangle is empty");
+  }
+
+  // The view's bounds are drawn scaled so that the source rectangle covers
+  // the whole output.
+  const CGFloat scaleX = static_cast<CGFloat>(width) / sourceWidth;
+  const CGFloat scaleY = static_cast<CGFloat>(height) / sourceHeight;
+  const CGRect drawRect =
+      CGRectMake(-sourceX * scaleX, -sourceY * scaleY,
+                 bounds.size.width * scaleX, bounds.size.height * scaleY);
+
+  CGImageRef cgImage = NULL;
+#if !TARGET_OS_OSX
+  // drawViewHierarchyInRect renders what is on screen (including Metal /
+  // CAMetalLayer content), which is what "the element as displayed" means.
+  // afterScreenUpdates:YES flushes pending layout and layer changes first, so
+  // a snapshot taken right after a state change reflects that change.
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.scale = 1.0;
+  format.opaque = NO;
+  format.preferredRange = UIGraphicsImageRendererFormatRangeStandard;
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc]
+      initWithSize:CGSizeMake(width, height)
+            format:format];
+  // drawViewHierarchyInRect returns NO and draws nothing when the view is not
+  // in a window (e.g. a screen pushed under another one). The image would
+  // then be fully transparent, so treat it as a failure instead.
+  __block BOOL drawn = NO;
+  UIImage *image = [renderer
+      imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull context) {
+        drawn = [view drawViewHierarchyInRect:drawRect afterScreenUpdates:YES];
+      }];
+  if (!drawn) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view could not be rendered (is it "
+        "attached to a window?)");
+  }
+  cgImage = image.CGImage;
+  if (cgImage != NULL) {
+    CGImageRetain(cgImage);
+  }
+#else
+  NSBitmapImageRep *rep = [view bitmapImageRepForCachingDisplayInRect:bounds];
+  if (rep != nil) {
+    [view cacheDisplayInRect:bounds toBitmapImageRep:rep];
+    cgImage = rep.CGImage;
+    if (cgImage != NULL) {
+      CGImageRetain(cgImage);
+    }
+  }
+#endif
+  if (cgImage == NULL) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view could not be rendered");
+  }
+
+  // Normalize into premultiplied BGRA8 with no row padding, whatever the
+  // renderer produced.
+  ImageData result;
+  result.width = width;
+  result.height = height;
+  result.format = wgpu::TextureFormat::BGRA8Unorm;
+  result.premultiplied = true;
+  result.data.assign(static_cast<size_t>(width) * height * 4, 0);
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      result.data.data(), width, height, 8, static_cast<size_t>(width) * 4,
+      colorSpace, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
+  CGColorSpaceRelease(colorSpace);
+  if (context == NULL) {
+    CGImageRelease(cgImage);
+    throw std::runtime_error(
+        "drawElementImageToTexture: could not allocate the pixel buffer");
+  }
+#if !TARGET_OS_OSX
+  // The renderer already produced exactly width x height pixels.
+  const CGRect imageRect = CGRectMake(0, 0, width, height);
+#else
+  // The cached display covers the whole view at the backing scale; draw it so
+  // that the source rectangle fills the output. CoreGraphics' origin is the
+  // bottom-left corner, hence the flipped vertical offset.
+  const CGRect imageRect = CGRectMake(
+      -sourceX * scaleX,
+      -(bounds.size.height - sourceY - sourceHeight) * scaleY,
+      bounds.size.width * scaleX, bounds.size.height * scaleY);
+#endif
+  CGContextSetBlendMode(context, kCGBlendModeCopy);
+  CGContextDrawImage(context, imageRect, cgImage);
+  CGContextRelease(context);
+  CGImageRelease(cgImage);
+  return result;
+}
+
+} // namespace
+
+void ApplePlatformContext::snapshotView(
+    const ViewSnapshotRequest &request,
+    std::function<void(ImageData)> onSuccess,
+    std::function<void(std::string)> onError) {
+  // Copies: the block outlives this call.
+  ViewLookup lookup = _viewLookup;
+  ViewSnapshotRequest snapshotRequest = request;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @autoreleasepool {
+      try {
+        onSuccess(snapshotViewOnMainThread(lookup, snapshotRequest));
+      } catch (const std::exception &error) {
+        onError(error.what());
+      } catch (...) {
+        onError("drawElementImageToTexture: unknown native error");
+      }
+    }
+  });
+}
+
 wgpu::Surface ApplePlatformContext::makeSurface(wgpu::Instance instance,
                                                 void *surface, int width,
                                                 int height) {

package/apple/AppleVideoPlayer.mm

@@ -3,6 +3,9 @@
 #import <AVFoundation/AVFoundation.h>
 #import <CoreVideo/CoreVideo.h>
 
+#include <algorithm>
+#include <atomic>
+#include <memory>
 #include <stdexcept>
 
 namespace rnwgpu {
@@ -16,27 +19,27 @@ namespace {
 // 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, //
+    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, //
+    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, //
+    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);
+  CFTypeRef matrixKey =
+      CVBufferGetAttachment(pixelBuffer, kCVImageBufferYCbCrMatrixKey, nullptr);
   const float *src = kBT709LimitedToRgb;
   if (matrixKey) {
     auto matrix = (CFStringRef)matrixKey;
@@ -53,28 +56,108 @@ static void fillYuvMatrix(CVPixelBufferRef pixelBuffer, float out[12]) {
 }
 
 // Map a CVPixelBuffer's pixel format to our VideoPixelFormat enum.
-static VideoPixelFormat pixelFormatFromCVPixelBuffer(
-    CVPixelBufferRef pixelBuffer) {
+static VideoPixelFormat
+pixelFormatFromCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
   OSType type = CVPixelBufferGetPixelFormatType(pixelBuffer);
   switch (type) {
-    case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
-    case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
-      return VideoPixelFormat::NV12;
-    default:
-      return VideoPixelFormat::BGRA8;
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+    return VideoPixelFormat::NV12;
+  default:
+    return VideoPixelFormat::BGRA8;
   }
 }
 
+// The clockwise rotation, in degrees, that a track's preferredTransform
+// applies to its frames: a video recorded in portrait stores landscape frames
+// with a 90 or 270 degree transform.
+static int rotationFromTransform(CGAffineTransform t) {
+  if (t.a == 0 && t.b == 1 && t.c == -1 && t.d == 0) {
+    return 90;
+  }
+  if (t.a == 0 && t.b == -1 && t.c == 1 && t.d == 0) {
+    return 270;
+  }
+  if (t.a == -1 && t.b == 0 && t.c == 0 && t.d == -1) {
+    return 180;
+  }
+  return 0;
+}
+
+// The state the AVFoundation callbacks update. It is shared with the blocks
+// observing the asset and the item, so a callback that fires after the player
+// was destroyed only touches memory that outlives it.
+struct AppleVideoPlayerState {
+  std::atomic<bool> playing{false};
+  std::atomic<bool> loop{true};
+  std::atomic<double> duration{0};
+  std::atomic<double> frameRate{0};
+  std::atomic<uint32_t> width{0};
+  std::atomic<uint32_t> height{0};
+  std::atomic<int> rotation{0};
+};
+
 class AppleVideoPlayer : public IVideoPlayer {
 public:
-  AppleVideoPlayer(AVPlayer *player, AVPlayerItemVideoOutput *output,
-                   id loopObserver)
-      : _player(player), _output(output), _loopObserver(loopObserver) {}
+  AppleVideoPlayer(AVPlayer *player, AVPlayerItem *item,
+                   AVPlayerItemVideoOutput *output)
+      : _player(player), _output(output),
+        _state(std::make_shared<AppleVideoPlayerState>()) {
+    auto state = _state;
+
+    // The metadata loads asynchronously, so that a remote asset never blocks
+    // the calling thread; the getters report 0 until it has.
+    AVAsset *asset = item.asset;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    [asset
+        loadValuesAsynchronouslyForKeys:@[ @"duration", @"tracks" ]
+                      completionHandler:^{
+                        if ([asset statusOfValueForKey:@"duration" error:nil] ==
+                            AVKeyValueStatusLoaded) {
+                          CMTime duration = asset.duration;
+                          if (CMTIME_IS_NUMERIC(duration)) {
+                            state->duration = CMTimeGetSeconds(duration);
+                          }
+                        }
+                        if ([asset statusOfValueForKey:@"tracks" error:nil] ==
+                            AVKeyValueStatusLoaded) {
+                          AVAssetTrack *track =
+                              [[asset tracksWithMediaType:AVMediaTypeVideo]
+                                  firstObject];
+                          if (track) {
+                            CGSize size = track.naturalSize;
+                            state->width = static_cast<uint32_t>(size.width);
+                            state->height = static_cast<uint32_t>(size.height);
+                            state->rotation =
+                                rotationFromTransform(track.preferredTransform);
+                            state->frameRate = track.nominalFrameRate;
+                          }
+                        }
+                      }];
+#pragma clang diagnostic pop
+
+    // At the end of the stream, either loop or stop. The player keeps showing
+    // the last frame either way (actionAtItemEnd is None).
+    __weak AVPlayer *weakPlayer = player;
+    _endObserver = [[NSNotificationCenter defaultCenter]
+        addObserverForName:AVPlayerItemDidPlayToEndTimeNotification
+                    object:item
+                     queue:[NSOperationQueue mainQueue]
+                usingBlock:^(NSNotification * /*note*/) {
+                  if (state->loop) {
+                    [weakPlayer seekToTime:kCMTimeZero];
+                    [weakPlayer play];
+                  } else {
+                    state->playing = false;
+                  }
+                }];
+  }
 
   ~AppleVideoPlayer() override {
-    if (_loopObserver) {
-      [[NSNotificationCenter defaultCenter] removeObserver:_loopObserver];
-      _loopObserver = nil;
+    if (_endObserver) {
+      [[NSNotificationCenter defaultCenter] removeObserver:_endObserver];
+      _endObserver = nil;
     }
     [_player pause];
     _player = nil;
@@ -105,13 +188,51 @@ public:
     }
   }
 
-  void play() override { [_player play]; }
-  void pause() override { [_player pause]; }
+  void play() override {
+    _state->playing = true;
+    [_player play];
+  }
+
+  void pause() override {
+    _state->playing = false;
+    [_player pause];
+  }
+
+  bool paused() override { return !_state->playing; }
+
+  double currentTime() override {
+    CMTime time = [_player currentTime];
+    return CMTIME_IS_NUMERIC(time) ? CMTimeGetSeconds(time) : 0;
+  }
+
+  // An exact seek: the output then holds the frame at that position, also
+  // while paused, so the next copyLatestFrame() returns it.
+  void seek(double seconds) override {
+    [_player seekToTime:CMTimeMakeWithSeconds(seconds, NSEC_PER_SEC)
+        toleranceBefore:kCMTimeZero
+         toleranceAfter:kCMTimeZero];
+  }
+
+  double duration() override { return _state->duration; }
+
+  double volume() override { return _player.volume; }
+  void setVolume(double volume) override {
+    _player.volume = static_cast<float>(std::clamp(volume, 0.0, 1.0));
+  }
+
+  bool loop() override { return _state->loop; }
+  void setLoop(bool loop) override { _state->loop = loop; }
+
+  uint32_t videoWidth() override { return _state->width; }
+  uint32_t videoHeight() override { return _state->height; }
+  int rotation() override { return _state->rotation; }
+  double frameRate() override { return _state->frameRate; }
 
 private:
   AVPlayer *_player;
   AVPlayerItemVideoOutput *_output;
-  id _loopObserver;
+  std::shared_ptr<AppleVideoPlayerState> _state;
+  id _endObserver = nil;
 };
 
 } // namespace
@@ -142,8 +263,8 @@ VideoFrameHandle wrapCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
   return handle;
 }
 
-std::unique_ptr<IVideoPlayer>
-createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
+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://"] ||
@@ -164,8 +285,8 @@ createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
   // importExternalTexture. BGRA is the "decode + convert" path for the
   // single-plane SharedTextureMemory demo.
   OSType pixelFormat = format == VideoPixelFormat::NV12
-                          ? kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
-                          : kCVPixelFormatType_32BGRA;
+                           ? kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+                           : kCVPixelFormatType_32BGRA;
   NSDictionary *outputSettings = @{
     (NSString *)kCVPixelBufferPixelFormatTypeKey : @(pixelFormat),
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
@@ -176,20 +297,11 @@ createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
   [item addOutput:output];
 
   AVPlayer *player = [AVPlayer playerWithPlayerItem:item];
+  // Keep the last frame at the end of the stream; AppleVideoPlayer decides
+  // whether to loop.
   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);
+  return std::make_unique<AppleVideoPlayer>(player, item, output);
 }
 
 std::string writeAppleTestVideoFile() {
@@ -231,8 +343,7 @@ std::string writeAppleTestVideoFile() {
   writerInput.expectsMediaDataInRealTime = NO;
 
   NSDictionary *bufferAttrs = @{
-    (NSString *)kCVPixelBufferPixelFormatTypeKey :
-        @(kCVPixelFormatType_32BGRA),
+    (NSString *)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
     (NSString *)kCVPixelBufferWidthKey : @(kWidth),
     (NSString *)kCVPixelBufferHeightKey : @(kHeight),
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
@@ -274,8 +385,7 @@ std::string writeAppleTestVideoFile() {
       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);
+        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;

package/apple/WebGPUModule.mm

@@ -1,6 +1,7 @@
 #import "WebGPUModule.h"
 #include "ApplePlatformContext.h"
 #import "GPUCanvasContext.h"
+#import "RNWGUIKit.h"
 
 #import <React/RCTBridge+Private.h>
 #import <React/RCTCallInvoker.h>
@@ -31,6 +32,11 @@ static std::shared_ptr<rnwgpu::RNWebGPUManager> webgpuManager;
 // calls setCallInvoker: during module initialization.
 @synthesize callInvoker = _callInvoker;
 
+// Synthesize the view registry so the TurboModule infra injects it too. It
+// resolves React tags to native views in both Bridge and Bridgeless mode
+// (Fabric component views included), which drawElementImageToTexture needs.
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
 + (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
   return webgpuManager;
 }
@@ -74,8 +80,21 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     return [NSNumber numberWithBool:NO];
   }
 
+  // Main-thread only (see ApplePlatformContext::ViewLookup). Weak: the module
+  // is invalidated on reload, after which lookups simply fail.
+  __weak WebGPUModule *weakSelf = self;
+  rnwgpu::ApplePlatformContext::ViewLookup viewLookup =
+      [weakSelf](int tag) -> void * {
+    WebGPUModule *strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return nullptr;
+    }
+    RNWGPlatformView *view =
+        [strongSelf.viewRegistry_DEPRECATED viewForReactTag:@(tag)];
+    return (__bridge void *)view;
+  };
   std::shared_ptr<rnwgpu::PlatformContext> platformContext =
-      std::make_shared<rnwgpu::ApplePlatformContext>();
+      std::make_shared<rnwgpu::ApplePlatformContext>(std::move(viewLookup));
   webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
                                                             platformContext);
   return @true;

package/cpp/rnwgpu/PlatformContext.h

@@ -2,6 +2,7 @@
 
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <span>
 #include <string>
 #include <utility>
@@ -58,7 +59,8 @@ struct VideoFrameHandle {
 };
 
 // Platform-implemented video source that hands out fresh IOSurface /
-// AHardwareBuffer-backed frames as a video plays.
+// AHardwareBuffer-backed frames as a video plays, with the playback controls
+// of an HTMLMediaElement (times in seconds).
 class IVideoPlayer {
 public:
   virtual ~IVideoPlayer() = default;
@@ -70,6 +72,44 @@ public:
 
   virtual void play() = 0;
   virtual void pause() = 0;
+  virtual bool paused() = 0;
+
+  // Playback position and length, in seconds. The duration is 0 until the
+  // metadata of the media has loaded.
+  virtual double currentTime() = 0;
+  virtual void seek(double seconds) = 0;
+  virtual double duration() = 0;
+
+  virtual double volume() = 0;
+  virtual void setVolume(double volume) = 0;
+  virtual bool loop() = 0;
+  virtual void setLoop(bool loop) = 0;
+
+  // The geometry of the frames, 0 until the metadata has loaded: their coded
+  // size, the clockwise rotation (0, 90, 180 or 270) to apply when displaying
+  // them, and the nominal frame rate of the video track.
+  virtual uint32_t videoWidth() = 0;
+  virtual uint32_t videoHeight() = 0;
+  virtual int rotation() = 0;
+  virtual double frameRate() = 0;
+};
+
+// A request to rasterize a native React Native view (looked up by its React
+// tag) for GPUQueue.drawElementImageToTexture.
+//
+// The source rectangle is expressed in the view's own coordinate space, in
+// density-independent points (the units of React Native layout). A
+// non-positive sourceWidth/sourceHeight means "the whole view". The
+// destination size is in pixels: the platform rasterizes the source rectangle
+// scaled to exactly width x height.
+struct ViewSnapshotRequest {
+  int viewTag = 0;
+  double sourceX = 0;
+  double sourceY = 0;
+  double sourceWidth = 0;
+  double sourceHeight = 0;
+  uint32_t width = 0;
+  uint32_t height = 0;
 };
 
 class PlatformContext {
@@ -77,6 +117,31 @@ public:
   PlatformContext() = default;
   virtual ~PlatformContext() = default;
 
+  // The platform context of the currently installed RNWebGPUManager, for API
+  // objects (e.g. GPUQueue) that are created without a reference to it. Set on
+  // install, cleared on teardown; a dev reload replaces it.
+  static void setCurrent(std::shared_ptr<PlatformContext> context) {
+    std::lock_guard<std::mutex> lock(currentMutex());
+    currentSlot() = std::move(context);
+  }
+  static std::shared_ptr<PlatformContext> current() {
+    std::lock_guard<std::mutex> lock(currentMutex());
+    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
+  // (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.
+  virtual void snapshotView(const ViewSnapshotRequest &request,
+                            std::function<void(ImageData)> onSuccess,
+                            std::function<void(std::string)> onError) = 0;
+
   virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
                                     int width, int height) = 0;
   virtual ImageData createImageBitmap(std::string blobId, double offset,
@@ -129,6 +194,16 @@ public:
   // and return its absolute path. Lets the SharedTextureMemory example play
   // a real decoded video without bundling an asset.
   virtual std::string writeTestVideoFile() = 0;
+
+private:
+  static std::mutex &currentMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+  static std::shared_ptr<PlatformContext> &currentSlot() {
+    static std::shared_ptr<PlatformContext> slot;
+    return slot;
+  }
 };
 
 } // namespace rnwgpu