@shopify/react-native-skia 1.5.10 → 1.7.0

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -9,9 +9,9 @@
 #include <vector>
 
 #include "JsiHostObject.h"
-#include "JsiValueWrapper.h"
 #include "RNSkPlatformContext.h"
 #include "RNSkView.h"
+#include "ViewProperty.h"
 #include <jsi/jsi.h>
 
 namespace RNSkia {
@@ -20,7 +20,7 @@ namespace jsi = facebook::jsi;
 using RNSkViewInfo = struct RNSkViewInfo {
   RNSkViewInfo() { view = nullptr; }
   std::shared_ptr<RNSkView> view;
-  std::unordered_map<std::string, RNJsi::JsiValueWrapper> props;
+  std::unordered_map<std::string, RNJsi::ViewProperty> props;
 };
 
 class RNSkJsiViewApi : public RNJsi::JsiHostObject,
@@ -57,7 +57,7 @@ public:
     auto info = getEnsuredViewInfo(nativeId);
 
     info->props.insert_or_assign(arguments[1].asString(runtime).utf8(runtime),
-                                 RNJsi::JsiValueWrapper(runtime, arguments[2]));
+                                 RNJsi::ViewProperty(runtime, arguments[2]));
 
     // Now let's see if we have a view that we can update
     if (info->view != nullptr) {

package/cpp/rnskia/RNSkPictureView.h

@@ -9,8 +9,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiValueWrapper.h"
 #include "RNSkView.h"
+#include "ViewProperty.h"
 
 #include "JsiSkPicture.h"
 #include "RNSkLog.h"
@@ -40,46 +40,36 @@ class RNSkPictureRenderer
 public:
   RNSkPictureRenderer(std::function<void()> requestRedraw,
                       std::shared_ptr<RNSkPlatformContext> context)
-      : RNSkRenderer(requestRedraw), _platformContext(context) {}
-
-  bool tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override {
-    return performDraw(canvasProvider);
-  }
+      : RNSkRenderer(std::move(requestRedraw)),
+        _platformContext(std::move(context)) {}
 
   void
   renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override {
     performDraw(canvasProvider);
   }
 
-  void setPicture(std::shared_ptr<jsi::HostObject> picture) {
-    if (picture == nullptr) {
-      _picture = nullptr;
-    } else {
-      _picture = std::dynamic_pointer_cast<JsiSkPicture>(picture);
-    }
+  void setPicture(sk_sp<SkPicture> picture) {
+    _picture = picture;
     _requestRedraw();
   }
 
 private:
   bool performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
-    canvasProvider->renderToCanvas([=](SkCanvas *canvas) {
+    return canvasProvider->renderToCanvas([=](SkCanvas *canvas) {
       // Make sure to scale correctly
       auto pd = _platformContext->getPixelDensity();
       canvas->clear(SK_ColorTRANSPARENT);
       canvas->save();
       canvas->scale(pd, pd);
-
       if (_picture != nullptr) {
-        canvas->drawPicture(_picture->getObject());
+        canvas->drawPicture(_picture);
       }
-
       canvas->restore();
     });
-    return true;
   }
 
   std::shared_ptr<RNSkPlatformContext> _platformContext;
-  std::shared_ptr<JsiSkPicture> _picture;
+  sk_sp<SkPicture> _picture;
 };
 
 class RNSkPictureView : public RNSkView {
@@ -95,27 +85,20 @@ public:
                 std::bind(&RNSkPictureView::requestRedraw, this), context)) {}
 
   void setJsiProperties(
-      std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) override {
-
-    RNSkView::setJsiProperties(props);
+      std::unordered_map<std::string, RNJsi::ViewProperty> &props) override {
 
     for (auto &prop : props) {
       if (prop.first == "picture") {
-        if (prop.second.isUndefinedOrNull()) {
+        if (prop.second.isNull()) {
           // Clear picture
           std::static_pointer_cast<RNSkPictureRenderer>(getRenderer())
               ->setPicture(nullptr);
           continue;
-        } else if (prop.second.getType() !=
-                   RNJsi::JsiWrapperValueType::HostObject) {
-          // We expect a function for the picture custom property
-          throw std::runtime_error(
-              "Expected an object for the picture custom property.");
         }
 
         // Save picture
         std::static_pointer_cast<RNSkPictureRenderer>(getRenderer())
-            ->setPicture(prop.second.getAsHostObject());
+            ->setPicture(prop.second.getPicture());
       }
     }
   }

package/cpp/rnskia/RNSkPlatformContext.h

@@ -23,8 +23,6 @@
 
 #pragma clang diagnostic pop
 
-#include <jsi/jsi.h>
-
 #include <ReactCommon/CallInvoker.h>
 
 namespace RNSkia {
@@ -32,16 +30,22 @@ namespace RNSkia {
 namespace jsi = facebook::jsi;
 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(jsi::Runtime *runtime,
-                      std::shared_ptr<react::CallInvoker> callInvoker,
+  RNSkPlatformContext(std::shared_ptr<react::CallInvoker> callInvoker,
                       float pixelDensity)
-      : _pixelDensity(pixelDensity), _jsRuntime(runtime),
-        _callInvoker(callInvoker) {}
+      : _pixelDensity(pixelDensity), _callInvoker(callInvoker) {}
 
   virtual ~RNSkPlatformContext() = default;
 
@@ -65,11 +69,6 @@ public:
    */
   virtual sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) = 0;
 
-  /**
-   Returns the javascript runtime
-   */
-  jsi::Runtime *getJsRuntime() { return _jsRuntime; }
-
   /**
    * Returns an SkStream wrapping the require uri provided.
    * @param sourceUri Uri for the resource to load as a string
@@ -107,6 +106,10 @@ public:
    */
   virtual sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) = 0;
 
+  virtual sk_sp<SkImage>
+  makeImageFromNativeTexture(const TextureInfo &textureInfo, int width,
+                             int height, bool mipMapped) = 0;
+
 #if !defined(SK_GRAPHITE)
   virtual GrDirectContext *getDirectContext() = 0;
 #endif
@@ -115,6 +118,10 @@ public:
 
   virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
 
+  virtual const TextureInfo getTexture(sk_sp<SkSurface> image) = 0;
+
+  virtual const TextureInfo getTexture(sk_sp<SkImage> image) = 0;
+
   virtual std::shared_ptr<RNSkVideo> createVideo(const std::string &url) = 0;
 
   /**
@@ -154,7 +161,6 @@ public:
 
 private:
   float _pixelDensity;
-  jsi::Runtime *_jsRuntime;
   std::shared_ptr<react::CallInvoker> _callInvoker;
 };
 } // namespace RNSkia

package/cpp/rnskia/RNSkView.h

@@ -6,8 +6,8 @@
 #include <unordered_map>
 #include <vector>
 
-#include "JsiValueWrapper.h"
 #include "RNSkPlatformContext.h"
+#include "ViewProperty.h"
 
 #include "JsiSkImage.h"
 #include "JsiSkPoint.h"
@@ -52,33 +52,15 @@ protected:
 class RNSkRenderer {
 public:
   explicit RNSkRenderer(std::function<void()> requestRedraw)
-      : _requestRedraw(requestRedraw) {}
+      : _requestRedraw(std::move(requestRedraw)), _showDebugOverlays(false) {}
 
-  /**
-   Tries to render the current set of drawing operations. If we're busy we'll
-   return false so that the calling RNSkBaseDrawView can request a new render
-   next frame. The tryRender method is typically called on each frame if there
-   are any redraw requests. The method will be called from the main thread, so
-   the implementor must make sure any thread requirements are met before
-   rendering. This method will also allow the rendering to be dispatched to
-   another thread.
-   */
-  virtual bool
-  tryRender(std::shared_ptr<RNSkCanvasProvider> canvasProvider) = 0;
-
-  /**
-   Renders directly to the canvas in the canvas provider. This method is called
-   from a Javascript call to render a snapshot of the SkiaView to an image, and
-   can therefore run outside the tryRender loop and directly in the javascript
-   thread.
-   */
   virtual void
   renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) = 0;
 
   void setShowDebugOverlays(bool showDebugOverlays) {
     _showDebugOverlays = showDebugOverlays;
   }
-  bool getShowDebugOverlays() { return _showDebugOverlays; }
+  bool getShowDebugOverlays() const { return _showDebugOverlays; }
 
 protected:
   std::function<void()> _requestRedraw;
@@ -161,14 +143,8 @@ public:
    */
   virtual ~RNSkView() {}
 
-  /**
-   Sets custom properties. Custom properties are properties that are set
-   directly from Javascript without having to go through the async bridge.
-   */
   virtual void setJsiProperties(
-      std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) {
-    // Nothing here...
-  }
+      std::unordered_map<std::string, RNJsi::ViewProperty> &props) = 0;
 
   void requestRedraw() {
     if (!_redrawRequested) {
@@ -180,7 +156,7 @@ public:
         // Try to lock the weak pointer
         if (auto strongThis = weakThis.lock()) {
           // Only proceed if the object still exists
-          if (strongThis->_renderer) {
+          if (strongThis->_renderer && strongThis->_redrawRequested) {
             strongThis->_renderer->renderImmediate(strongThis->_canvasProvider);
             strongThis->_redrawRequested = false;
           }

package/ios/RNSkia-iOS/MetalContext.h

@@ -1,13 +1,64 @@
 #pragma once
 
-#include "SkiaMetalSurfaceFactory.h"
-#include "WindowContext.h"
+#include "MetalWindowContext.h"
+#include "SkiaCVPixelBufferUtils.h"
 
 #include "include/core/SkSurface.h"
 
-namespace RNSkia {
-class RNSkiOSPlatformContext;
-}
+#import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/GrDirectContext.h>
+#import <include/gpu/ganesh/SkImageGanesh.h>
+#import <include/gpu/ganesh/SkSurfaceGanesh.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendSurface.h>
+#import <include/gpu/ganesh/mtl/GrMtlDirectContext.h>
+#import <include/gpu/ganesh/mtl/SkSurfaceMetal.h>
+
+// namespace RNSkia {
+// class RNSkiOSPlatformContext;
+// }
+
+class MetalSharedContext {
+public:
+  static MetalSharedContext &getInstance() {
+    static MetalSharedContext instance;
+    return instance;
+  }
+
+  id<MTLDevice> getDevice() { return _device; }
+
+private:
+  MetalSharedContext() {
+    _device = MTLCreateSystemDefaultDevice();
+    if (!_device) {
+      throw std::runtime_error("Failed to create Metal device");
+    }
+  }
+
+  MetalSharedContext(const MetalSharedContext &) = delete;
+  MetalSharedContext &operator=(const MetalSharedContext &) = delete;
+
+  id<MTLDevice> _device;
+};
+
+struct OffscreenRenderContext {
+  id<MTLTexture> texture;
+
+  OffscreenRenderContext(id<MTLDevice> device,
+                         sk_sp<GrDirectContext> skiaContext,
+                         id<MTLCommandQueue> commandQueue, int width,
+                         int height) {
+    // Create a Metal texture descriptor
+    MTLTextureDescriptor *textureDescriptor = [MTLTextureDescriptor
+        texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+                                     width:width
+                                    height:height
+                                 mipmapped:NO];
+    textureDescriptor.usage =
+        MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+    texture = [device newTextureWithDescriptor:textureDescriptor];
+  }
+};
 
 class MetalContext {
 
@@ -21,28 +72,63 @@ public:
   }
 
   sk_sp<SkSurface> MakeOffscreen(int width, int height) {
-    return SkiaMetalSurfaceFactory::makeOffscreenSurface(_device, &_context,
-                                                         width, height);
+    auto device = MetalSharedContext::getInstance().getDevice();
+    auto ctx = new OffscreenRenderContext(device, _directContext, _commandQueue,
+                                          width, height);
+
+    // Create a GrBackendTexture from the Metal texture
+    GrMtlTextureInfo info;
+    info.fTexture.retain((__bridge void *)ctx->texture);
+    GrBackendTexture backendTexture =
+        GrBackendTextures::MakeMtl(width, height, skgpu::Mipmapped::kNo, info);
+
+    // Create a SkSurface from the GrBackendTexture
+    auto surface = SkSurfaces::WrapBackendTexture(
+        _directContext.get(), backendTexture, kTopLeft_GrSurfaceOrigin, 0,
+        kBGRA_8888_SkColorType, nullptr, nullptr,
+        [](void *addr) { delete (OffscreenRenderContext *)addr; }, ctx);
+
+    return surface;
   }
 
   sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+
     CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
-    return SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(&_context,
-                                                                 sampleBuffer);
+    SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat format =
+        SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(sampleBuffer);
+    switch (format) {
+    case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::rgb: {
+      // CVPixelBuffer is in any RGB format, single-plane
+      return SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
+          _directContext.get(), sampleBuffer);
+    }
+    case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::yuv: {
+      // CVPixelBuffer is in any YUV format, multi-plane
+      return SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
+          _directContext.get(), sampleBuffer);
+    }
+    default:
+      [[unlikely]] {
+        throw std::runtime_error("Failed to convert NativeBuffer to SkImage - "
+                                 "NativeBuffer has unsupported PixelFormat! " +
+                                 std::to_string(static_cast<int>(format)));
+      }
+    }
   }
 
   std::unique_ptr<RNSkia::WindowContext> MakeWindow(CALayer *window, int width,
                                                     int height) {
-    return SkiaMetalSurfaceFactory::makeContext(&_context, window, width,
-                                                height);
+    auto device = MetalSharedContext::getInstance().getDevice();
+    return std::make_unique<MetalWindowContext>(
+        _directContext.get(), device, _commandQueue, window, width, height);
   }
 
-  GrDirectContext *getDirectContext() { return _context.skContext.get(); }
+  GrDirectContext *getDirectContext() { return _directContext.get(); }
 
 private:
-  friend class RNSkia::RNSkiOSPlatformContext;
-  id<MTLDevice> _device;
-  SkiaMetalContext _context;
+  // friend class RNSkia::RNSkiOSPlatformContext;
+  id<MTLCommandQueue> _commandQueue = nullptr;
+  sk_sp<GrDirectContext> _directContext = nullptr;
 
   MetalContext();
 };

package/ios/RNSkia-iOS/MetalContext.mm

@@ -1,5 +1,7 @@
 #include "MetalContext.h"
 
+#include "RNSkLog.h"
+
 #import <MetalKit/MetalKit.h>
 
 #pragma clang diagnostic push
@@ -16,18 +18,17 @@
 #pragma clang diagnostic pop
 
 MetalContext::MetalContext() {
-  _device = MTLCreateSystemDefaultDevice();
-  _context.commandQueue =
-      id<MTLCommandQueue>(CFRetain((GrMTLHandle)[_device newCommandQueue]));
-
+  auto device = MetalSharedContext::getInstance().getDevice();
+  _commandQueue =
+      id<MTLCommandQueue>(CFRetain((GrMTLHandle)[device newCommandQueue]));
   GrMtlBackendContext backendContext = {};
-  backendContext.fDevice.reset((__bridge void *)_device);
-  backendContext.fQueue.reset((__bridge void *)_context.commandQueue);
+  backendContext.fDevice.reset((__bridge void *)device);
+  backendContext.fQueue.reset((__bridge void *)_commandQueue);
   GrContextOptions grContextOptions; // set different options here.
 
   // Create the Skia Direct Context
-  _context.skContext = GrDirectContexts::MakeMetal(backendContext);
-  if (_context.skContext == nullptr) {
+  _directContext = GrDirectContexts::MakeMetal(backendContext);
+  if (_directContext == nullptr) {
     RNSkia::RNSkLogger::logToConsole("Couldn't create a Skia Metal Context");
   }
 }

package/ios/RNSkia-iOS/MetalWindowContext.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#import <MetalKit/MetalKit.h>
+
+#include "WindowContext.h"
+
+class SkiaMetalContext;
+
+class MetalWindowContext : public RNSkia::WindowContext {
+public:
+  MetalWindowContext(GrDirectContext *directContext, id<MTLDevice> device,
+                     id<MTLCommandQueue> commandQueue, CALayer *layer,
+                     int width, int height);
+  ~MetalWindowContext() = default;
+
+  sk_sp<SkSurface> getSurface() override;
+
+  void present() override;
+
+  int getWidth() override {
+    return _layer.frame.size.width * _layer.contentsScale;
+  };
+
+  int getHeight() override {
+    return _layer.frame.size.height * _layer.contentsScale;
+  };
+
+  void resize(int width, int height) override { _skSurface = nullptr; }
+
+private:
+  GrDirectContext *_directContext;
+  id<MTLCommandQueue> _commandQueue;
+  sk_sp<SkSurface> _skSurface = nullptr;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  CAMetalLayer *_layer;
+#pragma clang diagnostic pop
+  id<CAMetalDrawable> _currentDrawable = nil;
+};

package/ios/RNSkia-iOS/MetalWindowContext.mm

@@ -0,0 +1,60 @@
+#include "MetalWindowContext.h"
+
+#include "MetalContext.h"
+#include "RNSkLog.h"
+
+MetalWindowContext::MetalWindowContext(GrDirectContext *directContext,
+                                       id<MTLDevice> device,
+                                       id<MTLCommandQueue> commandQueue,
+                                       CALayer *layer, int width, int height)
+    : _directContext(directContext), _commandQueue(commandQueue) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  _layer = (CAMetalLayer *)layer;
+#pragma clang diagnostic pop
+  _layer.framebufferOnly = NO;
+  _layer.device = device;
+  _layer.opaque = false;
+  _layer.contentsScale = [UIScreen mainScreen].scale;
+  _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+  _layer.contentsGravity = kCAGravityBottomLeft;
+  _layer.drawableSize = CGSizeMake(width, height);
+}
+
+sk_sp<SkSurface> MetalWindowContext::getSurface() {
+  if (_skSurface) {
+    return _skSurface;
+  }
+
+  // Get the next drawable from the CAMetalLayer
+  _currentDrawable = [_layer nextDrawable];
+  if (!_currentDrawable) {
+    RNSkia::RNSkLogger::logToConsole(
+        "Could not retrieve drawable from CAMetalLayer");
+    return nullptr;
+  }
+
+  // Get the texture from the drawable
+  GrMtlTextureInfo fbInfo;
+  fbInfo.fTexture.retain((__bridge void *)_currentDrawable.texture);
+
+  GrBackendRenderTarget backendRT = GrBackendRenderTargets::MakeMtl(
+      _layer.drawableSize.width, _layer.drawableSize.height, fbInfo);
+
+  _skSurface = SkSurfaces::WrapBackendRenderTarget(
+      _directContext, backendRT, kTopLeft_GrSurfaceOrigin,
+      kBGRA_8888_SkColorType, nullptr, nullptr);
+
+  return _skSurface;
+}
+
+void MetalWindowContext::present() {
+  if (auto dContext = GrAsDirectContext(_skSurface->recordingContext())) {
+    dContext->flushAndSubmit();
+  }
+
+  id<MTLCommandBuffer> commandBuffer([_commandQueue commandBuffer]);
+  [commandBuffer presentDrawable:_currentDrawable];
+  [commandBuffer commit];
+  _skSurface = nullptr;
+}

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -22,33 +22,19 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
-static void handleNotification(CFNotificationCenterRef center, void *observer,
-                               CFStringRef name, const void *object,
-                               CFDictionaryRef userInfo);
-
 class RNSkiOSPlatformContext : public RNSkPlatformContext {
 public:
   RNSkiOSPlatformContext(
-      jsi::Runtime *runtime, RCTBridge *bridge,
+      RCTBridge *bridge,
       std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
-      : RNSkPlatformContext(runtime, jsCallInvoker,
-                            [[UIScreen mainScreen] scale]) {
-
-    // We need to make sure we invalidate when modules are freed
-    CFNotificationCenterAddObserver(
-        CFNotificationCenterGetLocalCenter(), this, &handleNotification,
-        (__bridge CFStringRef)RCTBridgeWillInvalidateModulesNotification, NULL,
-        CFNotificationSuspensionBehaviorDeliverImmediately);
+      : RNSkPlatformContext(jsCallInvoker, [[UIScreen mainScreen] scale]) {
 
     // Create screenshot manager
     _screenshotService =
         [[ViewScreenshotService alloc] initWithUiManager:bridge.uiManager];
   }
 
-  ~RNSkiOSPlatformContext() {
-    CFNotificationCenterRemoveEveryObserver(
-        CFNotificationCenterGetLocalCenter(), this);
-  }
+  ~RNSkiOSPlatformContext() = default;
 
   void runOnMainThread(std::function<void()>) override;
 
@@ -56,8 +42,16 @@ public:
 
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override;
 
+  sk_sp<SkImage> makeImageFromNativeTexture(const TextureInfo &textureInfo,
+                                            int width, int height,
+                                            bool mipMapped) override;
+
   uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
 
+  const TextureInfo getTexture(sk_sp<SkSurface> image) override;
+
+  const TextureInfo getTexture(sk_sp<SkImage> image) override;
+
   void releaseNativeBuffer(uint64_t pointer) override;
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
@@ -76,16 +70,10 @@ public:
 #endif
   sk_sp<SkFontMgr> createFontMgr() override;
 
-  void willInvalidateModules() {}
-
 private:
   ViewScreenshotService *_screenshotService;
-};
 
-static void handleNotification(CFNotificationCenterRef center, void *observer,
-                               CFStringRef name, const void *object,
-                               CFDictionaryRef userInfo) {
-  (static_cast<RNSkiOSPlatformContext *>(observer))->willInvalidateModules();
-}
+  SkColorType mtlPixelFormatToSkColorType(MTLPixelFormat pixelFormat);
+};
 
 } // namespace RNSkia