react-native-webgpu 0.15.0 → 0.15.2

package/android/cpp/cpp-adapter.cpp

@@ -156,9 +156,58 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceChanged(
   }
 }
 
+namespace {
+
+// Weak handle on a Java view and one of its no-argument methods, for native
+// threads to call into it: the fence waiter wakes a WebGPUHardwareBufferView
+// when a frame is ready, the presenting thread reports each frame a
+// SurfaceView shows. Holding the view weakly means a view that RN has dropped
+// is not kept alive by a SurfaceInfo that outlives it (the registry keeps the
+// SurfaceInfo until onDropViewInstance).
+struct WeakViewCall {
+  jweak view = nullptr;
+  jmethodID method = nullptr;
+
+  WeakViewCall(JNIEnv *env, jobject thiz, const char *methodName) {
+    view = env->NewWeakGlobalRef(thiz);
+    jclass cls = env->GetObjectClass(thiz);
+    method = env->GetMethodID(cls, methodName, "()V");
+    env->DeleteLocalRef(cls);
+  }
+
+  ~WeakViewCall() {
+    // May run on any thread; ThreadScope attaches if needed.
+    facebook::jni::ThreadScope scope;
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (env != nullptr && view != nullptr) {
+      env->DeleteWeakGlobalRef(view);
+    }
+  }
+
+  // Called on a native thread, outside the SurfaceInfo locks.
+  void operator()() const {
+    facebook::jni::ThreadScope scope;
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (env == nullptr || method == nullptr) {
+      return;
+    }
+    jobject local = env->NewLocalRef(view);
+    if (local == nullptr) {
+      return; // the view was garbage collected
+    }
+    env->CallVoidMethod(local, method);
+    if (env->ExceptionCheck()) {
+      env->ExceptionClear();
+    }
+    env->DeleteLocalRef(local);
+  }
+};
+
+} // namespace
+
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
-    jfloat height) {
+    jfloat height, jboolean reportPresents) {
   if (manager == nullptr) {
     return;
   }
@@ -179,6 +228,15 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
       surface, [](void *nativeSurface) {
         ANativeWindow_release(static_cast<ANativeWindow *>(nativeSurface));
       });
+  // A SurfaceView asks to hear about each presented frame, for its refresh
+  // rate vote (WebGPUView.onFramePresented).
+  if (reportPresents) {
+    auto reporter =
+        std::make_shared<WeakViewCall>(env, thiz, "onFramePresented");
+    info->setFramePresentedCallback([reporter]() { (*reporter)(); });
+  } else {
+    info->setFramePresentedCallback(nullptr);
+  }
   // The attach is adopted at the next frame boundary by the rendering thread;
   // schedule a flush so contexts that are not currently rendering still pick
   // it up (and present their last offscreen frame).
@@ -190,6 +248,7 @@ Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->setFramePresentedCallback(nullptr);
     info->switchToOffscreen();
   }
 }
@@ -202,6 +261,7 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
   // surface; see RNWebGPU::destroyContext for the ownership split.
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->setFramePresentedCallback(nullptr);
     info->detachSurface();
   }
   registry.removeSurfaceInfo(contextId);
@@ -210,53 +270,6 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
 // --- WebGPUHardwareBufferView (AHB-pool presentation)
 // ---------------------------------
 
-namespace {
-
-// Weak handle on a WebGPUHardwareBufferView used by the native fence waiter to
-// wake the UI thread when a frame is ready. Holding it weakly means a view that
-// RN has dropped is not kept alive by a SurfaceInfo that outlives it (the
-// registry keeps the SurfaceInfo until onDropViewInstance).
-struct HardwareBufferViewWaker {
-  jweak view = nullptr;
-  jmethodID onFrameReady = nullptr;
-
-  HardwareBufferViewWaker(JNIEnv *env, jobject thiz) {
-    view = env->NewWeakGlobalRef(thiz);
-    jclass cls = env->GetObjectClass(thiz);
-    onFrameReady = env->GetMethodID(cls, "onNativeFrameReady", "()V");
-    env->DeleteLocalRef(cls);
-  }
-
-  ~HardwareBufferViewWaker() {
-    // May run on the waiter or JS thread; ThreadScope attaches if needed.
-    facebook::jni::ThreadScope scope;
-    JNIEnv *env = facebook::jni::Environment::current();
-    if (env != nullptr && view != nullptr) {
-      env->DeleteWeakGlobalRef(view);
-    }
-  }
-
-  // Called on the waiter thread, outside the pool lock.
-  void operator()() const {
-    facebook::jni::ThreadScope scope;
-    JNIEnv *env = facebook::jni::Environment::current();
-    if (env == nullptr || onFrameReady == nullptr) {
-      return;
-    }
-    jobject local = env->NewLocalRef(view);
-    if (local == nullptr) {
-      return; // the view was garbage collected
-    }
-    env->CallVoidMethod(local, onFrameReady);
-    if (env->ExceptionCheck()) {
-      env->ExceptionClear();
-    }
-    env->DeleteLocalRef(local);
-  }
-};
-
-} // namespace
-
 // Turn on pool mode for this context. dpW/dpH is the canvas-client (dp) size;
 // the native pool buffers are sized from the canvas drawing buffer lazily.
 extern "C" JNIEXPORT void JNICALL
@@ -267,7 +280,7 @@ Java_com_webgpu_WebGPUHardwareBufferView_nEnablePool(JNIEnv *env, jobject thiz,
   auto info = registry.getSurfaceInfoOrCreate(
       contextId, rnwgpu::WebGPURuntime::shared().instance(),
       static_cast<int>(dpW), static_cast<int>(dpH));
-  auto waker = std::make_shared<HardwareBufferViewWaker>(env, thiz);
+  auto waker = std::make_shared<WeakViewCall>(env, thiz, "onNativeFrameReady");
   info->setPoolFrameReadyCallback([waker]() { (*waker)(); });
   info->enablePool(static_cast<int>(dpW), static_cast<int>(dpH));
 }

package/android/src/main/java/com/webgpu/SurfaceFrameRateVote.java

@@ -0,0 +1,184 @@
+package com.webgpu;
+
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.Display;
+import android.view.Surface;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Votes the display's refresh rate for a SurfaceView canvas while it animates.
+ *
+ * A SurfaceView is composited in a layer of its own, outside the window that
+ * votes for the app's views, so SurfaceFlinger picks the layer's refresh rate
+ * from its present history alone: a canvas drawing every frame on a display
+ * idling at 60 Hz looks like 60 Hz content and never gets more. Since Android
+ * 11 a layer can say what it wants with Surface.setFrameRate. Once the canvas
+ * presents frames back to back, this asks for the highest rate the display can
+ * switch to seamlessly, as the window does for its own views, and takes the
+ * vote back once the animation stops, whether the canvas stops drawing or
+ * drops back to a few redraws a second: a layer with a vote counts as active
+ * for SurfaceFlinger even when it no longer draws.
+ *
+ * attach() and detach() run on the main thread with the surface callbacks;
+ * onFramePresented() runs on whichever thread presents (the JS thread, the
+ * Reanimated UI runtime or a worklet runtime), so the state is locked.
+ */
+final class SurfaceFrameRateVote {
+  private static final String TAG = "SurfaceFrameRateVote";
+
+  // Presents this close together are an animation (faster than 40 fps). The
+  // threshold is absolute rather than relative to the current refresh rate,
+  // so that a canvas that only manages 60 fps at 120 Hz keeps its vote rather
+  // than oscillating between the two rates. A canvas that redraws a few times
+  // a second never votes.
+  private static final long ANIMATING_INTERVAL_NANOS = 25_000_000L;
+
+  // The vote is taken back once the canvas has not animated (no two presents
+  // within ANIMATING_INTERVAL_NANOS) for this long. Measured from the last
+  // back-to-back present rather than the last present, so that a canvas that
+  // slows down to a few redraws a second lets the vote lapse like one that
+  // stops drawing.
+  private static final long IDLE_AFTER_NANOS = 500_000_000L;
+
+  private final View mView;
+  private final Handler mHandler = new Handler(Looper.getMainLooper());
+  private final Runnable mIdleCheck = this::checkIdle;
+
+  @Nullable
+  private Surface mSurface;
+  private boolean mVoting = false;
+  private boolean mIdleCheckPending = false;
+  // 0 before the first present on the surface.
+  private long mLastPresentNanos = 0;
+  // The last present that followed its predecessor within
+  // ANIMATING_INTERVAL_NANOS; 0 until the first.
+  private long mLastAnimatingNanos = 0;
+
+  /** The view the surface belongs to; its display decides the rate to ask for. */
+  SurfaceFrameRateVote(View view) {
+    mView = view;
+  }
+
+  /** The surface was created: it is voted on until detach(). Main thread. */
+  synchronized void attach(Surface surface) {
+    detach();
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+      return;
+    }
+    mSurface = surface;
+  }
+
+  /** A frame was presented on the surface. Any thread. */
+  synchronized void onFramePresented() {
+    if (mSurface == null) {
+      return;
+    }
+    long now = System.nanoTime();
+    boolean animating = mLastPresentNanos != 0 && now - mLastPresentNanos <= ANIMATING_INTERVAL_NANOS;
+    mLastPresentNanos = now;
+    if (animating) {
+      mLastAnimatingNanos = now;
+      if (!mVoting) {
+        vote();
+      }
+    }
+    if (mVoting && !mIdleCheckPending) {
+      scheduleIdleCheck(IDLE_AFTER_NANOS);
+    }
+  }
+
+  /** The surface is going away (it is still valid here) or the view left its window. Main thread. */
+  synchronized void detach() {
+    if (mSurface == null) {
+      return;
+    }
+    withdraw();
+    mHandler.removeCallbacks(mIdleCheck);
+    mIdleCheckPending = false;
+    mLastPresentNanos = 0;
+    mLastAnimatingNanos = 0;
+    mSurface = null;
+  }
+
+  private void vote() {
+    float refreshRate = resolveMaxRefreshRate();
+    if (refreshRate <= 0 || !mSurface.isValid()) {
+      return;
+    }
+    try {
+      // This form only switches when the display can do so seamlessly, like
+      // the vote the window casts for its own views: a canvas animation is
+      // not worth a blank screen. Surface.setFrameRate is thread-safe.
+      mSurface.setFrameRate(refreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+      mVoting = true;
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not vote the refresh rate, leaving it to the display", e);
+      detach();
+    }
+  }
+
+  private void withdraw() {
+    if (!mVoting) {
+      return;
+    }
+    mVoting = false;
+    if (mSurface == null || !mSurface.isValid()) {
+      return;
+    }
+    try {
+      mSurface.setFrameRate(0, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not withdraw the refresh rate vote", e);
+    }
+  }
+
+  private void scheduleIdleCheck(long delayNanos) {
+    mIdleCheckPending = true;
+    mHandler.postDelayed(mIdleCheck, (delayNanos + 999_999) / 1_000_000);
+  }
+
+  private synchronized void checkIdle() {
+    mIdleCheckPending = false;
+    if (!mVoting) {
+      return;
+    }
+    long idleNanos = System.nanoTime() - mLastAnimatingNanos;
+    if (idleNanos >= IDLE_AFTER_NANOS) {
+      withdraw();
+    } else {
+      scheduleIdleCheck(IDLE_AFTER_NANOS - idleNanos);
+    }
+  }
+
+  // The highest rate a seamless switch from the current mode can reach, which
+  // is all the vote may ask for. Resolved when the vote is cast, so that it
+  // follows the display the view is on.
+  private float resolveMaxRefreshRate() {
+    Display display = mView.getDisplay();
+    if (display == null) {
+      return 0f;
+    }
+    Display.Mode current = display.getMode();
+    float maxRefreshRate = current.getRefreshRate();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      for (float refreshRate : current.getAlternativeRefreshRates()) {
+        maxRefreshRate = Math.max(maxRefreshRate, refreshRate);
+      }
+    } else {
+      // Android 11 does not tell which modes are a seamless switch away: the
+      // ones at the current resolution usually are.
+      for (Display.Mode mode : display.getSupportedModes()) {
+        if (mode.getPhysicalWidth() == current.getPhysicalWidth()
+            && mode.getPhysicalHeight() == current.getPhysicalHeight()) {
+          maxRefreshRate = Math.max(maxRefreshRate, mode.getRefreshRate());
+        }
+      }
+    }
+    return maxRefreshRate;
+  }
+}

package/android/src/main/java/com/webgpu/WebGPUView.java

@@ -24,6 +24,9 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   private boolean mAppliedZOrderOnTop;
   private WebGPUModule mModule;
   private View mView = null;
+  // Only a SurfaceView votes: a TextureView or HardwareBufferView is
+  // composited into the window, which votes for it.
+  private final SurfaceFrameRateVote mFrameRateVote = new SurfaceFrameRateVote(this);
 
   WebGPUView(Context context) {
     super(context);
@@ -134,7 +137,11 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     float density = getResources().getDisplayMetrics().density;
     float width = getWidth() / density;
     float height = getHeight() / density;
-    onSurfaceCreate(surface, mContextId, width, height);
+    boolean votesFrameRate = mAppliedKind == KIND_SURFACE_VIEW;
+    if (votesFrameRate) {
+      mFrameRateVote.attach(surface);
+    }
+    onSurfaceCreate(surface, mContextId, width, height, votesFrameRate);
   }
 
   @Override
@@ -147,9 +154,20 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
 
   @Override
   public void surfaceOffscreen() {
+    // The surface is still valid here, so the vote can be taken back.
+    mFrameRateVote.detach();
     switchToOffscreenSurface(mContextId);
   }
 
+  /**
+   * Called from native (SurfaceInfo::presentFrame) on the thread that
+   * presented a frame to the surface, only for a SurfaceView.
+   */
+  @DoNotStrip
+  void onFramePresented() {
+    mFrameRateVote.onFramePresented();
+  }
+
   @Override
   public int getContextId() {
     return mContextId;
@@ -160,15 +178,19 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
    * view: the view dies with its Canvas, so it retires the registry entry.
    */
   public void destroy() {
+    mFrameRateVote.detach();
     onViewDestroyed(mContextId);
   }
 
+  // reportPresents asks native to call onFramePresented() for each frame
+  // presented to this surface.
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
     int contextId,
     float width,
-    float height
+    float height,
+    boolean reportPresents
   );
 
   @DoNotStrip

package/apple/ApplePlatformContext.mm

@@ -42,159 +42,279 @@ ApplePlatformContext::ApplePlatformContext(ViewLookup viewLookup)
 
 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) {
+// A view that UIKit declined to render (it is not in a window). The pixel
+// path would fail the same way, so there is no point falling back to it.
+struct ViewNotRenderable : std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+// The view, the output size and the rectangle to draw it in, resolved from a
+// request on the main thread. Throws std::runtime_error with a user-facing
+// message.
+struct ResolvedSnapshot {
+  RNWGPlatformView *view = nil;
+  CGRect bounds = CGRectZero;
+  // The source rectangle in points (view space).
+  double sourceX = 0;
+  double sourceY = 0;
+  double sourceWidth = 0;
+  double sourceHeight = 0;
+  // The output size in pixels.
+  uint32_t width = 0;
+  uint32_t height = 0;
+  CGFloat scaleX = 1;
+  CGFloat scaleY = 1;
+  // The view's bounds, scaled and offset so that the source rectangle covers
+  // the whole output, in pixels and with UIKit's top-left origin.
+  CGRect drawRect = CGRectZero;
+};
+
+ResolvedSnapshot resolveSnapshot(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) {
+  ResolvedSnapshot snapshot;
+  snapshot.view = (__bridge RNWGPlatformView *)lookup(request.viewTag);
+  if (snapshot.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;
+  snapshot.bounds = snapshot.view.bounds;
+  const CGRect bounds = snapshot.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 =
+  snapshot.sourceX = request.sourceX;
+  snapshot.sourceY = request.sourceY;
+  snapshot.sourceWidth =
       request.sourceWidth > 0 ? request.sourceWidth : bounds.size.width;
-  const double sourceHeight =
+  snapshot.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;
+  CGFloat scale = snapshot.view.window.screen.scale;
   if (scale <= 0) {
     scale = UIScreen.mainScreen.scale;
   }
 #else
-  CGFloat scale = view.window.backingScaleFactor;
+  CGFloat scale = snapshot.view.window.backingScaleFactor;
   if (scale <= 0) {
     scale = NSScreen.mainScreen.backingScaleFactor;
   }
 #endif
-  const uint32_t width =
+  snapshot.width =
       request.width > 0
           ? request.width
-          : static_cast<uint32_t>(std::llround(sourceWidth * scale));
-  const uint32_t height =
+          : static_cast<uint32_t>(std::llround(snapshot.sourceWidth * scale));
+  snapshot.height =
       request.height > 0
           ? request.height
-          : static_cast<uint32_t>(std::llround(sourceHeight * scale));
-  if (width == 0 || height == 0) {
+          : static_cast<uint32_t>(std::llround(snapshot.sourceHeight * scale));
+  if (snapshot.width == 0 || snapshot.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);
+  snapshot.scaleX = static_cast<CGFloat>(snapshot.width) / snapshot.sourceWidth;
+  snapshot.scaleY =
+      static_cast<CGFloat>(snapshot.height) / snapshot.sourceHeight;
+  snapshot.drawRect = CGRectMake(-snapshot.sourceX * snapshot.scaleX,
+                                 -snapshot.sourceY * snapshot.scaleY,
+                                 bounds.size.width * snapshot.scaleX,
+                                 bounds.size.height * snapshot.scaleY);
+  return snapshot;
+}
+
+// A premultiplied BGRA8 Core Graphics context over `pixels`, the layout both
+// snapshot paths produce. Returns NULL when Core Graphics rejects it.
+CGContextRef createBgraContext(void *pixels, uint32_t width, uint32_t height,
+                               size_t bytesPerRow) {
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      pixels, width, height, 8, bytesPerRow, colorSpace,
+      kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
+  CGColorSpaceRelease(colorSpace);
+  return context;
+}
 
-  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];
-      }];
+// Draws the view hierarchy through `context`, a bitmap context of exactly
+// `snapshot.width` x `snapshot.height` pixels (Core Graphics orientation; the
+// flip to UIKit's top-left origin is applied here).
+//
+// 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; NO draws
+// the last committed frame and skips that round trip to the render server.
+//
+// drawViewHierarchyInRect returns NO and draws nothing when the view is not
+// in a window (e.g. a screen pushed under another one). The output would then
+// be fully transparent, so that is reported as a failure instead.
+void drawViewHierarchy(const ResolvedSnapshot &snapshot, CGContextRef context,
+                       bool afterScreenUpdates) {
+  CGContextSaveGState(context);
+  CGContextTranslateCTM(context, 0, snapshot.height);
+  CGContextScaleCTM(context, 1, -1);
+  UIGraphicsPushContext(context);
+  const BOOL drawn =
+      [snapshot.view drawViewHierarchyInRect:snapshot.drawRect
+                          afterScreenUpdates:afterScreenUpdates ? YES : NO];
+  UIGraphicsPopContext();
+  CGContextRestoreGState(context);
   if (!drawn) {
-    throw std::runtime_error(
+    throw ViewNotRenderable(
         "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);
+}
+
+// Releases a pixel buffer when it goes out of scope.
+struct PixelBufferRelease {
+  CVPixelBufferRef buffer;
+  ~PixelBufferRelease() {
+    if (buffer != NULL) {
+      CFRelease(buffer);
     }
   }
-#endif
-  if (cgImage == NULL) {
+};
+
+// The zero-copy path: renders the view into an IOSurface-backed BGRA pixel
+// buffer, which the caller imports as shared texture memory and draws into
+// the destination on the GPU (VideoFrameBlit, which also converts the
+// premultiplied pixels to straight alpha when asked). UIKit rasterizes
+// straight into the surface's memory through a Core Graphics context, so the
+// pixels are never copied or converted on the CPU. Throws on an allocation
+// failure, which the caller answers with the pixel path.
+VideoFrameHandle renderViewIntoSurface(const ResolvedSnapshot &snapshot,
+                                       bool afterScreenUpdates) {
+  NSDictionary *attributes = @{
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
+    (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,
+  };
+  CVPixelBufferRef pixelBuffer = NULL;
+  const CVReturn created =
+      CVPixelBufferCreate(kCFAllocatorDefault, snapshot.width, snapshot.height,
+                          kCVPixelFormatType_32BGRA,
+                          (__bridge CFDictionaryRef)attributes, &pixelBuffer);
+  if (created != kCVReturnSuccess || pixelBuffer == NULL) {
     throw std::runtime_error(
-        "drawElementImageToTexture: the view could not be rendered");
+        "drawElementImageToTexture: could not allocate an IOSurface for the "
+        "view (CVPixelBufferCreate returned " +
+        std::to_string(created) + ")");
   }
+  // wrapCVPixelBuffer retains its own reference for the frame.
+  PixelBufferRelease release{pixelBuffer};
 
-  // Normalize into premultiplied BGRA8 with no row padding, whatever the
-  // renderer produced.
+  if (CVPixelBufferLockBaseAddress(pixelBuffer, 0) != kCVReturnSuccess) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: could not lock the IOSurface");
+  }
+  CGContextRef context = createBgraContext(
+      CVPixelBufferGetBaseAddress(pixelBuffer), snapshot.width, snapshot.height,
+      CVPixelBufferGetBytesPerRow(pixelBuffer));
+  if (context == NULL) {
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+    throw std::runtime_error(
+        "drawElementImageToTexture: could not draw into the IOSurface");
+  }
+  try {
+    // A fresh surface holds whatever was in that memory, and the view may be
+    // transparent.
+    CGContextClearRect(context,
+                       CGRectMake(0, 0, snapshot.width, snapshot.height));
+    drawViewHierarchy(snapshot, context, afterScreenUpdates);
+  } catch (...) {
+    CGContextRelease(context);
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+    throw;
+  }
+  CGContextRelease(context);
+  // Unlocking publishes the CPU writes to the GPU.
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+  return wrapCVPixelBuffer(pixelBuffer);
+}
+#endif
+
+// The pixel path: rasterizes the view into tightly packed, premultiplied
+// BGRA8 pixels that the caller uploads with writeTexture.
+ImageData renderViewIntoPixels(const ResolvedSnapshot &snapshot,
+                               bool afterScreenUpdates) {
   ImageData result;
-  result.width = width;
-  result.height = height;
+  result.width = snapshot.width;
+  result.height = snapshot.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);
+  // Zeroed: the view may be transparent.
+  result.data.assign(static_cast<size_t>(snapshot.width) * snapshot.height * 4,
+                     0);
+  CGContextRef context =
+      createBgraContext(result.data.data(), snapshot.width, snapshot.height,
+                        static_cast<size_t>(snapshot.width) * 4);
   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);
+  // UIKit draws straight into the vector; no intermediate image.
+  try {
+    drawViewHierarchy(snapshot, context, afterScreenUpdates);
+  } catch (...) {
+    CGContextRelease(context);
+    throw;
+  }
 #else
+  (void)afterScreenUpdates;
+  CGImageRef cgImage = NULL;
+  NSBitmapImageRep *rep =
+      [snapshot.view bitmapImageRepForCachingDisplayInRect:snapshot.bounds];
+  if (rep != nil) {
+    [snapshot.view cacheDisplayInRect:snapshot.bounds toBitmapImageRep:rep];
+    cgImage = rep.CGImage;
+    if (cgImage != NULL) {
+      CGImageRetain(cgImage);
+    }
+  }
+  if (cgImage == NULL) {
+    CGContextRelease(context);
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view could not be rendered");
+  }
   // 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
+  const CGRect imageRect =
+      CGRectMake(-snapshot.sourceX * snapshot.scaleX,
+                 -(snapshot.bounds.size.height - snapshot.sourceY -
+                   snapshot.sourceHeight) *
+                     snapshot.scaleY,
+                 snapshot.bounds.size.width * snapshot.scaleX,
+                 snapshot.bounds.size.height * snapshot.scaleY);
   CGContextSetBlendMode(context, kCGBlendModeCopy);
   CGContextDrawImage(context, imageRect, cgImage);
-  CGContextRelease(context);
   CGImageRelease(cgImage);
+#endif
+  CGContextRelease(context);
   return result;
 }
 
 } // namespace
 
-// Always delivers pixels: the view is drawn into a CPU bitmap, so there is no
-// GPU frame to hand over (onFrame is unused).
+// On iOS a caller that can draw a GPU frame (allowFrame) gets the view
+// rendered into an IOSurface; everything else, and macOS, gets pixels.
 void ApplePlatformContext::snapshotView(
-    const ViewSnapshotRequest &request,
-    std::function<void(ImageData)> onPixels,
-    std::function<void(VideoFrameHandle)> /* onFrame */,
+    const ViewSnapshotRequest &request, std::function<void(ImageData)> onPixels,
+    std::function<void(VideoFrameHandle)> onFrame,
     std::function<void(std::string)> onError) {
   // Copies: the block outlives this call.
   ViewLookup lookup = _viewLookup;
@@ -202,7 +322,29 @@ void ApplePlatformContext::snapshotView(
   dispatch_async(dispatch_get_main_queue(), ^{
     @autoreleasepool {
       try {
-        onPixels(snapshotViewOnMainThread(lookup, snapshotRequest));
+        const ResolvedSnapshot snapshot =
+            resolveSnapshot(lookup, snapshotRequest);
+#if !TARGET_OS_OSX
+        if (snapshotRequest.allowFrame) {
+          try {
+            onFrame(renderViewIntoSurface(snapshot,
+                                          snapshotRequest.afterScreenUpdates));
+            return;
+          } catch (const ViewNotRenderable &) {
+            throw;
+          } catch (const std::exception &error) {
+            // An IOSurface could not be set up; the pixel path draws the
+            // same view.
+            NSLog(@"[WebGPU] drawElementImageToTexture: %s; reading the "
+                  @"pixels back instead",
+                  error.what());
+          }
+        }
+#else
+        (void)onFrame;
+#endif
+        onPixels(
+            renderViewIntoPixels(snapshot, snapshotRequest.afterScreenUpdates));
       } catch (const std::exception &error) {
         onError(error.what());
       } catch (...) {
@@ -325,12 +467,10 @@ void ApplePlatformContext::createImageBitmapFromDataAsync(
   });
 }
 
-VideoFrameHandle
-ApplePlatformContext::loadVideoFrame(const std::string &path) {
+VideoFrameHandle ApplePlatformContext::loadVideoFrame(const std::string &path) {
   NSString *nsPath = [NSString stringWithUTF8String:path.c_str()];
-  NSURL *url = [nsPath hasPrefix:@"file://"]
-                   ? [NSURL URLWithString:nsPath]
-                   : [NSURL fileURLWithPath:nsPath];
+  NSURL *url = [nsPath hasPrefix:@"file://"] ? [NSURL URLWithString:nsPath]
+                                             : [NSURL fileURLWithPath:nsPath];
   AVURLAsset *asset = [AVURLAsset assetWithURL:url];
 
   NSArray<AVAssetTrack *> *videoTracks =
@@ -350,8 +490,7 @@ ApplePlatformContext::loadVideoFrame(const std::string &path) {
   }
 
   NSDictionary *outputSettings = @{
-    (NSString *)kCVPixelBufferPixelFormatTypeKey :
-        @(kCVPixelFormatType_32BGRA),
+    (NSString *)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
     (NSString *)kCVPixelBufferMetalCompatibilityKey : @YES,
   };
@@ -405,7 +544,7 @@ ApplePlatformContext::loadVideoFrame(const std::string &path) {
 
 std::unique_ptr<IVideoPlayer>
 ApplePlatformContext::createVideoPlayer(const std::string &path,
-                                         VideoPixelFormat format) {
+                                        VideoPixelFormat format) {
   return createAppleVideoPlayer(path, format);
 }
 

package/cpp/rnwgpu/PlatformContext.h

@@ -148,6 +148,12 @@ struct ViewSnapshotRequest {
   // 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 {

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -548,16 +548,27 @@ public:
     if (device) {
       dawn::native::metal::WaitForCommandsToBeScheduled(device.Get());
     }
+#endif
+#if defined(__ANDROID__)
+    std::function<void()> framePresented;
 #endif
     {
       std::unique_lock<std::shared_mutex> lock(_mutex);
       if (_surface && _acquiredFromSurface) {
         _surface.Present();
+#if defined(__ANDROID__)
+        framePresented = _framePresented;
+#endif
       }
       _acquiredFromSurface = false;
       _frameInFlight = false;
       _frameEpoch++;
     }
+#if defined(__ANDROID__)
+    if (framePresented) {
+      framePresented();
+    }
+#endif
     applyPendingAttach();
   }
 
@@ -691,6 +702,16 @@ public:
     std::lock_guard<std::mutex> poolLock(_poolMutex);
     _poolFrameReady = std::move(cb);
   }
+
+  // Invoked from the presenting thread (never under _mutex) after each frame
+  // presentFrame() shows on the attached surface; the blit of the last
+  // offscreen frame onto a newly attached surface does not count. The view
+  // uses it to vote the display's refresh rate while the canvas animates
+  // (see SurfaceFrameRateVote.java). Pass nullptr to unregister.
+  void setFramePresentedCallback(std::function<void()> cb) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _framePresented = std::move(cb);
+  }
 #endif
 
 private:
@@ -1239,6 +1260,9 @@ private:
   static constexpr int kPoolSize =
       5; // 2 held + 1 rendering + 1 waiting + 1 ready
 
+  // See setFramePresentedCallback(); read under _mutex, called outside it.
+  std::function<void()> _framePresented;
+
   std::atomic<bool> _poolMode{false};
   std::mutex _poolMutex;
   std::condition_variable _freeCv;    // a slot returned to Free

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -357,12 +357,15 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
         "a positive width and height");
   }
 
+  request.afterScreenUpdates = source->afterScreenUpdates.value_or(true);
+
   // 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).
+  // GPU buffer (Android 13 and above through HardwareRenderer, iOS through an
+  // IOSurface) 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) ==

package/cpp/rnwgpu/api/descriptors/GPUDrawElementImageSource.h

@@ -22,6 +22,9 @@ struct GPUDrawElementImageSource {
   std::optional<double> sourceY;      // float
   std::optional<double> sourceWidth;  // float
   std::optional<double> sourceHeight; // float
+  // iOS: pass false to draw the last committed frame instead of waiting for
+  // pending layout and layer changes (default true). Ignored on Android.
+  std::optional<bool> afterScreenUpdates;
 };
 
 } // namespace rnwgpu
@@ -93,6 +96,10 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUDrawElementImageSource>> {
       result->sourceHeight = JSIConverter<std::optional<double>>::fromJSI(
           runtime, obj.getProperty(runtime, "sourceHeight"), false);
     }
+    if (obj.hasProperty(runtime, "afterScreenUpdates")) {
+      result->afterScreenUpdates = JSIConverter<std::optional<bool>>::fromJSI(
+          runtime, obj.getProperty(runtime, "afterScreenUpdates"), false);
+    }
     return result;
   }
 

package/lib/typescript/src/types.d.ts

@@ -73,6 +73,7 @@ export interface GPUDrawElementImageSource {
     sourceY?: number;
     sourceWidth?: number;
     sourceHeight?: number;
+    afterScreenUpdates?: boolean;
 }
 export interface GPUDrawElementImageDestination extends GPUCopyExternalImageDestInfo {
     size?: GPUExtent3DStrict;

package/lib/typescript/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/types.ts

@@ -152,6 +152,12 @@ export interface GPUDrawElementImageSource {
   sourceY?: number;
   sourceWidth?: number;
   sourceHeight?: number;
+  // iOS only (default true): flush pending layout and layer changes before
+  // drawing, so a snapshot taken right after a state change reflects it. Pass
+  // false to draw the last committed frame instead, which skips a round trip
+  // to the render server; the choice for repeated captures. Android renders
+  // the views' current display lists either way.
+  afterScreenUpdates?: boolean;
 }
 
 // The destination argument of drawElementImageToTexture: