react-native-skia 0.0.1 → 3.0.0

package/cpp/rnskia/RNSkPictureView.h

@@ -0,0 +1,211 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "RNSkView.h"
+#include "jsi/ViewProperty.h"
+
+#include "RNSkPlatformContext.h"
+#include "api/JsiSkPicture.h"
+#include "utils/RNSkLog.h"
+#include "utils/RNSkTimingInfo.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkBBHFactory.h"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPictureRecorder.h"
+
+#pragma clang diagnostic pop
+
+class SkPicture;
+struct SkRect;
+class SkImage;
+
+namespace RNSkia {
+
+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>
+ * driven by Reanimated shared values). The recorder is owned by the
+ * renderer, not by a JS wrapper: its commands hold every native resource the
+ * canvas draws (images, pictures, paths), and tying their lifetime to the
+ * garbage collector of a runtime that rarely allocates (the UI runtime) kept
+ * them resident long after unmount. Here they are released as soon as the
+ * recorder is replaced, or when the host view is torn down (see clear()).
+ *
+ * Threading: setPicture/setRecorder run on the JS thread (React commit),
+ * applyUpdates on the UI thread (Reanimated mapper), drawInto on the main
+ * thread (onscreen draws) or the JS thread (snapshots). _mutex only guards
+ * the two pointers, so a commit never waits for a draw; the recorder
+ * serializes its replay against its updates on its own.
+ */
+class RNSkPictureRenderer
+    : public RNSkRenderer,
+      public std::enable_shared_from_this<RNSkPictureRenderer> {
+public:
+  RNSkPictureRenderer(std::function<void()> requestRedraw,
+                      std::shared_ptr<RNSkPlatformContext> context)
+      : RNSkRenderer(std::move(requestRedraw)),
+        _platformContext(std::move(context)) {}
+
+  virtual ~RNSkPictureRenderer() = default;
+
+  void
+  renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override {
+    performDraw(canvasProvider);
+  }
+
+  void setPicture(sk_sp<SkPicture> picture) {
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      _picture = picture;
+      _recorder = nullptr;
+    }
+    _requestRedraw();
+  }
+
+  /**
+   * Takes ownership of a recorder. A recording without shared values is
+   * played once into a picture here (and its commands released): nothing
+   * will ever update it, and drawing a picture on every redraw (resize,
+   * foreground, ref.redraw(), snapshots) is cheaper than replaying commands.
+   * The previous recorder (and the resources its commands reference) is
+   * released here; Recorder's destructor moves the commands to the main
+   * thread before destroying them so GPU-backed resources are freed on the
+   * thread that used them.
+   */
+  void setRecorder(std::shared_ptr<Recorder> recorder);
+
+  /**
+   * Drops the recorder and the picture without scheduling a redraw. Called
+   * when the host view is torn down, so that the resources go away with the
+   * view rather than with the garbage collection of its host object (on
+   * Android the native view is only destroyed when the Java view is
+   * finalized).
+   */
+  void clear() {
+    std::shared_ptr<Recorder> retired;
+    sk_sp<SkPicture> picture;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      retired = std::move(_recorder);
+      picture = std::move(_picture);
+    }
+    // Both are destroyed here, outside the lock.
+  }
+
+  /**
+   * Reads the shared values on the calling runtime into the recorder's
+   * commands. Returns false when there is no recorder to update, or when the
+   * view holds a different recording than recorderId (a stale mapper whose
+   * values would otherwise land in the new recording's slots).
+   */
+  bool applyUpdates(jsi::Runtime &runtime, double recorderId,
+                    const jsi::Array &values);
+
+  /**
+   * Same as applyUpdates(), for a recording that no view owns yet (one
+   * queued in the view registry until its view registers).
+   */
+  static bool applyUpdatesTo(const std::shared_ptr<Recorder> &recorder,
+                             jsi::Runtime &runtime, double recorderId,
+                             const jsi::Array &values);
+
+  /**
+   * Draws the current content (recorder or picture) into the canvas, scaled
+   * by the pixel density. Used for onscreen draws, snapshots and the Android
+   * bitmap export.
+   */
+  void drawInto(SkCanvas *canvas, float pixelDensity) {
+    // Copy the content under the lock and draw from the copies: a React
+    // commit swapping the content must only ever wait for a pointer swap,
+    // never for a draw. If the recorder is replaced mid-draw, this frame
+    // finishes with the old one and the swap schedules the next frame.
+    std::shared_ptr<Recorder> recorder;
+    sk_sp<SkPicture> picture;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      recorder = _recorder;
+      picture = _picture;
+    }
+    drawContent(canvas, recorder.get(), picture, pixelDensity);
+  }
+
+private:
+  bool performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
+    auto pd = _platformContext->getPixelDensity();
+    return canvasProvider->renderToCanvas(
+        [this, pd](SkCanvas *canvas) { drawInto(canvas, pd); });
+  }
+
+  std::shared_ptr<RNSkPlatformContext> _platformContext;
+  mutable std::mutex _mutex;
+  sk_sp<SkPicture> _picture;
+  std::shared_ptr<Recorder> _recorder;
+};
+
+class RNSkPictureView : public RNSkView {
+public:
+  /**
+   * Constructor
+   */
+  RNSkPictureView(std::shared_ptr<RNSkPlatformContext> context,
+                  std::shared_ptr<RNSkCanvasProvider> canvasProvider)
+      : RNSkView(
+            context, canvasProvider,
+            std::make_shared<RNSkPictureRenderer>(
+                std::bind(&RNSkPictureView::requestRedraw, this), context)) {}
+
+  void setJsiProperties(
+      std::unordered_map<std::string, RNJsi::ViewProperty> &props) override {
+    auto renderer =
+        std::static_pointer_cast<RNSkPictureRenderer>(getRenderer());
+    for (auto &prop : props) {
+      if (prop.first == "picture") {
+        renderer->setPicture(prop.second.isPicture() ? prop.second.getPicture()
+                                                     : nullptr);
+      } else if (prop.first == "recorder") {
+        renderer->setRecorder(
+            prop.second.isRecorder() ? prop.second.getRecorder() : nullptr);
+      }
+    }
+  }
+
+  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/RNSkPlatformContext.h

@@ -0,0 +1,204 @@
+#pragma once
+
+#include <exception>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "RNSkVideo.h"
+#include "RNWindowContext.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkData.h"
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkStream.h"
+#include "include/core/SkSurface.h"
+
+#pragma clang diagnostic pop
+
+#include <ReactCommon/CallInvoker.h>
+
+namespace RNSkia {
+
+namespace react = facebook::react;
+
+struct TextureInfo {
+  const void *mtlTexture = nullptr;
+  unsigned int glTarget = 0;
+  unsigned int glID = 0;
+  unsigned int glFormat = 0;
+  bool glProtected = false;
+};
+
+class RNSkPlatformContext {
+public:
+  /**
+   * Constructor
+   */
+  RNSkPlatformContext(std::shared_ptr<react::CallInvoker> callInvoker,
+                      float pixelDensity)
+      : _pixelDensity(pixelDensity), _callInvoker(callInvoker) {}
+
+  virtual ~RNSkPlatformContext() = default;
+
+  /**
+   * Schedules the function to be run on the javascript thread async
+   * @param func Function to run
+   */
+  void runOnJavascriptThread(std::function<void()> func) {
+    _callInvoker->invokeAsync(std::move(func));
+  }
+
+  /**
+   * Runs the passed function on the main thread
+   * @param func Function to run.
+   */
+  virtual void runOnMainThread(std::function<void()> func) = 0;
+
+  /**
+   * Takes a screenshot of a given view represented by the view tag
+   * @param tag React view tag
+   */
+  virtual sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) = 0;
+
+  /**
+   * Returns an SkStream wrapping the require uri provided.
+   * @param sourceUri Uri for the resource to load as a string
+   * @op Operation to execute when the stream has successfuly been loaded.
+   */
+  virtual void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) = 0;
+
+  /**
+   * Raises an exception on the platform. This function does not necessarily
+   * throw an exception and stop execution, so it is important to stop execution
+   * by returning after calling the function
+   * @param err Error to raise
+   */
+  virtual void raiseError(const std::exception &err) = 0;
+
+  /**
+   * Creates an offscreen surface
+   * @param width Width of the offscreen surface
+   * @param height Height of the offscreen surface
+   * @param useP3ColorSpace If true, surface will use Display P3 color space
+   * @return sk_sp<SkSurface>
+   */
+  virtual sk_sp<SkSurface>
+  makeOffscreenSurface(int width, int height, bool useP3ColorSpace = false) = 0;
+
+  /**
+   * Creates an image from a native buffer.
+   * - On iOS, this is a `CVPixelBufferRef`
+   * - On Android, this is a `AHardwareBuffer*`
+   * @param buffer The native buffer.
+   * @return sk_sp<SkImage>
+   */
+  virtual sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) = 0;
+
+#if !defined(SK_GRAPHITE)
+  virtual sk_sp<SkImage>
+  makeImageFromNativeTexture(const TextureInfo &textureInfo, int width,
+                             int height, bool mipMapped) = 0;
+
+  virtual const TextureInfo getTexture(sk_sp<SkSurface> image) = 0;
+
+  virtual const TextureInfo getTexture(sk_sp<SkImage> image) = 0;
+
+  virtual GrDirectContext *getDirectContext() = 0;
+#else
+  sk_sp<SkImage> makeImageFromNativeTexture(const TextureInfo &textureInfo,
+                                            int width, int height,
+                                            bool mipMapped) {
+    throw std::runtime_error(
+        "makeImageFromNativeTexture not implemented yet on Graphite");
+  }
+
+  const TextureInfo getTexture(sk_sp<SkSurface> image) {
+    throw std::runtime_error(
+        "getTexture(surface) not implemented yet on Graphite");
+  }
+
+  const TextureInfo getTexture(sk_sp<SkImage> image) {
+    throw std::runtime_error(
+        "getTexture(image) not implemented yet on Graphite");
+  }
+#endif
+
+  virtual void releaseNativeBuffer(uint64_t pointer) = 0;
+
+  virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
+
+  // Allocate a platform native buffer (IOSurface on Apple, AHardwareBuffer on
+  // Android) of the given size filled with a procedural test pattern (RGB
+  // gradient + diagonal stripes), entirely on the CPU. Intended for examples
+  // and tests that need a buffer to feed into importExternalTexture without a
+  // camera/video source. Release it with releaseNativeBuffer().
+  virtual uint64_t makeTestNativeBuffer(int width, int height) = 0;
+
+  virtual std::shared_ptr<RNSkVideo> createVideo(const std::string &url) = 0;
+
+  /**
+   * Return the Platform specific font manager
+   */
+  virtual sk_sp<SkFontMgr> createFontMgr() = 0;
+
+  /**
+   * Return platform-specific system font family names that aren't
+   * enumerated by the standard font manager (e.g., .AppleSystemUIFont on iOS)
+   */
+  virtual std::vector<std::string> getSystemFontFamilies() { return {}; }
+
+  /**
+   * Resolve font family aliases to actual font family names.
+   * For example, "System" on iOS resolves to ".AppleSystemUIFont".
+   * Returns the input unchanged if no mapping exists.
+   */
+  virtual std::string resolveFontFamily(const std::string &familyName) {
+    return familyName;
+  }
+
+  /**
+   * Creates an skImage containing the screenshot of a native view and its
+   * children.
+   * @param viewTag React viewtag
+   * @param callback Called when image is ready or with null if something
+   * failed.
+   */
+  virtual void
+  makeViewScreenshot(int viewTag,
+                     std::function<void(sk_sp<SkImage>)> callback) {
+    runOnMainThread([this, callback, viewTag]() {
+      callback(takeScreenshotFromViewTag(viewTag));
+    });
+  }
+
+  /**
+   * Raises an exception on the platform. This function does not necessarily
+   * throw an exception and stop execution, so it is important to stop execution
+   * by returning after calling the function
+   * @param message Message to show
+   */
+  void raiseError(const std::string &message) {
+    return raiseError(std::runtime_error(message));
+  }
+
+  /**
+   * @return Current scale factor for pixels
+   */
+  float getPixelDensity() { return _pixelDensity; }
+
+private:
+  float _pixelDensity;
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+} // 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/RNSkVideo.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkImage.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class RNSkVideo {
+public:
+  virtual ~RNSkVideo() = default;
+  virtual sk_sp<SkImage> nextImage(double *timeStamp = nullptr) = 0;
+  virtual double duration() = 0;
+  virtual double framerate() = 0;
+  virtual double currentTime() = 0;
+  virtual void seek(double timestamp) = 0;
+  virtual float getRotationInDegrees() = 0;
+  virtual SkISize getSize() = 0;
+  virtual void play() = 0;
+  virtual void pause() = 0;
+  virtual void setVolume(float volume) = 0;
+  virtual void setLooping(bool looping) = 0;
+  virtual bool isPlaying() = 0;
+};
+
+} // namespace RNSkia