react-native-skia 2.15.0 → 3.0.1

package/cpp/rnskia/RNSkGraphiteView.h

@@ -14,6 +14,7 @@
 
 #include "RNDawnContext.h"
 #include "RNDawnUtils.h"
+#include "RNSkGraphiteProducer.h"
 #include "RNSkPlatformContext.h"
 #include "RNSkView.h"
 #include "jsi/ViewProperty.h"
@@ -59,14 +60,31 @@ public:
   skgpu::graphite::Recording *get() const { return _recording.get(); }
 
   /**
-   Whether the recording can be replayed onto the given target: same format,
-   and the target supports every usage the recording relies on.
+   Whether the recording was made for a texture of the given size. A deferred
+   canvas records against fixed dimensions: replaying it onto a texture of
+   another size makes Graphite copy and draw outside of it, which Dawn
+   rejects (the whole frame is then dropped). A view that was resized has
+   stale recordings in flight; they are skipped and the content is recorded
+   again for the new size.
    */
-  bool isCompatibleWith(const RNSkGraphiteTargetInfo &target) const {
+  bool hasSizeOf(const RNSkGraphiteTargetInfo &target) const {
+    return _target.width == target.width && _target.height == target.height;
+  }
+
+  /**
+   Whether the recording has the format of the given target, and the target
+   supports every usage the recording relies on.
+   */
+  bool hasFormatOf(const RNSkGraphiteTargetInfo &target) const {
     return _target.colorType == target.colorType &&
            _target.textureInfo.canBeFulfilledBy(target.textureInfo);
   }
 
+  /** Whether the recording can be replayed onto the given target. */
+  bool isCompatibleWith(const RNSkGraphiteTargetInfo &target) const {
+    return hasSizeOf(target) && hasFormatOf(target);
+  }
+
 private:
   // Declared before the recording so that the recording is released first.
   std::shared_ptr<RNSkGraphiteRecorder> _recorder;
@@ -364,6 +382,20 @@ public:
     _target = std::move(target);
   }
 
+  /**
+   Called on the main thread after each presented frame (the producer paces
+   itself on it) and whenever the view asks for a redraw: a new surface, a
+   resize, or SkiaViewApi.requestRedraw. The latter returns whether a frame
+   is coming for it. Set once, at construction.
+   */
+  void setOnPresented(std::function<void()> callback) {
+    _onPresented = std::move(callback);
+  }
+
+  void setOnRedraw(std::function<bool()> callback) {
+    _onRedraw = std::move(callback);
+  }
+
   /**
    Presents everything submitted since the last frame. With nothing queued,
    presents the last frame again: a redraw after a resize or on a new
@@ -376,6 +408,8 @@ public:
     if (!canvasProvider->getGraphiteTargetInfo(&targetInfo)) {
       return;
     }
+    // Declarative content is recorded again for the surface as it is now.
+    const bool frameComing = _onRedraw && _onRedraw();
     std::shared_ptr<RNSkGraphiteTarget> target;
     std::shared_ptr<RNSkGraphiteRecording> lastPresented;
     {
@@ -388,24 +422,33 @@ public:
       recordings = target->takeQueued();
     }
     if (recordings.empty()) {
-      if (lastPresented == nullptr) {
+      // With a frame on its way, the layer keeps showing the last one until
+      // it lands: presenting it again would only cost a second present. The
+      // same holds after a resize, when the last frame has the old size.
+      if (frameComing || lastPresented == nullptr ||
+          !lastPresented->hasSizeOf(targetInfo)) {
         return;
       }
-      present(canvasProvider, targetInfo, {lastPresented},
-              /* remember= */ true);
+      if (present(canvasProvider, targetInfo, {lastPresented},
+                  /* remember= */ true)) {
+        notifyPresented();
+      }
       return;
     }
-    if (!present(canvasProvider, targetInfo, recordings,
-                 /* remember= */ true) &&
-        target) {
+    if (present(canvasProvider, targetInfo, recordings,
+                /* remember= */ true)) {
+      notifyPresented();
+    } else if (target) {
       target->requeue(recordings);
     }
   }
 
   /**
    Presents the queued recordings, if any. Returns whether more are waiting,
-   so that the caller keeps its frame callback armed. Without a surface the
-   queue is left alone: the surface presents it when it appears.
+   so that the caller keeps its frame callback armed: also when the present
+   failed (the app is in the background), so that the recordings are tried
+   again on the next frame rather than left waiting for a redraw. Without a
+   surface the queue is left alone: the surface presents it when it appears.
    */
   bool presentQueued(const std::shared_ptr<RNSkCanvasProvider> &provider) {
     std::shared_ptr<RNSkGraphiteTarget> target;
@@ -426,8 +469,9 @@ public:
     }
     if (!present(provider, targetInfo, recordings, /* remember= */ true)) {
       target->requeue(recordings);
-      return false;
+      return true;
     }
+    notifyPresented();
     return target->hasQueued();
   }
 
@@ -460,9 +504,11 @@ public:
 
 private:
   /**
-   Replays the recordings onto the provider's target. Returns false when the
-   provider could not present (no surface, app in the background), in which
-   case nothing was consumed and the caller keeps the recordings.
+   Replays the recordings onto the provider's target, and remembers the last
+   one for the next redraw when asked to (not for a snapshot). Returns false
+   when the provider could not present (no surface, app in the background),
+   in which case nothing was consumed and the caller keeps the recordings.
+   The on-screen callers tell the producer about a consumed frame.
    */
   bool
   present(const std::shared_ptr<RNSkCanvasProvider> &provider,
@@ -472,10 +518,15 @@ private:
     std::vector<skgpu::graphite::Recording *> raw;
     std::shared_ptr<RNSkGraphiteRecording> last;
     for (const auto &recording : recordings) {
+      // A recording made for the size the view had before a resize is
+      // dropped quietly: the next one is recorded for the new size.
+      if (!recording->hasSizeOf(targetInfo)) {
+        continue;
+      }
       // A recording made for another format (recorded before the surface
       // existed, with a bit depth the surface did not get) cannot be
       // replayed onto this one.
-      if (!recording->isCompatibleWith(targetInfo)) {
+      if (!recording->hasFormatOf(targetInfo)) {
         RNSkLogger::logToConsole("SkiaGraphiteView: skipping a recording made "
                                  "for a different surface format");
         continue;
@@ -495,15 +546,26 @@ private:
     return success;
   }
 
+  void notifyPresented() {
+    if (_onPresented) {
+      _onPresented();
+    }
+  }
+
   std::mutex _mutex;
   std::shared_ptr<RNSkGraphiteTarget> _target;
   std::shared_ptr<RNSkGraphiteRecording> _lastPresented;
+  std::function<void()> _onPresented;
+  std::function<bool()> _onRedraw;
 };
 
 /**
- * A view that presents Graphite recordings. JS records frames through the
- * target (SkiaViewApi.makeGraphiteContext); the platform view presents them
- * on its display link. Only available with the Graphite backend.
+ * A view that presents Graphite recordings. Frames come from one of two
+ * producers: JS records them itself through the target
+ * (SkiaViewApi.makeGraphiteContext), or <GraphiteCanvas> hands over a recorder
+ * (or a picture) that the render thread pool records for the view. The
+ * platform view presents them on its display link. Only available with the
+ * Graphite backend.
  */
 class RNSkGraphiteView : public RNSkView {
 public:
@@ -511,7 +573,21 @@ public:
                    std::shared_ptr<RNSkCanvasProvider> canvasProvider)
       : RNSkView(context, canvasProvider,
                  std::make_shared<RNSkGraphiteRenderer>(
-                     std::bind(&RNSkGraphiteView::requestRedraw, this))) {}
+                     std::bind(&RNSkGraphiteView::requestRedraw, this))),
+        _producer(std::make_shared<RNSkGraphiteProducer>()) {
+    std::weak_ptr<RNSkGraphiteProducer> weakProducer = _producer;
+    getGraphiteRenderer()->setOnPresented([weakProducer]() {
+      if (auto producer = weakProducer.lock()) {
+        producer->onFramePresented();
+      }
+    });
+    getGraphiteRenderer()->setOnRedraw([weakProducer]() {
+      if (auto producer = weakProducer.lock()) {
+        return producer->requestFrame();
+      }
+      return false;
+    });
+  }
 
   ~RNSkGraphiteView() override {
     if (_target) {
@@ -519,9 +595,26 @@ public:
     }
   }
 
-  // No JSI properties: frames arrive through the target.
+  /** Declarative content: the recorder of <GraphiteCanvas>, or a picture. */
   void setJsiProperties(
-      std::unordered_map<std::string, RNJsi::ViewProperty> &props) override {}
+      std::unordered_map<std::string, RNJsi::ViewProperty> &props) override {
+    for (auto &prop : props) {
+      if (prop.first == "recorder") {
+        _producer->setRecorder(
+            prop.second.isRecorder() ? prop.second.getRecorder() : nullptr);
+      } else if (prop.first == "picture") {
+        _producer->setPicture(prop.second.isPicture() ? prop.second.getPicture()
+                                                      : nullptr);
+      }
+    }
+  }
+
+  bool applyUpdates(jsi::Runtime &runtime, double recorderId,
+                    const jsi::Array &values) override {
+    return _producer->applyUpdates(runtime, recorderId, values);
+  }
+
+  void releaseContent() override { _producer->clear(); }
 
   void setNativeId(size_t nativeId) override {
     RNSkView::setNativeId(nativeId);
@@ -546,6 +639,7 @@ public:
       });
     };
     _target->attach(getCanvasProvider(), scheduleOnMainThread);
+    _producer->setTarget(_target);
     // Frames recorded before the view existed are presented now.
     if (_target->hasQueued()) {
       scheduleOnMainThread();
@@ -579,12 +673,22 @@ public:
 
   bool hasQueuedRecordings() { return _target && _target->hasQueued(); }
 
-  /** Replays the current frame into an offscreen surface. */
+  /**
+   Renders the view into an offscreen surface: declarative content is
+   replayed on the calling thread with the latest values, so the snapshot
+   does not wait for a frame; otherwise the current frame is replayed.
+   */
   sk_sp<SkImage> makeImageSnapshot(SkRect *bounds) override {
     auto provider = std::make_shared<RNSkOffscreenCanvasProvider>(
         getPlatformContext(), std::bind(&RNSkView::requestRedraw, this),
         getScaledWidth(), getScaledHeight());
-    getGraphiteRenderer()->renderLastFrame(provider);
+    if (_producer->hasContent()) {
+      auto pd = getPlatformContext()->getPixelDensity();
+      provider->renderToCanvas(
+          [this, pd](SkCanvas *canvas) { _producer->renderInto(canvas, pd); });
+    } else {
+      getGraphiteRenderer()->renderLastFrame(provider);
+    }
     return provider->makeSnapshot(bounds);
   }
 
@@ -593,6 +697,7 @@ private:
     return std::static_pointer_cast<RNSkGraphiteRenderer>(getRenderer());
   }
 
+  std::shared_ptr<RNSkGraphiteProducer> _producer;
   std::shared_ptr<RNSkGraphiteTarget> _target;
   size_t _targetId = 0;
   std::function<void()> _frameScheduler;

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -231,12 +231,8 @@ public:
       return jsi::Value::undefined();
     }
     // Outside the registry lock: the update must not hold up the commits
-    // and registrations of other views.
-    auto renderer =
-        std::static_pointer_cast<RNSkPictureRenderer>(view->getRenderer());
-    if (renderer->applyUpdates(runtime, recorderId, values)) {
-      view->requestRedraw();
-    }
+    // and registrations of other views. The view schedules its own frame.
+    view->applyUpdates(runtime, recorderId, values);
     return jsi::Value::undefined();
   }
 

package/cpp/rnskia/RNSkPictureView.cpp

@@ -1,15 +1,29 @@
-// The recorder headers depend on the include order established by
-// JsiSkApi.h, so everything that needs a complete Recorder lives here rather
-// than in RNSkPictureView.h (which platform views include on its own).
-#include "api/JsiSkApi.h"
-
+// Everything that needs a complete Recorder lives here rather than in
+// RNSkPictureView.h (which platform views include on its own).
 #include "RNSkPictureView.h"
 
+#include <memory>
+#include <utility>
+
 #include "api/recorder/DrawingCtx.h"
 #include "api/recorder/RNRecorder.h"
 
 namespace RNSkia {
 
+void drawContent(SkCanvas *canvas, Recorder *recorder,
+                 const sk_sp<SkPicture> &picture, float pixelDensity) {
+  canvas->clear(SK_ColorTRANSPARENT);
+  canvas->save();
+  canvas->scale(pixelDensity, pixelDensity);
+  if (recorder != nullptr) {
+    DrawingCtx ctx(canvas);
+    recorder->play(&ctx);
+  } else if (picture != nullptr) {
+    canvas->drawPicture(picture);
+  }
+  canvas->restore();
+}
+
 void RNSkPictureRenderer::setRecorder(std::shared_ptr<Recorder> recorder) {
   sk_sp<SkPicture> picture;
   if (recorder != nullptr && recorder->variables.empty()) {
@@ -33,7 +47,9 @@ bool RNSkPictureRenderer::applyUpdatesTo(
   if (recorder == nullptr || recorder->id != recorderId) {
     return false;
   }
-  recorder->applyUpdates(runtime, values);
+  // The values are written into the commands by the next replay, which the
+  // caller schedules: the mapper never waits for a draw.
+  recorder->readUpdates(runtime, values);
   return true;
 }
 
@@ -50,9 +66,4 @@ bool RNSkPictureRenderer::applyUpdates(jsi::Runtime &runtime, double recorderId,
   return applyUpdatesTo(recorder, runtime, recorderId, values);
 }
 
-void RNSkPictureRenderer::replay(SkCanvas *canvas, Recorder *recorder) {
-  DrawingCtx ctx(canvas);
-  recorder->play(&ctx);
-}
-
 } // namespace RNSkia

package/cpp/rnskia/RNSkPictureView.h

@@ -37,6 +37,14 @@ namespace jsi = facebook::jsi;
 
 class Recorder;
 
+/**
+ * Replays declarative content, a recorder if there is one, else a picture,
+ * into a canvas that draws in pixels: clears it and applies the density.
+ * Shared by the picture renderer and the Graphite producer.
+ */
+void drawContent(SkCanvas *canvas, Recorder *recorder,
+                 const sk_sp<SkPicture> &picture, float pixelDensity);
+
 /**
  * Draws either an SkPicture (imperative API, or a recording without shared
  * values, played once into a picture) or a Recorder (declarative <Canvas>
@@ -142,20 +150,10 @@ public:
       recorder = _recorder;
       picture = _picture;
     }
-    canvas->clear(SK_ColorTRANSPARENT);
-    canvas->save();
-    canvas->scale(pixelDensity, pixelDensity);
-    if (recorder != nullptr) {
-      replay(canvas, recorder.get());
-    } else if (picture != nullptr) {
-      canvas->drawPicture(picture);
-    }
-    canvas->restore();
+    drawContent(canvas, recorder.get(), picture, pixelDensity);
   }
 
 private:
-  void replay(SkCanvas *canvas, Recorder *recorder);
-
   bool performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
     auto pd = _platformContext->getPixelDensity();
     return canvasProvider->renderToCanvas(
@@ -194,5 +192,20 @@ public:
       }
     }
   }
+
+  bool applyUpdates(jsi::Runtime &runtime, double recorderId,
+                    const jsi::Array &values) override {
+    auto renderer =
+        std::static_pointer_cast<RNSkPictureRenderer>(getRenderer());
+    if (!renderer->applyUpdates(runtime, recorderId, values)) {
+      return false;
+    }
+    requestRedraw();
+    return true;
+  }
+
+  void releaseContent() override {
+    std::static_pointer_cast<RNSkPictureRenderer>(getRenderer())->clear();
+  }
 };
 } // namespace RNSkia

package/cpp/rnskia/RNSkThreadPool.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <algorithm>
+#include <deque>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <thread>
+
+#include <condition_variable>
+
+#if defined(__APPLE__)
+#include <pthread.h>
+#include <pthread/qos.h>
+#elif defined(__ANDROID__)
+#include <pthread.h>
+#include <sys/resource.h>
+#include <unistd.h>
+#endif
+
+namespace RNSkia {
+
+/**
+ * The threads that replay recordings for SkiaGraphiteViews, so that neither
+ * the JS thread nor the UI thread pays for a frame. Jobs run in submission
+ * order on the first free thread; a view never has more than one job in
+ * flight, so views are what run in parallel.
+ */
+class RNSkThreadPool {
+public:
+  static RNSkThreadPool &getInstance() {
+    // Never destroyed: the threads are detached and the process takes them
+    // down, which spares the static destructor from joining them at exit.
+    static auto *instance = new RNSkThreadPool();
+    return *instance;
+  }
+
+  RNSkThreadPool(const RNSkThreadPool &) = delete;
+  RNSkThreadPool &operator=(const RNSkThreadPool &) = delete;
+
+  void post(std::function<void()> job) {
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      _jobs.push_back(std::move(job));
+    }
+    _condition.notify_one();
+  }
+
+private:
+  RNSkThreadPool() {
+    auto cores = std::thread::hardware_concurrency();
+    const unsigned size = cores == 0 ? 2u : std::clamp(cores / 2, 2u, 4u);
+    for (unsigned i = 0; i < size; i++) {
+      std::thread([this, i]() { run(i); }).detach();
+    }
+  }
+
+  static void configureThread(unsigned index) {
+    auto name = "RNSkia Render " + std::to_string(index + 1);
+#if defined(__APPLE__)
+    pthread_setname_np(name.c_str());
+    // Frames are presented on the next vsync: the same class the UI uses.
+    pthread_set_qos_class_self_np(QOS_CLASS_USER_INTERACTIVE, 0);
+#elif defined(__ANDROID__)
+    pthread_setname_np(pthread_self(), name.c_str());
+    // ANDROID_PRIORITY_DISPLAY; with PRIO_PROCESS and who = 0, Linux applies
+    // the nice value to the calling thread only.
+    setpriority(PRIO_PROCESS, 0, -4);
+#endif
+  }
+
+  void run(unsigned index) {
+    configureThread(index);
+    for (;;) {
+      std::function<void()> job;
+      {
+        std::unique_lock<std::mutex> lock(_mutex);
+        _condition.wait(lock, [this]() { return !_jobs.empty(); });
+        job = std::move(_jobs.front());
+        _jobs.pop_front();
+      }
+      job();
+    }
+  }
+
+  std::mutex _mutex;
+  std::condition_variable _condition;
+  std::deque<std::function<void()>> _jobs;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkView.h

@@ -230,6 +230,24 @@ public:
   virtual void setJsiProperties(
       std::unordered_map<std::string, RNJsi::ViewProperty> &props) = 0;
 
+  /**
+   Reads the shared values on the calling runtime into the recording the
+   view owns and schedules a frame. Returns false when there is nothing to
+   update: no recording, or one other than recorderId (a stale mapper).
+   */
+  virtual bool applyUpdates(jsi::Runtime &runtime, double recorderId,
+                            const jsi::Array &values) {
+    return false;
+  }
+
+  /**
+   Releases the content the view draws without scheduling a frame: the host
+   view is torn down. On Android the native view outlives the Java view
+   until it is finalized, so the resources go away here rather than with the
+   garbage collector.
+   */
+  virtual void releaseContent() {}
+
   void requestRedraw() {
     if (!_redrawRequested) {
       _redrawRequested = true;

package/cpp/skia/src/gpu/graphite/ContextOptionsPriv.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_ContextOptionsPriv_DEFINED
+#define skgpu_graphite_ContextOptionsPriv_DEFINED
+
+#include "include/private/SkMath.h"
+
+#include <optional>
+
+namespace skgpu::graphite {
+
+enum class PathRendererStrategy;
+
+/**
+ * Private options that are only meant for testing within Skia's tools.
+ */
+struct ContextOptionsPriv {
+
+    int  fMaxTextureSizeOverride = SK_MaxS32;
+
+    /**
+     * If true, will store a pointer in Recorder that points back to the Context
+     * that created it. Used by readPixels() and other methods that normally require a Context.
+     */
+    bool fStoreContextRefInRecorder = false;
+
+    /**
+     * If true, enables layer based draw ordering.
+     */
+    bool fDrawListLayer = false;
+
+    /**
+     * Override Caps' default strategy heuristics to prioritize this one if set *and* is supported.
+     */
+    std::optional<PathRendererStrategy> fPathRendererStrategy;
+};
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_ContextOptionsPriv_DEFINED