@shopify/react-native-skia 1.2.1 → 1.2.3

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

@@ -16,16 +16,13 @@ namespace RNSkia {
 thread_local SkiaOpenGLContext ThreadContextHolder::ThreadSkiaOpenGLContext;
 
 sk_sp<SkImage>
-SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer) {
+SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer,
+                                                      bool requireKnownFormat) {
 #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;
+          &ThreadContextHolder::ThreadSkiaOpenGLContext)) [[unlikely]] {
+    throw std::runtime_error("Failed to create Skia Context for this Thread!");
   }
   const AHardwareBuffer *hardwareBuffer =
       static_cast<AHardwareBuffer *>(buffer);
@@ -35,23 +32,46 @@ SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(void *buffer) {
 
   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;
+  switch (description.format) {
+  // TODO: find out if we can detect, which graphic buffers support
+  // GR_GL_TEXTURE_2D
+  case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+  case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+    format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+    format = GrBackendFormats::MakeGL(GR_GL_RGBA16F, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+    format = GrBackendFormats::MakeGL(GR_GL_RGB565, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+    format = GrBackendFormats::MakeGL(GR_GL_RGB10_A2, GR_GL_TEXTURE_EXTERNAL);
+  case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+    format = GrBackendFormats::MakeGL(GR_GL_RGB8, GR_GL_TEXTURE_EXTERNAL);
+#if __ANDROID_API__ >= 33
+  case AHARDWAREBUFFER_FORMAT_R8_UNORM:
+    format = GrBackendFormats::MakeGL(GR_GL_R8, GR_GL_TEXTURE_EXTERNAL);
+#endif
+  default:
+    if (requireKnownFormat) {
+      format = GrBackendFormat();
+    } else {
+      format = GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
+    }
   }
-  GrBackendFormat format =
-      GrBackendFormats::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_EXTERNAL);
 
   auto backendTex = MakeGLBackendTexture(
       ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
       const_cast<AHardwareBuffer *>(hardwareBuffer), description.width,
       description.height, &deleteImageProc, &updateImageProc, &deleteImageCtx,
       false, format, false);
+  if (!backendTex.isValid()) [[unlikely]] {
+    throw std::runtime_error(
+        "Failed to convert HardwareBuffer to OpenGL Texture!");
+  }
   sk_sp<SkImage> image = SkImages::BorrowTextureFrom(
       ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
       backendTex, kTopLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType,
-      kOpaque_SkAlphaType, nullptr);
+      kOpaque_SkAlphaType, nullptr, deleteImageProc, deleteImageCtx);
   return image;
 #else
   throw std::runtime_error(

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

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

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

@@ -162,16 +162,21 @@ public class ViewScreenshotService {
                 latch.await(SURFACE_VIEW_READ_PIXELS_TIMEOUT, TimeUnit.SECONDS);
             } catch (Exception e) {
                 Log.e(TAG, "Cannot PixelCopy for " + sv, e);
+                drawSurfaceViewFromCache(canvas, sv, paint, opacity);
             }
         } else {
-            Bitmap cache = sv.getDrawingCache();
-            if (cache != null) {
-                canvas.save();
-                applyTransformations(canvas, sv);
-                paint.setAlpha(Math.round(opacity * 255)); // Set paint alpha based on opacity
-                canvas.drawBitmap(cache, 0, 0, paint);
-                canvas.restore();
-            }
+            drawSurfaceViewFromCache(canvas, sv, paint, opacity);
+        }
+    }
+
+    private static void drawSurfaceViewFromCache(Canvas canvas, SurfaceView sv, Paint paint, float opacity) {
+        Bitmap cache = sv.getDrawingCache();
+        if (cache != null) {
+            canvas.save();
+            applyTransformations(canvas, sv);
+            paint.setAlpha(Math.round(opacity * 255)); // Set paint alpha based on opacity
+            canvas.drawBitmap(cache, 0, 0, paint);
+            canvas.restore();
         }
     }
 

package/cpp/api/JsiSkImageFactory.h

@@ -29,11 +29,11 @@ public:
 
   JSI_HOST_FUNCTION(MakeImageFromNativeBuffer) {
     jsi::BigInt pointer = arguments[0].asBigInt(runtime);
-    const uintptr_t platformBufferPointer = pointer.asUint64(runtime);
-    void *rawPointer = reinterpret_cast<void *>(platformBufferPointer);
+    const uintptr_t nativeBufferPointer = pointer.asUint64(runtime);
+    void *rawPointer = reinterpret_cast<void *>(nativeBufferPointer);
     auto image = getContext()->makeImageFromNativeBuffer(rawPointer);
     if (image == nullptr) {
-      throw std::runtime_error("Failed to convert PlatformBuffer to SkImage!");
+      throw std::runtime_error("Failed to convert NativeBuffer to SkImage!");
     }
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));

package/cpp/rnskia/RNSkPlatformContext.h

@@ -134,10 +134,10 @@ 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*`
+   * Creates an image from a native buffer.
+   * - On iOS, this is a `CVPixelBufferRef`
    * - On Android, this is a `AHardwareBuffer*`
-   * @param buffer The native platform buffer.
+   * @param buffer The native buffer.
    * @return sk_sp<SkImage>
    */
   virtual sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) = 0;

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -59,11 +59,7 @@ void RNSkiOSPlatformContext::performStreamOperation(
 }
 
 void RNSkiOSPlatformContext::releaseNativeBuffer(uint64_t pointer) {
-  CMSampleBufferRef sampleBuffer = reinterpret_cast<CMSampleBufferRef>(pointer);
-  CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
-  if (sampleBuffer) {
-    CFRelease(sampleBuffer);
-  }
+  CVPixelBufferRef pixelBuffer = reinterpret_cast<CVPixelBufferRef>(pointer);
   if (pixelBuffer) {
     CFRelease(pixelBuffer);
   }
@@ -79,7 +75,7 @@ uint64_t RNSkiOSPlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
     if (image == nullptr) {
       throw std::runtime_error(
           "Failed to convert image to BGRA_8888 colortype! Only BGRA_8888 "
-          "PlatformBuffers are supported.");
+          "NativeBuffers are supported.");
     }
   }
 

package/ios/RNSkia-iOS/SkiaCVPixelBufferUtils.h

@@ -6,6 +6,9 @@
 //
 
 #pragma once
+
+#import <vector>
+
 #import <CoreMedia/CMSampleBuffer.h>
 #import <CoreVideo/CVMetalTextureCache.h>
 #import <MetalKit/MetalKit.h>
@@ -13,7 +16,9 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 #import "include/core/SkColorSpace.h"
-#import <include/gpu/GrBackendSurface.h>
+#import "include/core/SkImage.h"
+#import "include/gpu/GrBackendSurface.h"
+#import "include/gpu/GrYUVABackendTextures.h"
 #pragma clang diagnostic pop
 
 /**
@@ -36,7 +41,7 @@ public:
    retained with `CFRetain`, and will later be manually
    released with `CFRelease`.
    */
-  explicit TextureHolder(CVMetalTextureRef texture);
+  TextureHolder(CVMetalTextureRef texture);
   ~TextureHolder();
 
   /**
@@ -48,9 +53,21 @@ 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 };
+  enum class CVPixelBufferBaseFormat { rgb, yuv };
 
   /**
    Get the base format (currently only RGB) of the PixelBuffer.
@@ -63,14 +80,32 @@ public:
   class RGB {
   public:
     /**
-     Gets the Skia Color Type of the RGB pixel-buffer.
+     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:
     /**
-     Gets a GPU-backed Skia Texture for the given RGB CVPixelBuffer.
+     Creates a GPU-backed Skia Texture (SkImage) with the given YUV
+     CVPixelBuffer.
      */
-    static TextureHolder *
-    getSkiaTextureForCVPixelBuffer(CVPixelBufferRef pixelBuffer);
+    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:

package/ios/RNSkia-iOS/SkiaCVPixelBufferUtils.mm

@@ -12,6 +12,7 @@
 #pragma clang diagnostic ignored "-Wdocumentation"
 #import "include/core/SkColorSpace.h"
 #import <include/gpu/GrBackendSurface.h>
+#import <include/gpu/ganesh/SkImageGanesh.h>
 #pragma clang diagnostic pop
 
 #include <TargetConditionals.h>
@@ -32,7 +33,10 @@
 // pragma MARK: TextureHolder
 
 TextureHolder::TextureHolder(CVMetalTextureRef texture) : _texture(texture) {}
-TextureHolder::~TextureHolder() { CFRelease(_texture); }
+TextureHolder::~TextureHolder() {
+  // ARC will now automatically release _texture.
+  CFRelease(_texture);
+}
 
 GrBackendTexture TextureHolder::toGrBackendTexture() {
   // Unwrap the underlying MTLTexture
@@ -51,6 +55,16 @@ GrBackendTexture TextureHolder::toGrBackendTexture() {
   return texture;
 }
 
+MultiTexturesHolder::~MultiTexturesHolder() {
+  for (TextureHolder *texture : _textures) {
+    delete texture;
+  }
+}
+
+void MultiTexturesHolder::addTexture(TextureHolder *texture) {
+  _textures.push_back(texture);
+}
+
 // pragma MARK: Base
 
 SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat
@@ -59,12 +73,30 @@ SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(
   OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
 
   switch (format) {
+  // 8-bit YUV formats
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+  // 10-bit YUV formats
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    return CVPixelBufferBaseFormat::yuv;
+  case kCVPixelFormatType_24RGB:
+  case kCVPixelFormatType_24BGR:
+  case kCVPixelFormatType_32ARGB:
   case kCVPixelFormatType_32BGRA:
+  case kCVPixelFormatType_32ABGR:
   case kCVPixelFormatType_32RGBA:
     return CVPixelBufferBaseFormat::rgb;
   default:
     [[unlikely]] throw std::runtime_error(
-        "CVPixelBuffer has unsupported pixel-format! " +
+        "CVPixelBuffer has unknown pixel format! " +
+        std::string("Expected: any RGB or YUV format, Received: ") +
         std::string(FourCC2Str(format)));
   }
 }
@@ -80,7 +112,7 @@ SkColorType SkiaCVPixelBufferUtils::RGB::getCVPixelBufferColorType(
     [[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
+  // This can be extended with branches for specific RGB formats if Apple
   // uses new formats.
   default:
     [[unlikely]] throw std::runtime_error(
@@ -89,9 +121,150 @@ SkColorType SkiaCVPixelBufferUtils::RGB::getCVPixelBufferColorType(
   }
 }
 
-TextureHolder *SkiaCVPixelBufferUtils::RGB::getSkiaTextureForCVPixelBuffer(
+sk_sp<SkImage> SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
+    GrDirectContext *context, CVPixelBufferRef pixelBuffer) {
+  // 1. Get Skia color type for RGB buffer
+  SkColorType colorType = getCVPixelBufferColorType(pixelBuffer);
+
+  // 2. Get texture, RGB buffers only have one plane
+  TextureHolder *texture =
+      getSkiaTextureForCVPixelBufferPlane(pixelBuffer, /* planeIndex */ 0);
+
+  // 3. Convert to image with manual memory cleanup
+  return SkImages::BorrowTextureFrom(
+      context, texture->toGrBackendTexture(), kTopLeft_GrSurfaceOrigin,
+      colorType, kOpaque_SkAlphaType, nullptr,
+      [](void *texture) { delete (TextureHolder *)texture; }, (void *)texture);
+}
+
+// pragma MARK: YUV
+
+sk_sp<SkImage> SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
+    GrDirectContext *context, CVPixelBufferRef pixelBuffer) {
+  // 1. Get all planes (YUV, Y_UV, Y_U_V or Y_U_V_A)
+  size_t planesCount = CVPixelBufferGetPlaneCount(pixelBuffer);
+  MultiTexturesHolder *texturesHolder = new MultiTexturesHolder();
+  GrBackendTexture textures[planesCount];
+
+  for (size_t planeIndex = 0; planeIndex < planesCount; planeIndex++) {
+    TextureHolder *textureHolder =
+        getSkiaTextureForCVPixelBufferPlane(pixelBuffer, planeIndex);
+    textures[planeIndex] = textureHolder->toGrBackendTexture();
+    texturesHolder->addTexture(textureHolder);
+  }
+
+  // 2. Wrap info about buffer
+  SkYUVAInfo info = getYUVAInfoForCVPixelBuffer(pixelBuffer);
+
+  // 3. Wrap as YUVA textures type
+  GrYUVABackendTextures yuvaTextures(info, textures, kTopLeft_GrSurfaceOrigin);
+
+  // 4. Wrap into SkImage type with manualy memory cleanup
+  return SkImages::TextureFromYUVATextures(
+      context, yuvaTextures, nullptr,
+      [](void *textureHolders) {
+        delete (MultiTexturesHolder *)textureHolders;
+      },
+      (void *)texturesHolder);
+}
+
+SkYUVAInfo SkiaCVPixelBufferUtils::YUV::getYUVAInfoForCVPixelBuffer(
     CVPixelBufferRef pixelBuffer) {
-  return getSkiaTextureForCVPixelBufferPlane(pixelBuffer, /* planeIndex */ 0);
+  size_t width = CVPixelBufferGetWidth(pixelBuffer);
+  size_t height = CVPixelBufferGetHeight(pixelBuffer);
+  SkISize size =
+      SkISize::Make(static_cast<int>(width), static_cast<int>(height));
+
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+  SkYUVAInfo::PlaneConfig planeConfig = getPlaneConfig(format);
+  SkYUVAInfo::Subsampling subsampling = getSubsampling(format);
+  SkYUVColorSpace colorspace = getColorspace(format);
+
+  return SkYUVAInfo(size, planeConfig, subsampling, colorspace);
+}
+
+// pragma MARK: YUV getPlaneConfig()
+
+SkYUVAInfo::PlaneConfig
+SkiaCVPixelBufferUtils::YUV::getPlaneConfig(OSType pixelFormat) {
+  switch (pixelFormat) {
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+    return SkYUVAInfo::PlaneConfig::kYUV;
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    [[likely]] return SkYUVAInfo::PlaneConfig::kY_UV;
+
+  // This can be extended with branches for specific YUV formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error("Invalid pixel format! " +
+                                          std::string(FourCC2Str(pixelFormat)));
+  }
+}
+
+// pragma MARK: YUV getSubsampling()
+
+SkYUVAInfo::Subsampling
+SkiaCVPixelBufferUtils::YUV::getSubsampling(OSType pixelFormat) {
+  switch (pixelFormat) {
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+    [[likely]] return SkYUVAInfo::Subsampling::k420;
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+    return SkYUVAInfo::Subsampling::k422;
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    return SkYUVAInfo::Subsampling::k444;
+  // This can be extended with branches for specific YUV formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error("Invalid pixel format! " +
+                                          std::string(FourCC2Str(pixelFormat)));
+  }
+}
+
+// pragma MARK: YUV getColorspace()
+
+SkYUVColorSpace SkiaCVPixelBufferUtils::YUV::getColorspace(OSType pixelFormat) {
+  switch (pixelFormat) {
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+    [[likely]]
+    // 8-bit limited
+    return SkYUVColorSpace::kRec709_Limited_SkYUVColorSpace;
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+    [[likely]]
+    // 8-bit full
+    return SkYUVColorSpace::kRec709_Full_SkYUVColorSpace;
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+    // 10-bit limited
+    return SkYUVColorSpace::kBT2020_10bit_Limited_SkYUVColorSpace;
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    // 10-bit full
+    return SkYUVColorSpace::kBT2020_10bit_Full_SkYUVColorSpace;
+  // This can be extended with branches for specific YUV formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error("Invalid pixel format! " +
+                                          std::string(FourCC2Str(pixelFormat)));
+  }
 }
 
 // pragma MARK: CVPixelBuffer -> Skia Texture

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.mm

@@ -119,22 +119,19 @@ sk_sp<SkImage> SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(
       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);
+    // CVPixelBuffer is in any RGB format, single-plane
+    return SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
+        context.skContext.get(), pixelBuffer);
+  }
+  case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::yuv: {
+    // CVPixelBuffer is in any YUV format, multi-plane
+    return SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
+        context.skContext.get(), pixelBuffer);
   }
   default:
     [[unlikely]] {
-      throw std::runtime_error("Failed to convert PlatformBuffer to SkImage - "
-                               "PlatformBuffer has unsupported PixelFormat! " +
+      throw std::runtime_error("Failed to convert NativeBuffer to SkImage - "
+                               "NativeBuffer has unsupported PixelFormat! " +
                                std::to_string(static_cast<int>(format)));
     }
   }

package/lib/commonjs/external/ModuleProxy.d.ts

@@ -0,0 +1,10 @@
+type ImportType = ReturnType<typeof require>;
+/**
+ * Create a lazily-imported module proxy.
+ * This is useful for lazily requiring optional dependencies.
+ */
+export declare const createModuleProxy: <TModule>(getModule: () => ImportType) => TModule;
+export declare class OptionalDependencyNotInstalledError extends Error {
+    constructor(name: string);
+}
+export {};

package/lib/commonjs/external/ModuleProxy.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModuleProxy = exports.OptionalDependencyNotInstalledError = void 0;
+// https://github.com/mrousavy/react-native-vision-camera/blob/main/package/src/dependencies/ModuleProxy.ts
+
+/**
+ * Create a lazily-imported module proxy.
+ * This is useful for lazily requiring optional dependencies.
+ */
+const createModuleProxy = getModule => {
+  const holder = {
+    module: undefined
+  };
+  const proxy = new Proxy(holder, {
+    get: (target, property) => {
+      if (target.module == null) {
+        // lazy initialize module via require()
+        // caller needs to make sure the require() call is wrapped in a try/catch
+        target.module = getModule();
+      }
+      return target.module[property];
+    }
+  });
+  return proxy;
+};
+exports.createModuleProxy = createModuleProxy;
+class OptionalDependencyNotInstalledError extends Error {
+  constructor(name) {
+    super(`${name} is not installed!`);
+  }
+}
+exports.OptionalDependencyNotInstalledError = OptionalDependencyNotInstalledError;
+//# sourceMappingURL=ModuleProxy.js.map

package/lib/commonjs/external/ModuleProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createModuleProxy","getModule","holder","module","undefined","proxy","Proxy","get","target","property","exports","OptionalDependencyNotInstalledError","Error","constructor","name"],"sources":["ModuleProxy.ts"],"sourcesContent":["// https://github.com/mrousavy/react-native-vision-camera/blob/main/package/src/dependencies/ModuleProxy.ts\ntype ImportType = ReturnType<typeof require>;\n\n/**\n * Create a lazily-imported module proxy.\n * This is useful for lazily requiring optional dependencies.\n */\nexport const createModuleProxy = <TModule>(\n  getModule: () => ImportType\n): TModule => {\n  const holder: { module: TModule | undefined } = { module: undefined };\n\n  const proxy = new Proxy(holder, {\n    get: (target, property) => {\n      if (target.module == null) {\n        // lazy initialize module via require()\n        // caller needs to make sure the require() call is wrapped in a try/catch\n        target.module = getModule() as TModule;\n      }\n      return target.module[property as keyof typeof holder.module];\n    },\n  });\n  return proxy as unknown as TModule;\n};\n\nexport class OptionalDependencyNotInstalledError extends Error {\n  constructor(name: string) {\n    super(`${name} is not installed!`);\n  }\n}\n"],"mappings":";;;;;;AAAA;;AAGA;AACA;AACA;AACA;AACO,MAAMA,iBAAiB,GAC5BC,SAA2B,IACf;EACZ,MAAMC,MAAuC,GAAG;IAAEC,MAAM,EAAEC;EAAU,CAAC;EAErE,MAAMC,KAAK,GAAG,IAAIC,KAAK,CAACJ,MAAM,EAAE;IAC9BK,GAAG,EAAEA,CAACC,MAAM,EAAEC,QAAQ,KAAK;MACzB,IAAID,MAAM,CAACL,MAAM,IAAI,IAAI,EAAE;QACzB;QACA;QACAK,MAAM,CAACL,MAAM,GAAGF,SAAS,CAAC,CAAY;MACxC;MACA,OAAOO,MAAM,CAACL,MAAM,CAACM,QAAQ,CAA+B;IAC9D;EACF,CAAC,CAAC;EACF,OAAOJ,KAAK;AACd,CAAC;AAACK,OAAA,CAAAV,iBAAA,GAAAA,iBAAA;AAEK,MAAMW,mCAAmC,SAASC,KAAK,CAAC;EAC7DC,WAAWA,CAACC,IAAY,EAAE;IACxB,KAAK,CAAE,GAAEA,IAAK,oBAAmB,CAAC;EACpC;AACF;AAACJ,OAAA,CAAAC,mCAAA,GAAAA,mCAAA"}

package/lib/commonjs/external/reanimated/ReanimatedProxy.d.ts

@@ -0,0 +1,3 @@
+import type * as ReanimatedT from "react-native-reanimated";
+declare const Reanimated: typeof ReanimatedT;
+export default Reanimated;

package/lib/commonjs/external/reanimated/ReanimatedProxy.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ModuleProxy = require("../ModuleProxy");
+const Reanimated = (0, _ModuleProxy.createModuleProxy)(() => {
+  try {
+    return require("react-native-reanimated");
+  } catch (e) {
+    throw new _ModuleProxy.OptionalDependencyNotInstalledError("react-native-reanimated");
+  }
+});
+
+// eslint-disable-next-line import/no-default-export
+var _default = exports.default = Reanimated;
+//# sourceMappingURL=ReanimatedProxy.js.map

package/lib/commonjs/external/reanimated/ReanimatedProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ModuleProxy","require","Reanimated","createModuleProxy","e","OptionalDependencyNotInstalledError","_default","exports","default"],"sources":["ReanimatedProxy.ts"],"sourcesContent":["import type * as ReanimatedT from \"react-native-reanimated\";\n\nimport {\n  OptionalDependencyNotInstalledError,\n  createModuleProxy,\n} from \"../ModuleProxy\";\ntype TReanimated = typeof ReanimatedT;\n\nconst Reanimated = createModuleProxy<TReanimated>(() => {\n  try {\n    return require(\"react-native-reanimated\");\n  } catch (e) {\n    throw new OptionalDependencyNotInstalledError(\"react-native-reanimated\");\n  }\n});\n\n// eslint-disable-next-line import/no-default-export\nexport default Reanimated;\n"],"mappings":";;;;;;AAEA,IAAAA,YAAA,GAAAC,OAAA;AAMA,MAAMC,UAAU,GAAG,IAAAC,8BAAiB,EAAc,MAAM;EACtD,IAAI;IACF,OAAOF,OAAO,CAAC,yBAAyB,CAAC;EAC3C,CAAC,CAAC,OAAOG,CAAC,EAAE;IACV,MAAM,IAAIC,gDAAmC,CAAC,yBAAyB,CAAC;EAC1E;AACF,CAAC,CAAC;;AAEF;AAAA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GACeN,UAAU"}

package/lib/commonjs/external/reanimated/buffers.js

@@ -6,17 +6,20 @@ Object.defineProperty(exports, "__esModule", {
 exports.useRectBuffer = exports.useRSXformBuffer = exports.usePointBuffer = exports.useColorBuffer = void 0;
 var _react = require("react");
 var _skia = require("../../skia");
-var _moduleWrapper = require("./moduleWrapper");
 var _interpolators = require("./interpolators");
-const useBufferValue = (size, bufferInitializer) => (0, _react.useMemo)(() => (0, _moduleWrapper.makeMutable)(new Array(size).fill(0).map(bufferInitializer)),
-// eslint-disable-next-line react-hooks/exhaustive-deps
-[size]);
+var _ReanimatedProxy = _interopRequireDefault(require("./ReanimatedProxy"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const useBufferValue = (size, bufferInitializer) => {
+  return (0, _react.useMemo)(() => _ReanimatedProxy.default.makeMutable(new Array(size).fill(0).map(bufferInitializer)),
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [size]);
+};
 const useBuffer = (size, bufferInitializer, modifier) => {
   var _mod$__closure;
   const values = useBufferValue(size, bufferInitializer);
   const mod = modifier;
   const deps = [size, ...Object.values((_mod$__closure = mod.__closure) !== null && _mod$__closure !== void 0 ? _mod$__closure : {})];
-  const mapperId = (0, _moduleWrapper.startMapper)(() => {
+  const mapperId = _ReanimatedProxy.default.startMapper(() => {
     "worklet";
 
     values.value.forEach((val, index) => {
@@ -26,7 +29,7 @@ const useBuffer = (size, bufferInitializer, modifier) => {
   }, deps);
   (0, _react.useEffect)(() => {
     return () => {
-      (0, _moduleWrapper.stopMapper)(mapperId);
+      _ReanimatedProxy.default.stopMapper(mapperId);
     };
   }, [mapperId]);
   return values;