@shopify/react-native-skia 1.1.0 → 1.2.1

package/android/CMakeLists.txt

@@ -47,6 +47,7 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/GrAHardwareBufferUtils.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
 
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiHostObject.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiValue.cpp"

package/android/build.gradle

@@ -137,6 +137,7 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
         versionCode 1
         versionName "1.0"
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
 
         externalNativeBuild {
             cmake {

package/android/cpp/rnskia-android/AHardwareBufferUtils.cpp

@@ -0,0 +1,31 @@
+#if __ANDROID_API__ >= 26
+
+#include "AHardwareBufferUtils.h"
+#include <android/hardware_buffer.h>
+
+namespace RNSkia {
+
+uint32_t GetBufferFormatFromSkColorType(SkColorType bufferFormat) {
+  switch (bufferFormat) {
+  case kRGBA_8888_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+  case kRGB_888x_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM;
+  case kRGBA_F16_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
+  case kRGB_565_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
+  case kRGBA_1010102_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
+#if __ANDROID_API__ >= 33
+  case kAlpha_8_SkColorType:
+    return AHARDWAREBUFFER_FORMAT_R8_UNORM;
+#endif
+  default:
+    return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+  }
+}
+
+} // namespace RNSkia
+
+#endif

package/android/cpp/rnskia-android/AHardwareBufferUtils.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "include/core/SkColorType.h"
+
+#if __ANDROID_API__ >= 26
+
+namespace RNSkia {
+
+uint32_t GetBufferFormatFromSkColorType(SkColorType bufferFormat);
+
+} // namespace RNSkia
+
+#endif

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -1,10 +1,15 @@
 #pragma once
 
+// TODO: Add android flags
+#if __ANDROID_API__ >= 26
+#include <android/hardware_buffer.h>
+#endif
 #include <exception>
 #include <functional>
 #include <memory>
 #include <string>
 
+#include "AHardwareBufferUtils.h"
 #include "JniPlatformContext.h"
 #include "RNSkPlatformContext.h"
 #include "SkiaOpenGLSurfaceFactory.h"
@@ -48,6 +53,76 @@ public:
     return SkiaOpenGLSurfaceFactory::makeOffscreenSurface(width, height);
   }
 
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
+    return SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(buffer);
+  }
+
+  void releaseNativeBuffer(uint64_t pointer) override {
+#if __ANDROID_API__ >= 26
+    AHardwareBuffer *buffer = reinterpret_cast<AHardwareBuffer *>(pointer);
+    AHardwareBuffer_release(buffer);
+#endif
+  }
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
+#if __ANDROID_API__ >= 26
+    auto bytesPerPixel = image->imageInfo().bytesPerPixel();
+    int bytesPerRow = image->width() * bytesPerPixel;
+    auto buf = SkData::MakeUninitialized(image->width() * image->height() *
+                                         bytesPerPixel);
+    SkImageInfo info =
+        SkImageInfo::Make(image->width(), image->height(), image->colorType(),
+                          image->alphaType());
+    image->readPixels(nullptr, info, const_cast<void *>(buf->data()),
+                      bytesPerRow, 0, 0);
+    const void *pixelData = buf->data();
+
+    // Define the buffer description
+    AHardwareBuffer_Desc desc = {};
+    // TODO: use image info here
+    desc.width = image->width();
+    desc.height = image->height();
+    desc.layers = 1; // Single image layer
+    desc.format = GetBufferFormatFromSkColorType(
+        image->colorType()); // Assuming the image
+                             // is in this format
+    desc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
+                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+    desc.stride = bytesPerRow; // Stride in pixels, not in bytes
+
+    // Allocate the buffer
+    AHardwareBuffer *buffer = nullptr;
+    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
+      // Handle allocation failure
+      return 0;
+    }
+
+    // Map the buffer to gain access to its memory
+    void *mappedBuffer = nullptr;
+    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1,
+                         nullptr, &mappedBuffer);
+    if (mappedBuffer == nullptr) {
+      // Handle mapping failure
+      AHardwareBuffer_release(buffer);
+      return 0;
+    }
+
+    // Copy the image data to the buffer
+    memcpy(mappedBuffer, pixelData, desc.height * bytesPerRow);
+
+    // Unmap the buffer
+    AHardwareBuffer_unlock(buffer, nullptr);
+
+    // Return the buffer pointer as a uint64_t. It's the caller's responsibility
+    // to manage this buffer.
+    return reinterpret_cast<uint64_t>(buffer);
+#else
+    return 0;
+#endif
+  }
+
   sk_sp<SkFontMgr> createFontMgr() override {
     return SkFontMgr_New_Android(nullptr);
   }

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp

@@ -7,6 +7,7 @@
 
 #include "include/gpu/ganesh/SkImageGanesh.h"
 #include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
+#include "src/gpu/ganesh/gl/GrGLDefines.h"
 
 #pragma clang diagnostic pop
 
@@ -15,30 +16,47 @@ namespace RNSkia {
 thread_local SkiaOpenGLContext ThreadContextHolder::ThreadSkiaOpenGLContext;
 
 sk_sp<SkImage>
-SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(const SkImageInfo &info,
-                                                      void *buffer) {
+SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer) {
 #if __ANDROID_API__ >= 26
+  // Setup OpenGL and Skia:
+  if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
+          &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
+
+    RNSkLogger::logToConsole(
+        "Could not create Skia Surface from native window / surface. "
+        "Failed creating Skia Direct Context");
+    return nullptr;
+  }
   const AHardwareBuffer *hardwareBuffer =
       static_cast<AHardwareBuffer *>(buffer);
   DeleteImageProc deleteImageProc = nullptr;
   UpdateImageProc updateImageProc = nullptr;
   TexImageCtx deleteImageCtx = nullptr;
+
+  AHardwareBuffer_Desc description;
+  AHardwareBuffer_describe(hardwareBuffer, &description);
+  if (description.format != AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM) {
+    throw std::runtime_error("AHardwareBuffer has unknown format (" +
+                             std::to_string(description.format) +
+                             ") - cannot convert to SkImage!");
+  }
+  GrBackendFormat format =
+      GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+
   auto backendTex = MakeGLBackendTexture(
       ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
-      const_cast<AHardwareBuffer *>(hardwareBuffer), info.width(),
-      info.height(), &deleteImageProc, &updateImageProc, &deleteImageCtx, false,
-      // GR_GL_RGBA8 0x8058
-      // GR_GL_TEXTURE_EXTERNAL 0x8D65
-      GrBackendFormats::MakeGL(0x8058, 0x8D65), false);
+      const_cast<AHardwareBuffer *>(hardwareBuffer), description.width,
+      description.height, &deleteImageProc, &updateImageProc, &deleteImageCtx,
+      false, format, false);
   sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
       ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
       backendTex, kTopLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType,
-      kPremul_SkAlphaType, nullptr);
+      kOpaque_SkAlphaType, nullptr);
   return image;
 #else
-  RNSkLogger::logToConsole(
-      "Hardware buffer in only supported on Android API level 26 and above.");
-  return nullptr;
+  throw std::runtime_error(
+      "HardwareBuffers are only supported on Android API 26 or higher! Set "
+      "your minSdk to 26 (or higher) and try again.");
 #endif
 }
 

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.h

@@ -149,8 +149,7 @@ public:
    */
   static sk_sp<SkSurface> makeOffscreenSurface(int width, int height);
 
-  static sk_sp<SkImage> makeImageFromHardwareBuffer(const SkImageInfo &info,
-                                                    void *buffer);
+  static sk_sp<SkImage> makeImageFromHardwareBuffer(void *buffer);
 
   /**
    * Creates a windowed Skia Surface holder.

package/android/src/main/java/com/shopify/reactnative/skia/ViewScreenshotService.java

@@ -17,7 +17,8 @@ import android.view.ViewGroup;
 import android.widget.ScrollView;
 import androidx.annotation.NonNull;
 import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.views.view.ReactViewGroup;
 
 import java.lang.reflect.Method;
@@ -29,7 +30,7 @@ public class ViewScreenshotService {
     private static final String TAG = "SkiaScreenshot";
 
     public static Bitmap makeViewScreenshotFromTag(ReactContext context, int tag) {
-        UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
+        UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(context, tag);
         View view = null;
         try {
             view = uiManager.resolveView(tag);

package/cpp/api/JsiNativeBuffer.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkImage.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+/**
+ Implementation of the ParagraphBuilderFactory for making ParagraphBuilder JSI
+ object
+ */
+class JsiNativeBufferFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(MakeFromImage) {
+    auto image = JsiSkImage::fromValue(runtime, arguments[0]);
+    image->makeNonTextureImage();
+    uint64_t pointer = getContext()->makeNativeBuffer(image);
+    return jsi::BigInt::fromUint64(runtime, pointer);
+  }
+
+  JSI_HOST_FUNCTION(Release) {
+
+    jsi::BigInt pointer = arguments[0].asBigInt(runtime);
+    const uintptr_t nativeBufferPointer = pointer.asUint64(runtime);
+
+    getContext()->releaseNativeBuffer(nativeBufferPointer);
+    return jsi::Value::undefined();
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiNativeBufferFactory, Release),
+                       JSI_EXPORT_FUNC(JsiNativeBufferFactory, MakeFromImage))
+
+  explicit JsiNativeBufferFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkApi.h

@@ -6,6 +6,7 @@
 
 #include "JsiSkHostObjects.h"
 
+#include "JsiNativeBuffer.h"
 #include "JsiSkAnimatedImage.h"
 #include "JsiSkAnimatedImageFactory.h"
 #include "JsiSkColor.h"
@@ -122,6 +123,9 @@ public:
     installReadonlyProperty(
         "ParagraphBuilder",
         std::make_shared<JsiSkParagraphBuilderFactory>(context));
+
+    installReadonlyProperty("NativeBuffer",
+                            std::make_shared<JsiNativeBufferFactory>(context));
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -177,7 +177,7 @@ public:
     if (!getObject()->readPixels(info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
     }
-    return std::move(dest);
+    return dest;
   }
 
   JSI_HOST_FUNCTION(makeNonTextureImage) {

package/cpp/api/JsiSkImageFactory.h

@@ -27,6 +27,18 @@ public:
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
 
+  JSI_HOST_FUNCTION(MakeImageFromNativeBuffer) {
+    jsi::BigInt pointer = arguments[0].asBigInt(runtime);
+    const uintptr_t platformBufferPointer = pointer.asUint64(runtime);
+    void *rawPointer = reinterpret_cast<void *>(platformBufferPointer);
+    auto image = getContext()->makeImageFromNativeBuffer(rawPointer);
+    if (image == nullptr) {
+      throw std::runtime_error("Failed to convert PlatformBuffer to SkImage!");
+    }
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+  }
+
   JSI_HOST_FUNCTION(MakeImage) {
     auto imageInfo = JsiSkImageInfo::fromValue(runtime, arguments[0]);
     auto pixelData = JsiSkData::fromValue(runtime, arguments[1]);
@@ -68,7 +80,9 @@ public:
 
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromEncoded),
                        JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromViewTag),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage), )
+                       JSI_EXPORT_FUNC(JsiSkImageFactory,
+                                       MakeImageFromNativeBuffer),
+                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage))
 
   explicit JsiSkImageFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkSurface.h

@@ -31,6 +31,12 @@ public:
 
   EXPORT_JSI_API_TYPENAME(JsiSkSurface, Surface)
 
+  // TODO-API: Properties?
+  JSI_HOST_FUNCTION(width) { return static_cast<double>(getObject()->width()); }
+  JSI_HOST_FUNCTION(height) {
+    return static_cast<double>(getObject()->height());
+  }
+
   JSI_HOST_FUNCTION(getCanvas) {
     return jsi::Object::createFromHostObject(
         runtime,
@@ -57,7 +63,9 @@ public:
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, width),
+                       JSI_EXPORT_FUNC(JsiSkSurface, height),
+                       JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),
                        JSI_EXPORT_FUNC(JsiSkSurface, makeImageSnapshot),
                        JSI_EXPORT_FUNC(JsiSkSurface, flush),
                        JSI_EXPORT_FUNC(JsiSkSurface, dispose))

package/cpp/rnskia/RNSkPlatformContext.h

@@ -133,6 +133,19 @@ public:
    */
   virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;
 
+  /**
+   * Creates an image from a native buffer. (for testing purposes only)
+   * - On iOS, this is a `CVPixelBufferRef*`
+   * - On Android, this is a `AHardwareBuffer*`
+   * @param buffer The native platform buffer.
+   * @return sk_sp<SkImage>
+   */
+  virtual sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) = 0;
+
+  virtual void releaseNativeBuffer(uint64_t pointer) = 0;
+
+  virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
+
   /**
    * Return the Platform specific font manager
    */

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -59,6 +59,12 @@ public:
 
   sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override;
 
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override;
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
+
+  void releaseNativeBuffer(uint64_t pointer) override;
+
   virtual void performStreamOperation(
       const std::string &sourceUri,
       const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override;

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -1,10 +1,12 @@
-#include "RNSkiOSPlatformContext.h"
+#import "RNSkiOSPlatformContext.h"
 
+#import <CoreMedia/CMSampleBuffer.h>
 #import <React/RCTUtils.h>
 #include <thread>
 #include <utility>
 
-#include "SkiaMetalSurfaceFactory.h"
+#import "SkiaCVPixelBufferUtils.h"
+#import "SkiaMetalSurfaceFactory.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -56,6 +58,95 @@ void RNSkiOSPlatformContext::performStreamOperation(
   std::thread(loader).detach();
 }
 
+void RNSkiOSPlatformContext::releaseNativeBuffer(uint64_t pointer) {
+  CMSampleBufferRef sampleBuffer = reinterpret_cast<CMSampleBufferRef>(pointer);
+  CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+  if (sampleBuffer) {
+    CFRelease(sampleBuffer);
+  }
+  if (pixelBuffer) {
+    CFRelease(pixelBuffer);
+  }
+}
+
+uint64_t RNSkiOSPlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
+  // 0. If Image is not in BGRA, convert to BGRA as only BGRA is supported.
+  if (image->colorType() != kBGRA_8888_SkColorType) {
+    // on iOS, 32_BGRA is the only supported RGB format for CVPixelBuffers.
+    image = image->makeColorTypeAndColorSpace(
+        ThreadContextHolder::ThreadSkiaMetalContext.skContext.get(),
+        kBGRA_8888_SkColorType, SkColorSpace::MakeSRGB());
+    if (image == nullptr) {
+      throw std::runtime_error(
+          "Failed to convert image to BGRA_8888 colortype! Only BGRA_8888 "
+          "PlatformBuffers are supported.");
+    }
+  }
+
+  // 1. Get image info
+  auto bytesPerPixel = image->imageInfo().bytesPerPixel();
+  int bytesPerRow = image->width() * bytesPerPixel;
+  auto buf = SkData::MakeUninitialized(image->width() * image->height() *
+                                       bytesPerPixel);
+  SkImageInfo info = SkImageInfo::Make(image->width(), image->height(),
+                                       image->colorType(), image->alphaType());
+  // 2. Copy pixels into our buffer
+  image->readPixels(nullptr, info, const_cast<void *>(buf->data()), bytesPerRow,
+                    0, 0);
+
+  // 3. Create an IOSurface (GPU + CPU memory)
+  CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
+      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
+      &kCFTypeDictionaryValueCallBacks);
+  int width = image->width();
+  int height = image->height();
+  int pitch = width * bytesPerPixel;
+  int size = width * height * bytesPerPixel;
+  OSType pixelFormat = kCVPixelFormatType_32BGRA;
+  CFDictionarySetValue(
+      dict, kIOSurfaceBytesPerRow,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pitch));
+  CFDictionarySetValue(
+      dict, kIOSurfaceBytesPerElement,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &bytesPerPixel));
+  CFDictionarySetValue(
+      dict, kIOSurfaceWidth,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &width));
+  CFDictionarySetValue(
+      dict, kIOSurfaceHeight,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &height));
+  CFDictionarySetValue(
+      dict, kIOSurfacePixelFormat,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pixelFormat));
+  CFDictionarySetValue(
+      dict, kIOSurfaceAllocSize,
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &size));
+  IOSurfaceRef surface = IOSurfaceCreate(dict);
+  if (surface == nil) {
+    throw std::runtime_error("Failed to create " + std::to_string(width) + "x" +
+                             std::to_string(height) + " IOSurface!");
+  }
+
+  // 4. Copy over the memory from the pixels into the IOSurface
+  IOSurfaceLock(surface, 0, nil);
+  void *base = IOSurfaceGetBaseAddress(surface);
+  memcpy(base, buf->data(), buf->size());
+  IOSurfaceUnlock(surface, 0, nil);
+
+  // 5. Create a CVPixelBuffer from the IOSurface
+  CVPixelBufferRef pixelBuffer = nullptr;
+  CVReturn result =
+      CVPixelBufferCreateWithIOSurface(nil, surface, nil, &pixelBuffer);
+  if (result != kCVReturnSuccess) {
+    throw std::runtime_error(
+        "Failed to create CVPixelBuffer from SkImage! Return value: " +
+        std::to_string(result));
+  }
+
+  // 8. Return CVPixelBuffer casted to uint64_t
+  return reinterpret_cast<uint64_t>(pixelBuffer);
+}
+
 void RNSkiOSPlatformContext::raiseError(const std::exception &err) {
   RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
 }
@@ -65,6 +156,11 @@ sk_sp<SkSurface> RNSkiOSPlatformContext::makeOffscreenSurface(int width,
   return SkiaMetalSurfaceFactory::makeOffscreenSurface(width, height);
 }
 
+sk_sp<SkImage> RNSkiOSPlatformContext::makeImageFromNativeBuffer(void *buffer) {
+  CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
+  return SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(sampleBuffer);
+}
+
 sk_sp<SkFontMgr> RNSkiOSPlatformContext::createFontMgr() {
   return SkFontMgr_New_CoreText(nullptr);
 }

package/ios/RNSkia-iOS/SkiaCVPixelBufferUtils.h

@@ -0,0 +1,84 @@
+//
+//  SkiaCVPixelBufferUtils.h
+//  react-native-skia
+//
+//  Created by Marc Rousavy on 10.04.24.
+//
+
+#pragma once
+#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/gpu/GrBackendSurface.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`.
+   */
+  explicit TextureHolder(CVMetalTextureRef texture);
+  ~TextureHolder();
+
+  /**
+   Converts this Texture to a Skia GrBackendTexture.
+   */
+  GrBackendTexture toGrBackendTexture();
+
+private:
+  CVMetalTextureRef _texture;
+};
+
+class SkiaCVPixelBufferUtils {
+public:
+  enum class CVPixelBufferBaseFormat { rgb };
+
+  /**
+   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:
+    /**
+     Gets the Skia Color Type of the RGB pixel-buffer.
+     */
+    static SkColorType getCVPixelBufferColorType(CVPixelBufferRef pixelBuffer);
+    /**
+     Gets a GPU-backed Skia Texture for the given RGB CVPixelBuffer.
+     */
+    static TextureHolder *
+    getSkiaTextureForCVPixelBuffer(CVPixelBufferRef pixelBuffer);
+  };
+
+private:
+  static CVMetalTextureCacheRef getTextureCache();
+  static TextureHolder *
+  getSkiaTextureForCVPixelBufferPlane(CVPixelBufferRef pixelBuffer,
+                                      size_t planeIndex);
+  static MTLPixelFormat
+  getMTLPixelFormatForCVPixelBufferPlane(CVPixelBufferRef pixelBuffer,
+                                         size_t planeIndex);
+};