react-native-webgpu 0.15.2 → 0.16.1

package/android/CMakeLists.txt

@@ -46,6 +46,8 @@ add_library(${PACKAGE_NAME} SHARED
     ../cpp/rnwgpu/api/GPUSharedFence.cpp
     ../cpp/rnwgpu/api/GPUSharedTextureMemory.cpp
     ../cpp/rnwgpu/api/GPUExternalTexture.cpp
+    ../cpp/rnwgpu/api/GPUNativeBufferWrapper.cpp
+    ../cpp/rnwgpu/api/NativeFrameImport.cpp
     ../cpp/rnwgpu/api/GPURenderBundleEncoder.cpp
     ../cpp/rnwgpu/api/GPURenderPassEncoder.cpp
     ../cpp/rnwgpu/api/GPURenderPipeline.cpp
@@ -96,6 +98,8 @@ if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
             log
             jnigraphics
             android
+            # sync_merge, for the one fence endAccess() returns
+            sync
             fbjni::fbjni
             ReactAndroid::jsi
             ReactAndroid::reactnative
@@ -108,6 +112,7 @@ else()
         log
         jnigraphics
         android
+        sync
         fbjni::fbjni
         ReactAndroid::jsi
         ReactAndroid::reactnativejni

package/android/build.gradle

@@ -75,6 +75,16 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Wgpu_" + name]).toInteger()
 }
 
+// androidMinSdkVersion in package.json is the lowest API level the native code
+// builds for: it calls the AHardwareBuffer API, from Android 8 (API 26). An
+// app's lower minSdkVersion does not lower it, so such an app gets the
+// manifest merger's error, with its suggested fix, instead of the compiler's.
+def resolveMinSdkVersion() {
+  def floor = new groovy.json.JsonSlurper().parse(file("../package.json")).androidMinSdkVersion as Integer
+  def app = rootProject.ext.has("minSdkVersion") ? rootProject.ext.get("minSdkVersion").toString().toInteger() : floor
+  return Math.max(app, floor)
+}
+
 def supportsNamespace() {
   def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
   def major = parsed[0].toInteger()
@@ -88,7 +98,7 @@ android {
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    minSdkVersion resolveMinSdkVersion()
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
     externalNativeBuild {

package/android/cpp/cpp-adapter.cpp

@@ -1,7 +1,11 @@
 #include <unistd.h>
 
+#include <atomic>
+#include <chrono>
+#include <cstdint>
 #include <cstring>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -160,10 +164,10 @@ 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).
+// when a frame is ready, the presenting thread tells a SurfaceView it is
+// animating (AnimationReporter). 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;
@@ -203,11 +207,84 @@ struct WeakViewCall {
   }
 };
 
+// Tells a SurfaceView it starts animating, for its refresh rate vote
+// (WebGPUView.onAnimating), from the frames presented to its surface. A call
+// into Java on the render path costs a JNI transition and attaches a presenting
+// thread the JVM doesn't know for the length of the call, so there is one call
+// per animation: the first frame presented right after its predecessor calls,
+// the frames after it only record the time. The view polls that time from the
+// main thread (releaseIfIdle) and, once the animation has stopped, takes its
+// vote back and re-arms the call for the next animation. Lock-free, since it
+// runs on every present.
+class AnimationReporter {
+public:
+  AnimationReporter(JNIEnv *env, jobject view)
+      : _onAnimating(env, view, "onAnimating") {}
+
+  void onFramePresented() {
+    const int64_t now = nowNanos();
+    const int64_t previous = _lastPresent.exchange(now);
+    if (now - previous > kAnimatingIntervalNanos) {
+      return;
+    }
+    _lastAnimating.store(now);
+    if (!_reported.exchange(true)) {
+      _onAnimating();
+    }
+  }
+
+  // Main thread. Returns how much longer the animation must stay stopped
+  // before it counts as idle, or 0 once it has: the next animating frame then
+  // calls into Java again.
+  int64_t releaseIfIdle(int64_t idleAfterNanos) {
+    const int64_t idle = nowNanos() - _lastAnimating.load();
+    if (idle < idleAfterNanos) {
+      return idleAfterNanos - idle;
+    }
+    _reported.store(false);
+    return 0;
+  }
+
+private:
+  // Presents this close together are an animation (faster than 40 fps).
+  static constexpr int64_t kAnimatingIntervalNanos = 25'000'000;
+
+  static int64_t nowNanos() {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+               std::chrono::steady_clock::now().time_since_epoch())
+        .count();
+  }
+
+  WeakViewCall _onAnimating;
+  // INT64_MIN / 2 rather than a sentinel: the first present is never "right
+  // after" it, and the subtractions above don't overflow.
+  std::atomic<int64_t> _lastPresent{INT64_MIN / 2};
+  std::atomic<int64_t> _lastAnimating{INT64_MIN / 2};
+  // Java has been told about the current animation.
+  std::atomic<bool> _reported{false};
+};
+
+// The reporters by contextId, for WebGPUView.releaseFrameRateVoteIfIdle. The
+// surface callbacks and the idle check all run on the main thread; the lock
+// only guards against a caller that doesn't.
+std::mutex animationReportersMutex;
+std::unordered_map<int, std::shared_ptr<AnimationReporter>> animationReporters;
+
+void setAnimationReporter(int contextId,
+                          std::shared_ptr<AnimationReporter> reporter) {
+  std::lock_guard<std::mutex> lock(animationReportersMutex);
+  if (reporter) {
+    animationReporters[contextId] = std::move(reporter);
+  } else {
+    animationReporters.erase(contextId);
+  }
+}
+
 } // namespace
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
-    jfloat height, jboolean reportPresents) {
+    jfloat height, jboolean reportAnimation) {
   if (manager == nullptr) {
     return;
   }
@@ -228,13 +305,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)(); });
+  // A SurfaceView asks to hear when it animates, for its refresh rate vote
+  // (WebGPUView.onAnimating).
+  if (reportAnimation) {
+    auto reporter = std::make_shared<AnimationReporter>(env, thiz);
+    setAnimationReporter(contextId, reporter);
+    info->setFramePresentedCallback(
+        [reporter]() { reporter->onFramePresented(); });
   } else {
+    setAnimationReporter(contextId, nullptr);
     info->setFramePresentedCallback(nullptr);
   }
   // The attach is adopted at the next frame boundary by the rendering thread;
@@ -246,6 +325,7 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
 extern "C" JNIEXPORT void JNICALL
 Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
+  setAnimationReporter(contextId, nullptr);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
     info->setFramePresentedCallback(nullptr);
@@ -253,12 +333,30 @@ Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
   }
 }
 
+// See AnimationReporter::releaseIfIdle; 0 when the surface reports nothing.
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_webgpu_WebGPUView_releaseFrameRateVoteIfIdle(JNIEnv *env, jobject thiz,
+                                                      jint contextId,
+                                                      jlong idleAfterNanos) {
+  std::shared_ptr<AnimationReporter> reporter;
+  {
+    std::lock_guard<std::mutex> lock(animationReportersMutex);
+    auto it = animationReporters.find(contextId);
+    if (it == animationReporters.end()) {
+      return 0;
+    }
+    reporter = it->second;
+  }
+  return static_cast<jlong>(reporter->releaseIfIdle(idleAfterNanos));
+}
+
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
     JNIEnv *env, jobject thiz, jint contextId) {
   // The view dies with its Canvas (contextIds are never reused), so view
   // teardown retires the registry entry. The JS-side cleanup
   // (RNWebGPU.destroyContext) only handles entries that never had a native
   // surface; see RNWebGPU::destroyContext for the ownership split.
+  setAnimationReporter(contextId, nullptr);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
     info->setFramePresentedCallback(nullptr);

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

@@ -24,134 +24,146 @@ import androidx.annotation.Nullable;
  * 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.
+ * Native code tells onAnimating() once per animation, on the thread that
+ * presents (the JS thread, the Reanimated UI runtime or a worklet runtime),
+ * and the vote is cast right there, with no hop to a main thread that may be
+ * busy. The rate is resolved ahead of time on the main thread, where the
+ * view's display can be read. The idle check runs on the main thread and asks
+ * native code how long ago the canvas last animated; once it has stopped, it
+ * takes the vote back and native code calls onAnimating() again at the next
+ * animation. The lock only guards the state: the binder calls
+ * (Surface.setFrameRate) are made outside it.
  */
 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;
+  // The vote is taken back once the canvas has not animated for this long,
+  // whether it stops drawing or drops back to a few redraws a second. Native
+  // code decides what animating means (presents faster than 40 fps, see
+  // AnimationReporter in cpp-adapter.cpp). 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.
+  static final long IDLE_AFTER_NANOS = 500_000_000L;
+
+  /** Native side of the vote, see AnimationReporter in cpp-adapter.cpp. */
+  interface AnimationSource {
+    /**
+     * How much longer the canvas must stay still before it counts as idle,
+     * or 0 once it does, in which case the next animation calls
+     * onAnimating() again. Main thread.
+     */
+    long releaseIfIdle(long idleAfterNanos);
+  }
 
   private final View mView;
+  private final AnimationSource mSource;
   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 rate to ask for, resolved on the main thread; 0 when unknown, in
+  // which case animations don't vote until the next idle check resolves it.
+  private float mRefreshRate = 0f;
 
   /** The view the surface belongs to; its display decides the rate to ask for. */
-  SurfaceFrameRateVote(View view) {
+  SurfaceFrameRateVote(View view, AnimationSource source) {
     mView = view;
+    mSource = source;
   }
 
   /** The surface was created: it is voted on until detach(). Main thread. */
-  synchronized void attach(Surface surface) {
+  void attach(Surface surface) {
     detach();
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
       return;
     }
-    mSurface = surface;
+    float refreshRate = resolveMaxRefreshRate();
+    synchronized (this) {
+      mSurface = surface;
+      mRefreshRate = refreshRate;
+    }
   }
 
-  /** 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();
+  /**
+   * The canvas started animating (presenting frames back to back). Called
+   * once per animation, on the presenting thread.
+   */
+  void onAnimating() {
+    Surface surface;
+    float refreshRate;
+    synchronized (this) {
+      if (mSurface == null) {
+        return;
       }
+      surface = mSurface;
+      refreshRate = mRefreshRate;
+      mVoting = refreshRate > 0;
     }
-    if (mVoting && !mIdleCheckPending) {
-      scheduleIdleCheck(IDLE_AFTER_NANOS);
+    // Whether it votes or not, the idle check re-arms native code once the
+    // animation stops.
+    mHandler.postDelayed(mIdleCheck, IDLE_AFTER_NANOS / 1_000_000);
+    if (refreshRate > 0) {
+      // 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.
+      setFrameRate(surface, refreshRate);
     }
   }
 
   /** 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;
+  void detach() {
+    Surface surface;
+    boolean voting;
+    synchronized (this) {
+      surface = mSurface;
+      voting = mVoting;
+      mSurface = null;
+      mVoting = false;
     }
-    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();
+    // A vote cast concurrently on the presenting thread may land after this;
+    // it dies with the surface, which is going away.
+    if (surface != null && voting) {
+      setFrameRate(surface, 0);
     }
   }
 
-  private void withdraw() {
-    if (!mVoting) {
+  private void checkIdle() {
+    long remainingNanos = mSource.releaseIfIdle(IDLE_AFTER_NANOS);
+    if (remainingNanos > 0) {
+      mHandler.postDelayed(mIdleCheck, (remainingNanos + 999_999) / 1_000_000);
       return;
     }
-    mVoting = false;
-    if (mSurface == null || !mSurface.isValid()) {
-      return;
+    // Native code is re-armed: the next onAnimating() can only come after
+    // this point, so it doesn't race with the withdrawal below.
+    float refreshRate = resolveMaxRefreshRate();
+    Surface surface;
+    boolean voting;
+    synchronized (this) {
+      surface = mSurface;
+      voting = mVoting;
+      mVoting = false;
+      if (surface != null) {
+        // Follows the display the view is on, for the next animation.
+        mRefreshRate = refreshRate;
+      }
     }
-    try {
-      mSurface.setFrameRate(0, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
-    } catch (RuntimeException e) {
-      Log.w(TAG, "Could not withdraw the refresh rate vote", e);
+    if (surface != null && voting) {
+      setFrameRate(surface, 0);
     }
   }
 
-  private void scheduleIdleCheck(long delayNanos) {
-    mIdleCheckPending = true;
-    mHandler.postDelayed(mIdleCheck, (delayNanos + 999_999) / 1_000_000);
-  }
-
-  private synchronized void checkIdle() {
-    mIdleCheckPending = false;
-    if (!mVoting) {
+  private static void setFrameRate(Surface surface, float refreshRate) {
+    if (!surface.isValid()) {
       return;
     }
-    long idleNanos = System.nanoTime() - mLastAnimatingNanos;
-    if (idleNanos >= IDLE_AFTER_NANOS) {
-      withdraw();
-    } else {
-      scheduleIdleCheck(IDLE_AFTER_NANOS - idleNanos);
+    try {
+      surface.setFrameRate(refreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not set the surface's frame rate, leaving it to the display", e);
     }
   }