@shopify/react-native-skia 2.2.19 → 2.2.20

package/android/CMakeLists.txt

@@ -126,6 +126,8 @@ add_library(
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/CSSColorParser.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/base64.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/SkottieUtils.cpp"
+
+        "${PROJECT_SOURCE_DIR}/../cpp/api/JsiSkDispatcher.cpp"
         ${BACKEND_SOURCES}
 )
 

package/apple/SkiaCVPixelBufferUtils.mm

@@ -30,12 +30,16 @@
 #include <TargetConditionals.h>
 #if TARGET_RT_BIG_ENDIAN
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*((char *)&fourcc), *(((char *)&fourcc) + 1),                 \
-                 *(((char *)&fourcc) + 2), *(((char *)&fourcc) + 3), 0}
+  (const char[]) {                                                             \
+    *((char *)&fourcc), *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 2),    \
+        *(((char *)&fourcc) + 3), 0                                            \
+  }
 #else
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),           \
-                 *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0}
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
 #endif
 
 // pragma MARK: TextureHolder

package/cpp/api/JsiSkCanvas.h

@@ -34,6 +34,7 @@
 #include "include/core/SkRegion.h"
 #include "include/core/SkSurface.h"
 #include "include/core/SkTypeface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
 
 #pragma clang diagnostic pop
 
@@ -68,6 +69,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImage) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     std::shared_ptr<SkPaint> paint;
@@ -80,6 +82,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageRect) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto paint = JsiSkPaint::fromValue(runtime, arguments[3]);
@@ -92,6 +95,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageCubic) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     float B = arguments[3].asNumber();
@@ -108,6 +112,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageOptions) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto x = arguments[1].asNumber();
     auto y = arguments[2].asNumber();
     auto fm = (SkFilterMode)arguments[3].asNumber();
@@ -124,6 +129,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageNine) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto center = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto fm = (SkFilterMode)arguments[3].asNumber();
@@ -140,6 +146,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageRectCubic) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     float B = arguments[3].asNumber();
@@ -159,6 +166,7 @@ public:
 
   JSI_HOST_FUNCTION(drawImageRectOptions) {
     auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    validateImageForDrawing(runtime, image);
     auto src = JsiSkRect::fromValue(runtime, arguments[1]);
     auto dest = JsiSkRect::fromValue(runtime, arguments[2]);
     auto filter = (SkFilterMode)arguments[3].asNumber();
@@ -695,6 +703,20 @@ public:
   SkCanvas *getCanvas() { return _canvas; }
 
 private:
+  void validateImageForDrawing(jsi::Runtime &runtime,
+                               const sk_sp<SkImage> image) {
+#if !defined(SK_GRAPHITE)
+    auto ctx = getContext()->getDirectContext();
+    if (!ctx) {
+      throw jsi::JSError(runtime, "No GPU context available");
+    }
+    if (image && !image->isValid(ctx->asRecorder())) {
+      throw jsi::JSError(
+          runtime, "image used in drawImage() does not belong to this context");
+    }
+#endif
+  }
+
   SkCanvas *_canvas;
 };
 } // namespace RNSkia

package/cpp/api/JsiSkDispatcher.cpp

@@ -0,0 +1,9 @@
+#include "JsiSkDispatcher.h"
+
+namespace RNSkia {
+
+// Thread-local storage definition
+thread_local std::shared_ptr<Dispatcher::DispatcherData>
+    Dispatcher::_threadDispatcher;
+
+} // namespace RNSkia

package/cpp/api/JsiSkDispatcher.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <unordered_map>
+
+namespace RNSkia {
+
+/**
+ * Thread-local dispatcher for managing deferred operations.
+ * Each thread gets its own dispatcher instance for queueing operations
+ * to be executed on that specific thread.
+ */
+class Dispatcher {
+private:
+  using Operation = std::function<void()>;
+
+  struct DispatcherData {
+    std::queue<Operation> operationQueue;
+    std::mutex queueMutex;
+  };
+
+  // Thread-local storage for dispatcher data
+  static thread_local std::shared_ptr<DispatcherData> _threadDispatcher;
+
+  // Global registry of all dispatchers by thread ID
+  static inline std::mutex _registryMutex;
+  static inline std::unordered_map<std::thread::id,
+                                   std::weak_ptr<DispatcherData>>
+      _dispatcherRegistry;
+
+  std::shared_ptr<DispatcherData> _data;
+  std::thread::id _threadId;
+
+public:
+  Dispatcher() : _threadId(std::this_thread::get_id()) {
+    // Get or create dispatcher data for current thread
+    if (!_threadDispatcher) {
+      _threadDispatcher = std::make_shared<DispatcherData>();
+
+      // Register in global registry
+      std::lock_guard<std::mutex> lock(_registryMutex);
+      _dispatcherRegistry[_threadId] = _threadDispatcher;
+    }
+    _data = _threadDispatcher;
+  }
+
+  /**
+   * Get the dispatcher for the current thread.
+   * Creates one if it doesn't exist.
+   */
+  static std::shared_ptr<Dispatcher> getDispatcher() {
+    return std::make_shared<Dispatcher>();
+  }
+
+  /**
+   * Get the dispatcher for a specific thread.
+   * Returns nullptr if that thread doesn't have a dispatcher.
+   */
+  static std::shared_ptr<Dispatcher> getDispatcher(std::thread::id threadId) {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    auto it = _dispatcherRegistry.find(threadId);
+    if (it != _dispatcherRegistry.end()) {
+      if (auto data = it->second.lock()) {
+        auto dispatcher = std::make_shared<Dispatcher>();
+        dispatcher->_data = data;
+        dispatcher->_threadId = threadId;
+        return dispatcher;
+      }
+    }
+    return nullptr;
+  }
+
+  /**
+   * Queue an operation to be executed on the dispatcher's thread.
+   * The operation will be executed when processQueue() is called on that
+   * thread.
+   */
+  void run(Operation op) {
+    if (!_data)
+      return;
+
+    std::lock_guard<std::mutex> lock(_data->queueMutex);
+    _data->operationQueue.push(std::move(op));
+  }
+
+  /**
+   * Process all pending operations for the current thread.
+   * Must be called from the thread that owns this dispatcher.
+   * Returns the number of operations processed.
+   */
+  size_t processQueue() {
+    if (!_data)
+      return 0;
+
+    // Only process if we're on the correct thread
+    if (std::this_thread::get_id() != _threadId) {
+      return 0;
+    }
+
+    std::queue<Operation> operations;
+    {
+      std::lock_guard<std::mutex> lock(_data->queueMutex);
+      operations.swap(_data->operationQueue);
+    }
+
+    size_t count = operations.size();
+    while (!operations.empty()) {
+      auto &op = operations.front();
+      op();
+      operations.pop();
+    }
+
+    return count;
+  }
+
+  /**
+   * Get the number of pending operations.
+   */
+  size_t getPendingCount() const {
+    if (!_data)
+      return 0;
+
+    std::lock_guard<std::mutex> lock(_data->queueMutex);
+    return _data->operationQueue.size();
+  }
+
+  /**
+   * Clean up dispatcher for a thread that's shutting down.
+   */
+  static void cleanup() {
+    if (_threadDispatcher) {
+      // Process any remaining operations
+      auto dispatcher = getDispatcher();
+      dispatcher->processQueue();
+
+      // Remove from registry
+      std::lock_guard<std::mutex> lock(_registryMutex);
+      _dispatcherRegistry.erase(std::this_thread::get_id());
+
+      _threadDispatcher.reset();
+    }
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -4,11 +4,11 @@
 #include <string>
 #include <utility>
 
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkImageInfo.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkShader.h"
-#include "JsiSkThreadSafeDeletion.h"
 #include "third_party/base64.h"
 
 #include "JsiTextureInfo.h"
@@ -63,7 +63,7 @@ inline SkSamplingOptions SamplingOptionsFromValue(jsi::Runtime &runtime,
 
 class JsiSkImage : public JsiSkWrappingSkPtrHostObject<SkImage> {
 private:
-  ThreadSafeDeletion<SkImage> _deletionHandler;
+  std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
   // TODO-API: Properties?
@@ -258,6 +258,10 @@ public:
     return JsiTextureInfo::toValue(runtime, texInfo);
   }
 
+  JSI_HOST_FUNCTION(isTextureBacked) {
+    return jsi::Value(getObject()->isTextureBacked());
+  }
+
   EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImage, width),
@@ -270,27 +274,41 @@ public:
                        JSI_EXPORT_FUNC(JsiSkImage, readPixels),
                        JSI_EXPORT_FUNC(JsiSkImage, makeNonTextureImage),
                        JSI_EXPORT_FUNC(JsiSkImage, getNativeTextureUnstable),
+                       JSI_EXPORT_FUNC(JsiSkImage, isTextureBacked),
                        JSI_EXPORT_FUNC(JsiSkImage, dispose))
 
   JsiSkImage(std::shared_ptr<RNSkPlatformContext> context,
              const sk_sp<SkImage> image)
       : JsiSkWrappingSkPtrHostObject<SkImage>(std::move(context),
                                               std::move(image)) {
-    // Drain any pending deletions when creating new images
-    ThreadSafeDeletion<SkImage>::drainDeletionQueue();
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
   }
 
   ~JsiSkImage() override {
-    // Handle thread-safe deletion
-    _deletionHandler.handleDeletion(getObject());
-    // Always clear the object to prevent base class destructor from deleting it
-    // handleDeletion takes full responsibility for the object's lifetime
+    // Queue deletion on the creation thread if needed
+    auto image = getObject();
+    if (image && _dispatcher) {
+      _dispatcher->run([image]() {
+        // Image will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
     setObject(nullptr);
   }
 
   size_t getMemoryPressure() const override {
     auto image = getObject();
-    return image ? image->imageInfo().computeMinByteSize() : 0;
+    if (image) {
+      if (image->isTextureBacked()) {
+        return image->textureSize();
+      } else {
+        return image->imageInfo().computeMinByteSize();
+      }
+    }
+    return 0;
   }
 };
 

package/cpp/api/JsiSkPicture.h

@@ -3,6 +3,7 @@
 #include <memory>
 
 #include "JsiSkData.h"
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkRect.h"
@@ -20,10 +21,30 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 
 class JsiSkPicture : public JsiSkWrappingSkPtrHostObject<SkPicture> {
+private:
+  std::shared_ptr<Dispatcher> _dispatcher;
+
 public:
   JsiSkPicture(std::shared_ptr<RNSkPlatformContext> context,
                const sk_sp<SkPicture> picture)
-      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {}
+      : JsiSkWrappingSkPtrHostObject<SkPicture>(context, picture) {
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
+  }
+
+  ~JsiSkPicture() override {
+    // Queue deletion on the creation thread if needed
+    auto picture = getObject();
+    if (picture && _dispatcher) {
+      _dispatcher->run([picture]() {
+        // Picture will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
+    setObject(nullptr);
+  }
 
   JSI_HOST_FUNCTION(makeShader) {
     auto tmx = (SkTileMode)arguments[0].asNumber();

package/cpp/api/JsiSkSurface.h

@@ -5,8 +5,8 @@
 
 #include <jsi/jsi.h>
 
+#include "JsiSkDispatcher.h"
 #include "JsiSkHostObjects.h"
-#include "JsiSkThreadSafeDeletion.h"
 #include "JsiTextureInfo.h"
 
 #include "JsiSkCanvas.h"
@@ -30,23 +30,28 @@ namespace jsi = facebook::jsi;
 
 class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
 private:
-  ThreadSafeDeletion<SkSurface> _deletionHandler;
+  std::shared_ptr<Dispatcher> _dispatcher;
 
 public:
   JsiSkSurface(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkSurface> surface)
       : JsiSkWrappingSkPtrHostObject<SkSurface>(std::move(context),
-                                                std::move(surface)),
-        _deletionHandler() {
-    // Drain any pending deletions when creating new surfaces
-    ThreadSafeDeletion<SkSurface>::drainDeletionQueue();
+                                                std::move(surface)) {
+    // Get the dispatcher for the current thread
+    _dispatcher = Dispatcher::getDispatcher();
+    // Process any pending operations
+    _dispatcher->processQueue();
   }
 
   ~JsiSkSurface() override {
-    // Handle thread-safe deletion
-    _deletionHandler.handleDeletion(getObject());
-    // Always clear the object to prevent base class destructor from deleting it
-    // handleDeletion takes full responsibility for the object's lifetime
+    // Queue deletion on the creation thread if needed
+    auto surface = getObject();
+    if (surface && _dispatcher) {
+      _dispatcher->run([surface]() {
+        // Surface will be deleted when this lambda is destroyed
+      });
+    }
+    // Clear the object to prevent base class destructor from deleting it
     setObject(nullptr);
   }
 

package/cpp/api/recorder/Drawings.h

@@ -6,6 +6,7 @@
 #include "Convertor.h"
 #include "DrawingCtx.h"
 #include "ImageFit.h"
+#include "RNSkPlatformContext.h"
 
 namespace RNSkia {
 
@@ -468,10 +469,11 @@ struct ImageCmdProps {
 class ImageCmd : public Command {
 public:
   ImageCmdProps props;
+  std::shared_ptr<RNSkPlatformContext> _context;
 
-  ImageCmd(jsi::Runtime &runtime, const jsi::Object &object,
-           Variables &variables)
-      : Command(CommandType::DrawImage) {
+  ImageCmd(std::shared_ptr<RNSkPlatformContext> context, jsi::Runtime &runtime,
+           const jsi::Object &object, Variables &variables)
+      : Command(CommandType::DrawImage), _context(context) {
     convertProperty(runtime, object, "rect", props.rect, variables);
     convertProperty(runtime, object, "image", props.image, variables);
     convertProperty(runtime, object, "sampling", props.sampling, variables);
@@ -484,6 +486,17 @@ public:
     convertProperty(runtime, object, "rect", props.rect, variables);
   }
 
+  ~ImageCmd() {
+    if (props.image.has_value()) {
+      auto image = props.image.value();
+      if (image) {
+        _context->runOnMainThread([image]() {
+          // Image will be deleted when this lambda is destroyed on main thread
+        });
+      }
+    }
+  }
+
   void draw(DrawingCtx *ctx) {
     auto [x, y, width, height, rect, fit, image, sampling] = props;
     if (image.has_value()) {
@@ -784,13 +797,24 @@ struct PictureCmdProps {
 class PictureCmd : public Command {
 public:
   PictureCmdProps props;
+  std::shared_ptr<RNSkPlatformContext> _context;
 
-  PictureCmd(jsi::Runtime &runtime, const jsi::Object &object,
+  PictureCmd(std::shared_ptr<RNSkPlatformContext> context,
+             jsi::Runtime &runtime, const jsi::Object &object,
              Variables &variables)
-      : Command(CommandType::DrawPicture) {
+      : Command(CommandType::DrawPicture), _context(context) {
     convertProperty(runtime, object, "picture", props.picture, variables);
   }
 
+  ~PictureCmd() {
+    auto picture = props.picture;
+    if (picture) {
+      _context->runOnMainThread([picture]() {
+        // Picture will be deleted when this lambda is destroyed on main thread
+      });
+    }
+  }
+
   void draw(DrawingCtx *ctx) { ctx->canvas->drawPicture(props.picture); }
 };
 
@@ -914,10 +938,11 @@ struct AtlasCmdProps {
 class AtlasCmd : public Command {
 public:
   AtlasCmdProps props;
+  std::shared_ptr<RNSkPlatformContext> _context;
 
-  AtlasCmd(jsi::Runtime &runtime, const jsi::Object &object,
-           Variables &variables)
-      : Command(CommandType::DrawAtlas) {
+  AtlasCmd(std::shared_ptr<RNSkPlatformContext> context, jsi::Runtime &runtime,
+           const jsi::Object &object, Variables &variables)
+      : Command(CommandType::DrawAtlas), _context(context) {
     convertProperty(runtime, object, "image", props.image, variables);
     convertProperty(runtime, object, "sprites", props.sprites, variables);
     convertProperty(runtime, object, "transforms", props.transforms, variables);
@@ -926,6 +951,15 @@ public:
     convertProperty(runtime, object, "sampling", props.sampling, variables);
   }
 
+  ~AtlasCmd() {
+    auto image = props.image;
+    if (image) {
+      _context->runOnMainThread([image]() {
+        // Image will be deleted when this lambda is destroyed on main thread
+      });
+    }
+  }
+
   void draw(DrawingCtx *ctx) {
     if (props.image) {
       // Validate transforms and sprites have the same size
@@ -956,4 +990,4 @@ public:
   }
 };
 
-} // namespace RNSkia
+} // namespace RNSkia

package/cpp/api/recorder/JsiRecorder.h

@@ -22,7 +22,9 @@ class JsiRecorder : public JsiSkWrappingSharedPtrHostObject<Recorder> {
 public:
   JsiRecorder(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkWrappingSharedPtrHostObject(std::move(context),
-                                         std::make_shared<Recorder>()) {}
+                                         std::make_shared<Recorder>()) {
+    getObject()->_context = getContext();
+  }
 
   JSI_HOST_FUNCTION(savePaint) {
     getObject()->savePaint(runtime, arguments[0].asObject(runtime),

package/cpp/api/recorder/RNRecorder.h

@@ -15,6 +15,7 @@
 #include "ImageFilters.h"
 #include "Paint.h"
 #include "PathEffects.h"
+#include "RNSkPlatformContext.h"
 #include "Shaders.h"
 
 namespace RNSkia {
@@ -24,8 +25,10 @@ private:
   std::vector<std::unique_ptr<Command>> commands;
 
 public:
+  std::shared_ptr<RNSkPlatformContext> _context;
   Variables variables;
 
+  Recorder() = default;
   ~Recorder() = default;
 
   void savePaint(jsi::Runtime &runtime, const jsi::Object &props,
@@ -216,7 +219,8 @@ public:
   }
 
   void drawImage(jsi::Runtime &runtime, const jsi::Object &props) {
-    commands.push_back(std::make_unique<ImageCmd>(runtime, props, variables));
+    commands.push_back(
+        std::make_unique<ImageCmd>(_context, runtime, props, variables));
   }
 
   void drawPoints(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -255,7 +259,8 @@ public:
   }
 
   void drawPicture(jsi::Runtime &runtime, const jsi::Object &props) {
-    commands.push_back(std::make_unique<PictureCmd>(runtime, props, variables));
+    commands.push_back(
+        std::make_unique<PictureCmd>(_context, runtime, props, variables));
   }
 
   void drawImageSVG(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -269,7 +274,8 @@ public:
   }
 
   void drawAtlas(jsi::Runtime &runtime, const jsi::Object &props) {
-    commands.push_back(std::make_unique<AtlasCmd>(runtime, props, variables));
+    commands.push_back(
+        std::make_unique<AtlasCmd>(_context, runtime, props, variables));
   }
 
   void drawSkottie(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -646,4 +652,4 @@ public:
   }
 };
 
-} // namespace RNSkia
+} // namespace RNSkia