@shopify/react-native-skia 1.12.1 → 1.12.2

package/apple/RNSkAppleVideo.mm

@@ -0,0 +1,137 @@
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkImage.h"
+
+#pragma clang diagnostic pop
+
+#include "RNSkAppleVideo.h"
+#include <AVFoundation/AVFoundation.h>
+#include <CoreVideo/CoreVideo.h>
+
+namespace RNSkia {
+
+RNSkAppleVideo::RNSkAppleVideo(std::string url, RNSkPlatformContext *context)
+    : _url(std::move(url)), _context(context) {
+  setupPlayer();
+}
+
+RNSkAppleVideo::~RNSkAppleVideo() {
+  if (_player) {
+    [_player pause];
+  }
+}
+
+void RNSkAppleVideo::setupPlayer() {
+  NSURL *videoURL = [NSURL URLWithString:@(_url.c_str())];
+  AVPlayerItem *playerItem = [AVPlayerItem playerItemWithURL:videoURL];
+  _player = [AVPlayer playerWithPlayerItem:playerItem];
+  _playerItem = playerItem;
+
+  NSDictionary *outputSettings = getOutputSettings();
+  _videoOutput =
+      [[AVPlayerItemVideoOutput alloc] initWithOutputSettings:outputSettings];
+  [playerItem addOutput:_videoOutput];
+
+  CMTime time = playerItem.asset.duration;
+  if (time.timescale != 0) {
+    _duration = CMTimeGetSeconds(time) * 1000; // Store duration in milliseconds
+  }
+
+  AVAssetTrack *videoTrack =
+      [[playerItem.asset tracksWithMediaType:AVMediaTypeVideo] firstObject];
+  if (videoTrack) {
+    _framerate = videoTrack.nominalFrameRate;
+    _preferredTransform = videoTrack.preferredTransform;
+    CGSize videoSize = videoTrack.naturalSize;
+    _videoWidth = videoSize.width;
+    _videoHeight = videoSize.height;
+  }
+  play();
+}
+
+sk_sp<SkImage> RNSkAppleVideo::nextImage(double *timeStamp) {
+  CMTime currentTime = [_player currentTime];
+  CVPixelBufferRef pixelBuffer =
+      [_videoOutput copyPixelBufferForItemTime:currentTime
+                            itemTimeForDisplay:nullptr];
+  if (!pixelBuffer) {
+    NSLog(@"No pixel buffer.");
+    return nullptr;
+  }
+
+  auto skImage = _context->makeImageFromNativeBuffer((void *)pixelBuffer);
+
+  if (timeStamp) {
+    *timeStamp = CMTimeGetSeconds(currentTime);
+  }
+
+  CVPixelBufferRelease(pixelBuffer);
+  return skImage;
+}
+
+NSDictionary *RNSkAppleVideo::getOutputSettings() {
+  return @{
+    (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
+    (id)kCVPixelBufferMetalCompatibilityKey : @YES
+  };
+}
+
+float RNSkAppleVideo::getRotationInDegrees() {
+  CGFloat rotationAngle = 0.0;
+  auto transform = _preferredTransform;
+  // Determine the rotation angle in radians
+  if (transform.a == 0 && transform.b == 1 && transform.c == -1 &&
+      transform.d == 0) {
+    rotationAngle = 90;
+  } else if (transform.a == 0 && transform.b == -1 && transform.c == 1 &&
+             transform.d == 0) {
+    rotationAngle = 270;
+  } else if (transform.a == -1 && transform.b == 0 && transform.c == 0 &&
+             transform.d == -1) {
+    rotationAngle = 180;
+  }
+  return rotationAngle;
+}
+
+void RNSkAppleVideo::seek(double timeInMilliseconds) {
+  CMTime seekTime =
+      CMTimeMakeWithSeconds(timeInMilliseconds / 1000.0, NSEC_PER_SEC);
+  [_player seekToTime:seekTime
+        toleranceBefore:kCMTimeZero
+         toleranceAfter:kCMTimeZero
+      completionHandler:^(BOOL finished) {
+        if (!finished) {
+          NSLog(@"Seek failed or was interrupted.");
+        }
+      }];
+}
+
+void RNSkAppleVideo::play() {
+  if (_player) {
+    [_player play];
+    _isPlaying = true;
+  }
+}
+
+void RNSkAppleVideo::pause() {
+  if (_player) {
+    [_player pause];
+    _isPlaying = false;
+  }
+}
+
+double RNSkAppleVideo::duration() { return _duration; }
+
+double RNSkAppleVideo::framerate() { return _framerate; }
+
+SkISize RNSkAppleVideo::getSize() {
+  return SkISize::Make(_videoWidth, _videoHeight);
+}
+
+void RNSkAppleVideo::setVolume(float volume) { _player.volume = volume; }
+
+} // namespace RNSkia

package/apple/RNSkAppleView.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#import <memory>
+
+#import "RNSkMetalCanvasProvider.h"
+#import "RNSkView.h"
+#import "RNSkApplePlatformContext.h"
+
+class RNSkBaseAppleView {
+public:
+  virtual CALayer *getLayer() = 0;
+  virtual void setSize(int width, int height) = 0;
+  virtual std::shared_ptr<RNSkia::RNSkView> getDrawView() = 0;
+};
+
+template <class T> class RNSkAppleView : public RNSkBaseAppleView, public T {
+public:
+  RNSkAppleView(std::shared_ptr<RNSkia::RNSkPlatformContext> context)
+      : T(context,
+          std::make_shared<RNSkMetalCanvasProvider>(
+              std::bind(&RNSkia::RNSkView::requestRedraw, this), context)) {}
+
+  CALayer *getLayer() override {
+    return std::static_pointer_cast<RNSkMetalCanvasProvider>(
+               this->getCanvasProvider())
+        ->getLayer();
+  }
+
+  void setSize(int width, int height) override {
+    std::static_pointer_cast<RNSkMetalCanvasProvider>(this->getCanvasProvider())
+        ->setSize(width, height);
+  }
+
+  std::shared_ptr<RNSkia::RNSkView> getDrawView() override {
+    return this->shared_from_this();
+  }
+};

package/apple/RNSkAppleView.mm

@@ -0,0 +1,35 @@
+#import <memory>
+
+#import "RNSkMetalCanvasProvider.h"
+#import "RNSkView.h"
+#import "RNSkApplePlatformContext.h"
+
+class RNSkBaseAppleView {
+public:
+  virtual CALayer *getLayer() = 0;
+  virtual void setSize(int width, int height) = 0;
+  virtual std::shared_ptr<RNSkia::RNSkView> getDrawView() = 0;
+};
+
+template <class T> class RNSkAppleView : public RNSkBaseAppleView, public T {
+public:
+  RNSkAppleView(std::shared_ptr<RNSkia::RNSkPlatformContext> context)
+      : T(context,
+          std::make_shared<RNSkMetalCanvasProvider>(
+              std::bind(&RNSkia::RNSkView::requestRedraw, this), context)) {}
+
+  CALayer *getLayer() override {
+    return std::static_pointer_cast<RNSkMetalCanvasProvider>(
+               this->getCanvasProvider())
+        ->getLayer();
+  }
+
+  void setSize(int width, int height) override {
+    std::static_pointer_cast<RNSkMetalCanvasProvider>(this->getCanvasProvider())
+        ->setSize(width, height);
+  }
+
+  std::shared_ptr<RNSkia::RNSkView> getDrawView() override {
+    return this->shared_from_this();
+  }
+};

package/apple/RNSkMetalCanvasProvider.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#import "RNSkPlatformContext.h"
+#import "RNSkView.h"
+
+#import <MetalKit/MetalKit.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import <include/gpu/ganesh/GrDirectContext.h>
+
+#pragma clang diagnostic pop
+
+class RNSkMetalCanvasProvider : public RNSkia::RNSkCanvasProvider {
+public:
+  RNSkMetalCanvasProvider(std::function<void()> requestRedraw,
+                          std::shared_ptr<RNSkia::RNSkPlatformContext> context);
+
+  ~RNSkMetalCanvasProvider();
+
+  int getScaledWidth() override;
+  int getScaledHeight() override;
+
+  bool renderToCanvas(const std::function<void(SkCanvas *)> &cb) override;
+
+  void setSize(int width, int height);
+  CALayer *getLayer();
+
+private:
+  std::shared_ptr<RNSkia::RNSkPlatformContext> _context;
+  std::unique_ptr<RNSkia::WindowContext> _ctx = nullptr;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  CAMetalLayer *_layer;
+#pragma clang diagnostic pop
+};

package/apple/RNSkMetalCanvasProvider.mm

@@ -0,0 +1,108 @@
+#import "RNSkMetalCanvasProvider.h"
+
+#import "RNSkLog.h"
+
+#if defined(SK_GRAPHITE)
+#import "DawnContext.h"
+#else
+#import "MetalContext.h"
+#endif
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import "include/core/SkCanvas.h"
+#import "include/core/SkColorSpace.h"
+#import "include/core/SkSurface.h"
+
+#import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/GrDirectContext.h>
+#import <include/gpu/ganesh/SkSurfaceGanesh.h>
+
+#pragma clang diagnostic pop
+
+RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(
+    std::function<void()> requestRedraw,
+    std::shared_ptr<RNSkia::RNSkPlatformContext> context)
+    : RNSkCanvasProvider(requestRedraw), _context(context) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  _layer = [CAMetalLayer layer];
+#pragma clang diagnostic pop
+}
+
+RNSkMetalCanvasProvider::~RNSkMetalCanvasProvider() {}
+
+/**
+ Returns the scaled width of the view
+ */
+int RNSkMetalCanvasProvider::getScaledWidth() {
+  return _ctx ? _ctx->getWidth() : -1;
+};
+
+/**
+ Returns the scaled height of the view
+ */
+int RNSkMetalCanvasProvider::getScaledHeight() {
+  return _ctx ? _ctx->getHeight() : -1;
+};
+
+/**
+ Render to a canvas
+ */
+bool RNSkMetalCanvasProvider::renderToCanvas(
+    const std::function<void(SkCanvas *)> &cb) {
+  if (!_ctx) {
+    return false;
+  }
+
+  // Make sure to NOT render or try any render operations while we're in the
+  // background or inactive. This will cause an error that might clear the
+  // CAMetalLayer so that the canvas is empty when the app receives focus again.
+  // Reference: https://github.com/Shopify/react-native-skia/issues/1257
+  // NOTE: UIApplication.sharedApplication.applicationState can only be
+  // accessed from the main thread so we need to check here.
+  if ([[NSThread currentThread] isMainThread]) {
+#if !TARGET_OS_OSX
+    auto state = UIApplication.sharedApplication.applicationState;
+    bool appIsBackgrounded = (state == UIApplicationStateBackground);
+#else
+    bool appIsBackgrounded = !NSApplication.sharedApplication.isActive;
+#endif // !TARGET_OS_OSX
+    if (appIsBackgrounded) {
+      // Request a redraw in the next run loop callback
+      _requestRedraw();
+      // and don't draw now since it might cause errors in the metal renderer if
+      // we try to render while in the background. (see above issue)
+      return false;
+    }
+  }
+  // Wrap in auto release pool since we want the system to clean up after
+  // rendering and not wait until later - we've seen some example of memory
+  // usage growing very fast in the simulator without this.
+  @autoreleasepool {
+    auto surface = _ctx->getSurface();
+    if (!surface) {
+      return false;
+    }
+    auto canvas = surface->getCanvas();
+    cb(canvas);
+    _ctx->present();
+  }
+  return true;
+};
+
+void RNSkMetalCanvasProvider::setSize(int width, int height) {
+  _layer.frame = CGRectMake(0, 0, width, height);
+  auto w = width * _context->getPixelDensity();
+  auto h = height * _context->getPixelDensity();
+#if defined(SK_GRAPHITE)
+  _ctx = RNSkia::DawnContext::getInstance().MakeWindow((__bridge void *)_layer,
+                                                       w, h);
+#else
+  _ctx = MetalContext::getInstance().MakeWindow(_layer, w, h);
+#endif
+  _requestRedraw();
+}
+
+CALayer *RNSkMetalCanvasProvider::getLayer() { return _layer; }

package/apple/RNSkiaModule.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <rnskia/rnskia.h>
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+#include "SkiaManager.h"
+
+@interface RNSkiaModule : NSObject
+#ifdef RCT_NEW_ARCH_ENABLED
+                          <NativeSkiaModuleSpec>
+#else
+                          <RCTBridgeModule>
+#endif
+
+- (SkiaManager *)manager;
+
+@end

package/apple/RNSkiaModule.mm

@@ -0,0 +1,55 @@
+
+#import "RNSkiaModule.h"
+#import <React/RCTBridge+Private.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+@implementation RNSkiaModule {
+  SkiaManager *skiaManager;
+  std::shared_ptr<facebook::react::CallInvoker> jsInvoker;
+}
+
+RCT_EXPORT_MODULE()
+@synthesize bridge = _bridge;
+
+#pragma Accessors
+
+- (SkiaManager *)manager {
+  return skiaManager;
+}
+
+#pragma Setup and invalidation
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+- (void)invalidate {
+  if (skiaManager != nil) {
+    [skiaManager invalidate];
+  }
+  skiaManager = nil;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  if (skiaManager != nil) {
+    // Already initialized, ignore call.
+    return @true;
+  }
+  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+  if (!jsInvoker) {
+    jsInvoker = cxxBridge.jsCallInvoker;
+  }
+  skiaManager = [[SkiaManager alloc] initWithBridge:cxxBridge
+                                          jsInvoker:jsInvoker];
+  return @true;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  jsInvoker = params.jsInvoker;
+  return std::make_shared<facebook::react::NativeSkiaModuleSpecJSI>(params);
+}
+#endif
+
+@end

package/apple/SkiaCVPixelBufferUtils.h

@@ -0,0 +1,119 @@
+//
+//  SkiaCVPixelBufferUtils.h
+//  react-native-skia
+//
+//  Created by Marc Rousavy on 10.04.24.
+//
+
+#pragma once
+
+#import <vector>
+
+#import <CoreMedia/CMSampleBuffer.h>
+#import <CoreVideo/CVMetalTextureCache.h>
+#import <MetalKit/MetalKit.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#import "include/core/SkColorSpace.h"
+#import "include/core/SkImage.h"
+#import "include/gpu/ganesh/GrBackendSurface.h"
+#import "include/gpu/ganesh/GrYUVABackendTextures.h"
+#pragma clang diagnostic pop
+
+/**
+ Holds a Metal Texture.
+ When the `TextureHolder` is destroyed, the underlying Metal Texture
+ is marked as invalid and might be overwritten by the Texture Cache,
+ so make sure to delete the `TextureHolder` only when the `SkImage`
+ has been deleted.
+
+ For example, use the `releaseProc` parameter in `BorrowImageFromTexture`
+ to delete the `TextureHolder`.
+ */
+class TextureHolder {
+public:
+  /**
+   Create a new instance of TextureHolder which holds
+   the given `CVMetalTextureRef`.
+
+   The given `CVMetalTextureRef` is assumed to already be
+   retained with `CFRetain`, and will later be manually
+   released with `CFRelease`.
+   */
+  TextureHolder(CVMetalTextureRef texture);
+  ~TextureHolder();
+
+  /**
+   Converts this Texture to a Skia GrBackendTexture.
+   */
+  GrBackendTexture toGrBackendTexture();
+
+private:
+  CVMetalTextureRef _texture;
+};
+
+/**
+ Same as `TextureHolder`, but for multiple planar textures (e.g. YUVA)
+ */
+class MultiTexturesHolder {
+public:
+  ~MultiTexturesHolder();
+  void addTexture(TextureHolder *texture);
+
+private:
+  std::vector<TextureHolder *> _textures;
+};
+
+class SkiaCVPixelBufferUtils {
+public:
+  enum class CVPixelBufferBaseFormat { rgb, yuv };
+
+  /**
+   Get the base format (currently only RGB) of the PixelBuffer.
+   Depending on the base-format, different methods have to be used to create
+   Skia buffers.
+   */
+  static CVPixelBufferBaseFormat
+  getCVPixelBufferBaseFormat(CVPixelBufferRef pixelBuffer);
+
+  class RGB {
+  public:
+    /**
+     Creates a GPU-backed Skia Texture (SkImage) with the given RGB
+     CVPixelBuffer.
+     */
+    static sk_sp<SkImage>
+    makeSkImageFromCVPixelBuffer(GrDirectContext *context,
+                                 CVPixelBufferRef pixelBuffer);
+
+  private:
+    static SkColorType getCVPixelBufferColorType(CVPixelBufferRef pixelBuffer);
+  };
+
+  class YUV {
+  public:
+    /**
+     Creates a GPU-backed Skia Texture (SkImage) with the given YUV
+     CVPixelBuffer.
+     */
+    static sk_sp<SkImage>
+    makeSkImageFromCVPixelBuffer(GrDirectContext *context,
+                                 CVPixelBufferRef pixelBuffer);
+
+  private:
+    static SkYUVAInfo::PlaneConfig getPlaneConfig(OSType pixelFormat);
+    static SkYUVAInfo::Subsampling getSubsampling(OSType pixelFormat);
+    static SkYUVColorSpace getColorspace(OSType pixelFormat);
+    static SkYUVAInfo getYUVAInfoForCVPixelBuffer(CVPixelBufferRef pixelBuffer);
+  };
+
+private:
+  static CVMetalTextureCacheRef getTextureCache();
+  static TextureHolder *
+  getSkiaTextureForCVPixelBufferPlane(CVPixelBufferRef pixelBuffer,
+                                      size_t planeIndex);
+  static MTLPixelFormat
+  getMTLPixelFormatForCVPixelBufferPlane(CVPixelBufferRef pixelBuffer,
+                                         size_t planeIndex);
+};