@shopify/react-native-skia 1.2.0 → 1.2.1

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

@@ -53,18 +53,18 @@ public:
     return SkiaOpenGLSurfaceFactory::makeOffscreenSurface(width, height);
   }
 
-  sk_sp<SkImage> makeImageFromPlatformBuffer(void *buffer) override {
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
     return SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(buffer);
   }
 
-  void releasePlatformBuffer(uint64_t pointer) override {
+  void releaseNativeBuffer(uint64_t pointer) override {
 #if __ANDROID_API__ >= 26
     AHardwareBuffer *buffer = reinterpret_cast<AHardwareBuffer *>(pointer);
     AHardwareBuffer_release(buffer);
 #endif
   }
 
-  uint64_t makePlatformBuffer(sk_sp<SkImage> image) override {
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
 #if __ANDROID_API__ >= 26
     auto bytesPerPixel = image->imageInfo().bytesPerPixel();
     int bytesPerRow = image->width() * bytesPerPixel;

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,7 +6,7 @@
 
 #include "JsiSkHostObjects.h"
 
-#include "JsiPlatformBuffer.h"
+#include "JsiNativeBuffer.h"
 #include "JsiSkAnimatedImage.h"
 #include "JsiSkAnimatedImageFactory.h"
 #include "JsiSkColor.h"
@@ -124,8 +124,8 @@ public:
         "ParagraphBuilder",
         std::make_shared<JsiSkParagraphBuilderFactory>(context));
 
-    installReadonlyProperty(
-        "PlatformBuffer", std::make_shared<JsiPlatformBufferFactory>(context));
+    installReadonlyProperty("NativeBuffer",
+                            std::make_shared<JsiNativeBufferFactory>(context));
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkImageFactory.h

@@ -27,11 +27,11 @@ public:
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
 
-  JSI_HOST_FUNCTION(MakeImageFromPlatformBuffer) {
+  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()->makeImageFromPlatformBuffer(rawPointer);
+    auto image = getContext()->makeImageFromNativeBuffer(rawPointer);
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert PlatformBuffer to SkImage!");
     }
@@ -81,7 +81,7 @@ public:
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromEncoded),
                        JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImageFromViewTag),
                        JSI_EXPORT_FUNC(JsiSkImageFactory,
-                                       MakeImageFromPlatformBuffer),
+                                       MakeImageFromNativeBuffer),
                        JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage))
 
   explicit JsiSkImageFactory(std::shared_ptr<RNSkPlatformContext> context)

package/cpp/rnskia/RNSkPlatformContext.h

@@ -134,17 +134,17 @@ public:
   virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;
 
   /**
-   * Creates an image from a native platform buffer.
-   * - On iOS, this is a `CMSampleBuffer`
+   * 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> makeImageFromPlatformBuffer(void *buffer) = 0;
+  virtual sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) = 0;
 
-  virtual void releasePlatformBuffer(uint64_t pointer) = 0;
+  virtual void releaseNativeBuffer(uint64_t pointer) = 0;
 
-  virtual uint64_t makePlatformBuffer(sk_sp<SkImage> image) = 0;
+  virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
 
   /**
    * Return the Platform specific font manager

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -59,11 +59,11 @@ public:
 
   sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override;
 
-  sk_sp<SkImage> makeImageFromPlatformBuffer(void *buffer) override;
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override;
 
-  uint64_t makePlatformBuffer(sk_sp<SkImage> image) override;
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
 
-  void releasePlatformBuffer(uint64_t pointer) override;
+  void releaseNativeBuffer(uint64_t pointer) override;
 
   virtual void performStreamOperation(
       const std::string &sourceUri,

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -1,11 +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"
@@ -57,7 +58,7 @@ void RNSkiOSPlatformContext::performStreamOperation(
   std::thread(loader).detach();
 }
 
-void RNSkiOSPlatformContext::releasePlatformBuffer(uint64_t pointer) {
+void RNSkiOSPlatformContext::releaseNativeBuffer(uint64_t pointer) {
   CMSampleBufferRef sampleBuffer = reinterpret_cast<CMSampleBufferRef>(pointer);
   CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
   if (sampleBuffer) {
@@ -68,76 +69,82 @@ void RNSkiOSPlatformContext::releasePlatformBuffer(uint64_t pointer) {
   }
 }
 
-uint64_t RNSkiOSPlatformContext::makePlatformBuffer(sk_sp<SkImage> image) {
+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);
-  auto pixelData = const_cast<void *>(buf->data());
 
-  // Create a CVPixelBuffer from the raw pixel data
-  CVPixelBufferRef pixelBuffer = nullptr;
-  // OSType pixelFormatType = MapSkColorTypeToOSType(image->colorType());
-
-  // You will need to fill in the details for creating the pixel buffer
-  // CVPixelBufferCreateWithBytes or CVPixelBufferCreateWithPlanarBytes
-  // Create the CVPixelBuffer with the image data
-  void *context = static_cast<void *>(
-      new sk_sp<SkData>(buf)); // Create a copy for the context
-  CVReturn r = CVPixelBufferCreateWithBytes(
-      nullptr, // allocator
-      image->width(), image->height(), kCVPixelFormatType_32BGRA,
-      pixelData,                                         // pixel data
-      bytesPerRow,                                       // bytes per row
-      [](void *releaseRefCon, const void *baseAddress) { // release callback
-        auto buf = static_cast<sk_sp<SkData> *>(releaseRefCon);
-        buf->reset(); // This effectively calls unref on the SkData object
-        delete buf;   // Cleanup the dynamically allocated context
-      },
-      context,     // release callback context
-      nullptr,     // pixel buffer attributes
-      &pixelBuffer // the newly created pixel buffer
-  );
-
-  if (r != kCVReturnSuccess) {
-    return 0; // or handle error appropriately
+  // 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!");
   }
 
-  // Wrap the CVPixelBuffer in a CMSampleBuffer
-  CMSampleBufferRef sampleBuffer = nullptr;
-
-  CMFormatDescriptionRef formatDescription = nullptr;
-  CMVideoFormatDescriptionCreateForImageBuffer(kCFAllocatorDefault, pixelBuffer,
-                                               &formatDescription);
-
-  // Assuming no specific timing is required, we initialize the timing info to
-  // zero.
-  CMSampleTimingInfo timingInfo = {0};
-  timingInfo.duration = kCMTimeInvalid; // Indicate an unknown duration.
-  timingInfo.presentationTimeStamp = kCMTimeZero; // Start at time zero.
-  timingInfo.decodeTimeStamp = kCMTimeInvalid;    // No specific decode time.
-
-  // Create the sample buffer.
-  OSStatus status = CMSampleBufferCreateReadyWithImageBuffer(
-      kCFAllocatorDefault, pixelBuffer, formatDescription, &timingInfo,
-      &sampleBuffer);
+  // 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);
 
-  if (status != noErr) {
-    if (formatDescription) {
-      CFRelease(formatDescription);
-    }
-    if (pixelBuffer) {
-      CFRelease(pixelBuffer);
-    }
-    return 0;
+  // 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));
   }
 
-  // Return sampleBuffer casted to uint64_t
-  return reinterpret_cast<uint64_t>(sampleBuffer);
+  // 8. Return CVPixelBuffer casted to uint64_t
+  return reinterpret_cast<uint64_t>(pixelBuffer);
 }
 
 void RNSkiOSPlatformContext::raiseError(const std::exception &err) {
@@ -149,35 +156,9 @@ sk_sp<SkSurface> RNSkiOSPlatformContext::makeOffscreenSurface(int width,
   return SkiaMetalSurfaceFactory::makeOffscreenSurface(width, height);
 }
 
-sk_sp<SkImage>
-RNSkiOSPlatformContext::makeImageFromPlatformBuffer(void *buffer) {
-  CMSampleBufferRef sampleBuffer = (CMSampleBufferRef)buffer;
-  // DO the CPU transfer (debugging only)
-  //  Step 1: Extract the CVPixelBufferRef from the CMSampleBufferRef
-  CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
-
-  // Step 2: Lock the pixel buffer to access the raw pixel data
-  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
-
-  // Step 3: Get information about the image
-  void *baseAddress = CVPixelBufferGetBaseAddress(pixelBuffer);
-  size_t width = CVPixelBufferGetWidth(pixelBuffer);
-  size_t height = CVPixelBufferGetHeight(pixelBuffer);
-  size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
-
-  // Assuming the pixel format is 32BGRA, which is common for iOS video frames.
-  // You might need to adjust this based on the actual pixel format.
-  SkImageInfo info = SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
-                                       kUnpremul_SkAlphaType);
-
-  // Step 4: Create an SkImage from the pixel buffer
-  sk_sp<SkData> data =
-      SkData::MakeWithoutCopy(baseAddress, height * bytesPerRow);
-  sk_sp<SkImage> image = SkImages::RasterFromData(info, data, bytesPerRow);
-  auto texture = SkiaMetalSurfaceFactory::makeTextureFromImage(image);
-  // Step 5: Unlock the pixel buffer
-  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
-  return texture;
+sk_sp<SkImage> RNSkiOSPlatformContext::makeImageFromNativeBuffer(void *buffer) {
+  CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
+  return SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(sampleBuffer);
 }
 
 sk_sp<SkFontMgr> RNSkiOSPlatformContext::createFontMgr() {

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);
+};

package/ios/RNSkia-iOS/SkiaCVPixelBufferUtils.mm

@@ -0,0 +1,159 @@
+//
+//  SkiaCVPixelBufferUtils.mm
+//  react-native-skia
+//
+//  Created by Marc Rousavy on 10.04.24.
+//
+
+#import "SkiaCVPixelBufferUtils.h"
+#import "SkiaMetalSurfaceFactory.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#import "include/core/SkColorSpace.h"
+#import <include/gpu/GrBackendSurface.h>
+#pragma clang diagnostic pop
+
+#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                                            \
+  }
+#else
+#define FourCC2Str(fourcc)                                                     \
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
+#endif
+
+// pragma MARK: TextureHolder
+
+TextureHolder::TextureHolder(CVMetalTextureRef texture) : _texture(texture) {}
+TextureHolder::~TextureHolder() { CFRelease(_texture); }
+
+GrBackendTexture TextureHolder::toGrBackendTexture() {
+  // Unwrap the underlying MTLTexture
+  id<MTLTexture> mtlTexture = CVMetalTextureGetTexture(_texture);
+  if (mtlTexture == nil) [[unlikely]] {
+    throw std::runtime_error(
+        "Failed to get MTLTexture from CVMetalTextureRef!");
+  }
+
+  // Wrap MTLTexture in Skia's GrBackendTexture
+  GrMtlTextureInfo textureInfo;
+  textureInfo.fTexture.retain((__bridge void *)mtlTexture);
+  GrBackendTexture texture =
+      GrBackendTexture((int)mtlTexture.width, (int)mtlTexture.height,
+                       skgpu::Mipmapped::kNo, textureInfo);
+  return texture;
+}
+
+// pragma MARK: Base
+
+SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat
+SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(
+    CVPixelBufferRef pixelBuffer) {
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+
+  switch (format) {
+  case kCVPixelFormatType_32BGRA:
+  case kCVPixelFormatType_32RGBA:
+    return CVPixelBufferBaseFormat::rgb;
+  default:
+    [[unlikely]] throw std::runtime_error(
+        "CVPixelBuffer has unsupported pixel-format! " +
+        std::string(FourCC2Str(format)));
+  }
+}
+
+// pragma MARK: RGB
+
+SkColorType SkiaCVPixelBufferUtils::RGB::getCVPixelBufferColorType(
+    CVPixelBufferRef pixelBuffer) {
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+
+  switch (format) {
+  case kCVPixelFormatType_32BGRA:
+    [[likely]] return kBGRA_8888_SkColorType;
+  case kCVPixelFormatType_32RGBA:
+    return kRGBA_8888_SkColorType;
+  // This can be extended with branches for specific RGB formats if new Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error(
+        "CVPixelBuffer has unknown RGB format! " +
+        std::string(FourCC2Str(format)));
+  }
+}
+
+TextureHolder *SkiaCVPixelBufferUtils::RGB::getSkiaTextureForCVPixelBuffer(
+    CVPixelBufferRef pixelBuffer) {
+  return getSkiaTextureForCVPixelBufferPlane(pixelBuffer, /* planeIndex */ 0);
+}
+
+// pragma MARK: CVPixelBuffer -> Skia Texture
+
+TextureHolder *SkiaCVPixelBufferUtils::getSkiaTextureForCVPixelBufferPlane(
+    CVPixelBufferRef pixelBuffer, size_t planeIndex) {
+  // 1. Get cache
+  CVMetalTextureCacheRef textureCache = getTextureCache();
+
+  // 2. Get MetalTexture from CMSampleBuffer
+  size_t width = CVPixelBufferGetWidthOfPlane(pixelBuffer, planeIndex);
+  size_t height = CVPixelBufferGetHeightOfPlane(pixelBuffer, planeIndex);
+  MTLPixelFormat pixelFormat =
+      getMTLPixelFormatForCVPixelBufferPlane(pixelBuffer, planeIndex);
+
+  CVMetalTextureRef textureHolder;
+  CVReturn result = CVMetalTextureCacheCreateTextureFromImage(
+      kCFAllocatorDefault, textureCache, pixelBuffer, nil, pixelFormat, width,
+      height, planeIndex, &textureHolder);
+
+  if (result != kCVReturnSuccess) [[unlikely]] {
+    throw std::runtime_error(
+        "Failed to create Metal Texture from CMSampleBuffer! Result: " +
+        std::to_string(result));
+  }
+
+  return new TextureHolder(textureHolder);
+}
+
+// pragma MARK: getTextureCache()
+
+CVMetalTextureCacheRef SkiaCVPixelBufferUtils::getTextureCache() {
+  static CVMetalTextureCacheRef textureCache = nil;
+  if (textureCache == nil) {
+    // Create a new Texture Cache
+    auto result = CVMetalTextureCacheCreate(kCFAllocatorDefault, nil,
+                                            MTLCreateSystemDefaultDevice(), nil,
+                                            &textureCache);
+    if (result != kCVReturnSuccess || textureCache == nil) {
+      throw std::runtime_error("Failed to create Metal Texture Cache!");
+    }
+  }
+  return textureCache;
+}
+
+// pragma MARK: Get CVPixelBuffer MTLPixelFormat
+
+MTLPixelFormat SkiaCVPixelBufferUtils::getMTLPixelFormatForCVPixelBufferPlane(
+    CVPixelBufferRef pixelBuffer, size_t planeIndex) {
+  size_t width = CVPixelBufferGetWidthOfPlane(pixelBuffer, planeIndex);
+  size_t bytesPerRow =
+      CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, planeIndex);
+  double bytesPerPixel = round(static_cast<double>(bytesPerRow) / width);
+  if (bytesPerPixel == 1) {
+    return MTLPixelFormatR8Unorm;
+  } else if (bytesPerPixel == 2) {
+    return MTLPixelFormatRG8Unorm;
+  } else if (bytesPerPixel == 4) {
+    return MTLPixelFormatBGRA8Unorm;
+  } else [[unlikely]] {
+    throw std::runtime_error("Invalid bytes per row! Expected 1 (R), 2 (RG) or "
+                             "4 (RGBA), but received " +
+                             std::to_string(bytesPerPixel));
+  }
+}

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.h

@@ -26,7 +26,8 @@ public:
                                               int height);
   static sk_sp<SkSurface> makeOffscreenSurface(int width, int height);
 
-  static sk_sp<SkImage> makeTextureFromImage(sk_sp<SkImage> image);
+  static sk_sp<SkImage>
+  makeTextureFromCVPixelBuffer(CVPixelBufferRef pixelBuffer);
 
 private:
   static id<MTLDevice> device;

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.mm

@@ -1,6 +1,7 @@
 #import "RNSkLog.h"
 
-#include "SkiaMetalSurfaceFactory.h"
+#import "SkiaCVPixelBufferUtils.h"
+#import "SkiaMetalSurfaceFactory.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -106,12 +107,35 @@ sk_sp<SkSurface> SkiaMetalSurfaceFactory::makeOffscreenSurface(int width,
   return surface;
 }
 
-sk_sp<SkImage>
-SkiaMetalSurfaceFactory::makeTextureFromImage(sk_sp<SkImage> image) {
+sk_sp<SkImage> SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(
+    CVPixelBufferRef pixelBuffer) {
   if (!SkiaMetalSurfaceFactory::createSkiaDirectContextIfNecessary(
-          &ThreadContextHolder::ThreadSkiaMetalContext)) {
+          &ThreadContextHolder::ThreadSkiaMetalContext)) [[unlikely]] {
     throw std::runtime_error("Failed to create Skia Context for this Thread!");
   }
-  return SkImages::TextureFromImage(
-      ThreadContextHolder::ThreadSkiaMetalContext.skContext.get(), image);
+  const SkiaMetalContext &context = ThreadContextHolder::ThreadSkiaMetalContext;
+
+  SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat format =
+      SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(pixelBuffer);
+  switch (format) {
+  case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::rgb: {
+    // CVPixelBuffer is in any RGB format.
+    SkColorType colorType =
+        SkiaCVPixelBufferUtils::RGB::getCVPixelBufferColorType(pixelBuffer);
+    TextureHolder *texture =
+        SkiaCVPixelBufferUtils::RGB::getSkiaTextureForCVPixelBuffer(
+            pixelBuffer);
+    return SkImages::BorrowTextureFrom(
+        context.skContext.get(), texture->toGrBackendTexture(),
+        kTopLeft_GrSurfaceOrigin, colorType, kOpaque_SkAlphaType, nullptr,
+        [](void *texture) { delete (TextureHolder *)texture; },
+        (void *)texture);
+  }
+  default:
+    [[unlikely]] {
+      throw std::runtime_error("Failed to convert PlatformBuffer to SkImage - "
+                               "PlatformBuffer has unsupported PixelFormat! " +
+                               std::to_string(static_cast<int>(format)));
+    }
+  }
 }