@shopify/react-native-skia 1.6.0 → 1.7.0

package/ios/RNSkia-iOS/MetalContext.h

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

package/ios/RNSkia-iOS/MetalContext.mm

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

package/ios/RNSkia-iOS/MetalWindowContext.h

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

package/ios/RNSkia-iOS/MetalWindowContext.mm

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

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

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

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -1,6 +1,7 @@
 #import "RNSkiOSPlatformContext.h"
 
 #import <CoreMedia/CMSampleBuffer.h>
+#include <Metal/Metal.h>
 #import <React/RCTUtils.h>
 #include <thread>
 #include <utility>
@@ -81,8 +82,8 @@ uint64_t RNSkiOSPlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
 #else
     // on iOS, 32_BGRA is the only supported RGB format for CVPixelBuffers.
     image = image->makeColorTypeAndColorSpace(
-        MetalContext::getInstance()._context.skContext.get(),
-        kBGRA_8888_SkColorType, SkColorSpace::MakeSRGB());
+        MetalContext::getInstance().getDirectContext(), kBGRA_8888_SkColorType,
+        SkColorSpace::MakeSRGB());
 #endif
     if (image == nullptr) {
       throw std::runtime_error(
@@ -155,6 +156,38 @@ uint64_t RNSkiOSPlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
   return reinterpret_cast<uint64_t>(pixelBuffer);
 }
 
+const TextureInfo RNSkiOSPlatformContext::getTexture(sk_sp<SkImage> image) {
+  GrBackendTexture texture;
+  TextureInfo result;
+  if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
+    throw std::runtime_error("Couldn't get backend texture");
+  }
+  if (!texture.isValid()) {
+    throw std::runtime_error("Invalid backend texture");
+  }
+  GrMtlTextureInfo textureInfo;
+  if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
+    throw std::runtime_error("Couldn't get Metal texture info");
+  }
+  result.mtlTexture = textureInfo.fTexture.get();
+  return result;
+}
+
+const TextureInfo RNSkiOSPlatformContext::getTexture(sk_sp<SkSurface> surface) {
+  GrBackendTexture texture = SkSurfaces::GetBackendTexture(
+      surface.get(), SkSurfaces::BackendHandleAccess::kFlushRead);
+  TextureInfo result;
+  if (!texture.isValid()) {
+    throw std::runtime_error("Invalid backend texture");
+  }
+  GrMtlTextureInfo textureInfo;
+  if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
+    throw std::runtime_error("Couldn't get Metal texture info");
+  }
+  result.mtlTexture = textureInfo.fTexture.get();
+  return result;
+}
+
 std::shared_ptr<RNSkVideo>
 RNSkiOSPlatformContext::createVideo(const std::string &url) {
   return std::make_shared<RNSkiOSVideo>(url, this);
@@ -192,6 +225,59 @@ sk_sp<SkImage> RNSkiOSPlatformContext::makeImageFromNativeBuffer(void *buffer) {
 #endif
 }
 
+sk_sp<SkImage> RNSkiOSPlatformContext::makeImageFromNativeTexture(
+    const TextureInfo &texInfo, int width, int height, bool mipMapped) {
+  id<MTLTexture> mtlTexture = (__bridge id<MTLTexture>)(texInfo.mtlTexture);
+
+  SkColorType colorType = mtlPixelFormatToSkColorType(mtlTexture.pixelFormat);
+  if (colorType == SkColorType::kUnknown_SkColorType) {
+    throw std::runtime_error("Unsupported pixelFormat");
+  }
+
+  GrMtlTextureInfo textureInfo;
+  textureInfo.fTexture.retain((__bridge const void *)mtlTexture);
+
+  GrBackendTexture texture = GrBackendTextures::MakeMtl(
+      width, height, mipMapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo,
+      textureInfo);
+
+  return SkImages::BorrowTextureFrom(getDirectContext(), texture,
+                                     kTopLeft_GrSurfaceOrigin, colorType,
+                                     kPremul_SkAlphaType, nullptr);
+}
+
+SkColorType RNSkiOSPlatformContext::mtlPixelFormatToSkColorType(
+    MTLPixelFormat pixelFormat) {
+  switch (pixelFormat) {
+  case MTLPixelFormatRGBA8Unorm:
+    return kRGBA_8888_SkColorType;
+  case MTLPixelFormatBGRA8Unorm:
+    return kBGRA_8888_SkColorType;
+  case MTLPixelFormatRGB10A2Unorm:
+    return kRGBA_1010102_SkColorType;
+  case MTLPixelFormatR8Unorm:
+    return kGray_8_SkColorType;
+  case MTLPixelFormatRGBA16Float:
+    return kRGBA_F16_SkColorType;
+  case MTLPixelFormatRG8Unorm:
+    return kR8G8_unorm_SkColorType;
+  case MTLPixelFormatR16Float:
+    return kA16_float_SkColorType;
+  case MTLPixelFormatRG16Float:
+    return kR16G16_float_SkColorType;
+  case MTLPixelFormatR16Unorm:
+    return kA16_unorm_SkColorType;
+  case MTLPixelFormatRG16Unorm:
+    return kR16G16_unorm_SkColorType;
+  case MTLPixelFormatRGBA16Unorm:
+    return kR16G16B16A16_unorm_SkColorType;
+  case MTLPixelFormatRGBA8Unorm_sRGB:
+    return kSRGBA_8888_SkColorType;
+  default:
+    return kUnknown_SkColorType;
+  }
+}
+
 #if !defined(SK_GRAPHITE)
 GrDirectContext *RNSkiOSPlatformContext::getDirectContext() {
   return MetalContext::getInstance().getDirectContext();

package/ios/RNSkia-iOS/SkiaCVPixelBufferUtils.mm

@@ -6,29 +6,40 @@
 //
 
 #import "SkiaCVPixelBufferUtils.h"
-#import "SkiaMetalSurfaceFactory.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
+
+#import "include/core/SkCanvas.h"
 #import "include/core/SkColorSpace.h"
+
+#import <CoreMedia/CMSampleBuffer.h>
+#import <CoreVideo/CVMetalTextureCache.h>
+
 #import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/GrDirectContext.h>
 #import <include/gpu/ganesh/SkImageGanesh.h>
+#import <include/gpu/ganesh/SkSurfaceGanesh.h>
 #import <include/gpu/ganesh/mtl/GrMtlBackendContext.h>
 #import <include/gpu/ganesh/mtl/GrMtlBackendSurface.h>
 #import <include/gpu/ganesh/mtl/GrMtlDirectContext.h>
-#import <include/gpu/ganesh/mtl/GrMtlTypes.h>
 #import <include/gpu/ganesh/mtl/SkSurfaceMetal.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}
+  (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}
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
 #endif
 
 // pragma MARK: TextureHolder

package/ios/RNSkia-iOS/SkiaManager.mm

@@ -38,8 +38,7 @@
       // Create the RNSkiaManager (cross platform)
       _skManager = std::make_shared<RNSkia::RNSkManager>(
           jsRuntime, jsInvoker,
-          std::make_shared<RNSkia::RNSkiOSPlatformContext>(jsRuntime, bridge,
-                                                           jsInvoker));
+          std::make_shared<RNSkia::RNSkiOSPlatformContext>(bridge, jsInvoker));
     }
   }
   return self;

package/ios/RNSkia-iOS/SkiaUIView.mm

@@ -62,18 +62,7 @@
 #pragma mark Lifecycle
 
 - (void)willMoveToSuperview:(UIView *)newWindow {
-  if (newWindow == NULL) {
-    // Remove implementation view when the parent view is not set
-    if (_impl != nullptr) {
-      [_impl->getLayer() removeFromSuperlayer];
-
-      if (_nativeId != 0 && _manager != nullptr) {
-        _manager->setSkiaView(_nativeId, nullptr);
-      }
-
-      _impl = nullptr;
-    }
-  } else {
+  if (newWindow != nullptr) {
     // Create implementation view when the parent view is set
     if (_impl == nullptr && _manager != nullptr) {
       _impl = _factory(_manager->getPlatformContext());
@@ -90,6 +79,21 @@
   }
 }
 
+- (void)removeFromSuperview {
+  // Cleanup when removed from view hierarchy
+  if (_impl != nullptr) {
+    [_impl->getLayer() removeFromSuperlayer];
+
+    if (_nativeId != 0 && _manager != nullptr) {
+      _manager->setSkiaView(_nativeId, nullptr);
+    }
+
+    _impl = nullptr;
+  }
+
+  [super removeFromSuperview];
+}
+
 - (void)dealloc {
   [self unregisterView];
   [[NSNotificationCenter defaultCenter]
@@ -119,8 +123,6 @@
   if (_manager != nullptr && _nativeId != 0) {
     _manager->unregisterSkiaView(_nativeId);
   }
-
-  assert(_impl == nullptr);
 }
 
 #pragma Render
@@ -152,7 +154,7 @@
 }
 
 - (void)setOpaque:(bool)opaque {
-    _opaque = opaque;
+  _opaque = opaque;
 }
 
 - (void)setNativeId:(size_t)nativeId {

package/lib/commonjs/skia/types/Image/Image.d.ts

@@ -38,6 +38,16 @@ export interface SkImage extends SkJSIInstance<"Image"> {
      * Returns the ImageInfo describing the image.
      */
     getImageInfo(): ImageInfo;
+    /**
+     * Returns the backend texture of the image.
+     * The returned object can be used to create a Skia Image object.
+     * The returned object is backend specific and should be used with caution.
+     * It is the caller's responsibility to ensure that the texture is not used after the image is deleted.
+     * The returned object may be null if the image does not have a backend texture.
+     *
+     * @return backend texture of the image or null
+     */
+    getNativeTextureUnstable(): unknown;
     /**
      * Returns this image as a shader with the specified tiling. It will use cubic sampling.
      * @param tx - tile mode in the x direction.

package/lib/commonjs/skia/types/Image/Image.js.map

@@ -1 +1 @@
-{"version":3,"names":["FilterMode","exports","MipmapMode","ImageFormat"],"sources":["Image.ts"],"sourcesContent":["import type { SkMatrix } from \"../Matrix\";\nimport type { SkJSIInstance } from \"../JsiInstance\";\nimport type { TileMode } from \"../ImageFilter\";\nimport type { SkShader } from \"../Shader\";\n\nimport type { ImageInfo } from \"./ImageFactory\";\n\nexport interface CubicResampler {\n  B: number;\n  C: number;\n}\n\nexport interface FilterOptions {\n  filter: FilterMode;\n  mipmap?: MipmapMode;\n}\n\nexport enum FilterMode {\n  Nearest,\n  Linear,\n}\n\nexport enum MipmapMode {\n  None,\n  Nearest,\n  Linear,\n}\n\nexport enum ImageFormat {\n  JPEG = 3,\n  PNG = 4,\n  WEBP = 6,\n}\n\nexport interface SkImage extends SkJSIInstance<\"Image\"> {\n  /**\n   * Returns the possibly scaled height of the image.\n   */\n  height(): number;\n\n  /**\n   * Returns the possibly scaled width of the image.\n   */\n  width(): number;\n\n  /**\n   * Returns the ImageInfo describing the image.\n   */\n  getImageInfo(): ImageInfo;\n\n  /**\n   * Returns this image as a shader with the specified tiling. It will use cubic sampling.\n   * @param tx - tile mode in the x direction.\n   * @param ty - tile mode in the y direction.\n   * @param fm - The filter mode. (default nearest)\n   * @param mm - The mipmap mode. Note: for settings other than None, the image must have mipmaps (default none)\n   *             calculated with makeCopyWithDefaultMipmaps;\n   * @param localMatrix\n   */\n  makeShaderOptions(\n    tx: TileMode,\n    ty: TileMode,\n    fm: FilterMode,\n    mm: MipmapMode,\n    localMatrix?: SkMatrix\n  ): SkShader;\n\n  /**\n   * Returns this image as a shader with the specified tiling. It will use cubic sampling.\n   * @param tx - tile mode in the x direction.\n   * @param ty - tile mode in the y direction.\n   * @param B - See CubicResampler in SkSamplingOptions.h for more information\n   * @param C - See CubicResampler in SkSamplingOptions.h for more information\n   * @param localMatrix\n   */\n  makeShaderCubic(\n    tx: TileMode,\n    ty: TileMode,\n    B: number,\n    C: number,\n    localMatrix?: SkMatrix\n  ): SkShader;\n\n  /** Encodes Image pixels, returning result as UInt8Array. Returns existing\n     encoded data if present; otherwise, SkImage is encoded with\n     SkEncodedImageFormat::kPNG. Skia must be built with SK_ENCODE_PNG to encode\n     SkImage.\n\n    Returns nullptr if existing encoded data is missing or invalid, and\n    encoding fails.\n\n    @param fmt - PNG is the default value.\n    @param quality - a value from 0 to 100; 100 is the least lossy. May be ignored.\n\n    @return  Uint8Array with data\n  */\n  encodeToBytes(fmt?: ImageFormat, quality?: number): Uint8Array;\n\n  /** Encodes Image pixels, returning result as a base64 encoded string. Returns existing\n     encoded data if present; otherwise, SkImage is encoded with\n     SkEncodedImageFormat::kPNG. Skia must be built with SK_ENCODE_PNG to encode\n     SkImage.\n\n    Returns nullptr if existing encoded data is missing or invalid, and\n    encoding fails.\n\n    @param fmt - PNG is the default value.\n    @param quality - a value from 0 to 100; 100 is the least lossy. May be ignored.\n\n    @return  base64 encoded string of data\n  */\n  encodeToBase64(fmt?: ImageFormat, quality?: number): string;\n\n  /** Read Image pixels\n   *\n   * @param srcX - optional x-axis upper left corner of the rectangle to read from\n   * @param srcY - optional y-axis upper left corner of the rectangle to read from\n   * @param imageInfo - optional describes the pixel format and dimensions of the data to read into\n   * @return Float32Array or Uint8Array with data or null if the read failed.\n   */\n  readPixels(\n    srcX?: number,\n    srcY?: number,\n    imageInfo?: ImageInfo\n  ): Float32Array | Uint8Array | null;\n\n  /**\n   * Returns raster image or lazy image. Copies SkImage backed by GPU texture\n   * into CPU memory if needed. Returns original SkImage if decoded in raster\n   * bitmap, or if encoded in a stream.\n   */\n  makeNonTextureImage(): SkImage;\n}\n"],"mappings":";;;;;;IAiBYA,UAAU,GAAAC,OAAA,CAAAD,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAA,IAKVE,UAAU,GAAAD,OAAA,CAAAC,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAA,IAMVC,WAAW,GAAAF,OAAA,CAAAE,WAAA,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA","ignoreList":[]}
+{"version":3,"names":["FilterMode","exports","MipmapMode","ImageFormat"],"sources":["Image.ts"],"sourcesContent":["import type { SkMatrix } from \"../Matrix\";\nimport type { SkJSIInstance } from \"../JsiInstance\";\nimport type { TileMode } from \"../ImageFilter\";\nimport type { SkShader } from \"../Shader\";\n\nimport type { ImageInfo } from \"./ImageFactory\";\n\nexport interface CubicResampler {\n  B: number;\n  C: number;\n}\n\nexport interface FilterOptions {\n  filter: FilterMode;\n  mipmap?: MipmapMode;\n}\n\nexport enum FilterMode {\n  Nearest,\n  Linear,\n}\n\nexport enum MipmapMode {\n  None,\n  Nearest,\n  Linear,\n}\n\nexport enum ImageFormat {\n  JPEG = 3,\n  PNG = 4,\n  WEBP = 6,\n}\n\nexport interface SkImage extends SkJSIInstance<\"Image\"> {\n  /**\n   * Returns the possibly scaled height of the image.\n   */\n  height(): number;\n\n  /**\n   * Returns the possibly scaled width of the image.\n   */\n  width(): number;\n\n  /**\n   * Returns the ImageInfo describing the image.\n   */\n  getImageInfo(): ImageInfo;\n\n  /**\n   * Returns the backend texture of the image.\n   * The returned object can be used to create a Skia Image object.\n   * The returned object is backend specific and should be used with caution.\n   * It is the caller's responsibility to ensure that the texture is not used after the image is deleted.\n   * The returned object may be null if the image does not have a backend texture.\n   *\n   * @return backend texture of the image or null\n   */\n  getNativeTextureUnstable(): unknown;\n\n  /**\n   * Returns this image as a shader with the specified tiling. It will use cubic sampling.\n   * @param tx - tile mode in the x direction.\n   * @param ty - tile mode in the y direction.\n   * @param fm - The filter mode. (default nearest)\n   * @param mm - The mipmap mode. Note: for settings other than None, the image must have mipmaps (default none)\n   *             calculated with makeCopyWithDefaultMipmaps;\n   * @param localMatrix\n   */\n  makeShaderOptions(\n    tx: TileMode,\n    ty: TileMode,\n    fm: FilterMode,\n    mm: MipmapMode,\n    localMatrix?: SkMatrix\n  ): SkShader;\n\n  /**\n   * Returns this image as a shader with the specified tiling. It will use cubic sampling.\n   * @param tx - tile mode in the x direction.\n   * @param ty - tile mode in the y direction.\n   * @param B - See CubicResampler in SkSamplingOptions.h for more information\n   * @param C - See CubicResampler in SkSamplingOptions.h for more information\n   * @param localMatrix\n   */\n  makeShaderCubic(\n    tx: TileMode,\n    ty: TileMode,\n    B: number,\n    C: number,\n    localMatrix?: SkMatrix\n  ): SkShader;\n\n  /** Encodes Image pixels, returning result as UInt8Array. Returns existing\n     encoded data if present; otherwise, SkImage is encoded with\n     SkEncodedImageFormat::kPNG. Skia must be built with SK_ENCODE_PNG to encode\n     SkImage.\n\n    Returns nullptr if existing encoded data is missing or invalid, and\n    encoding fails.\n\n    @param fmt - PNG is the default value.\n    @param quality - a value from 0 to 100; 100 is the least lossy. May be ignored.\n\n    @return  Uint8Array with data\n  */\n  encodeToBytes(fmt?: ImageFormat, quality?: number): Uint8Array;\n\n  /** Encodes Image pixels, returning result as a base64 encoded string. Returns existing\n     encoded data if present; otherwise, SkImage is encoded with\n     SkEncodedImageFormat::kPNG. Skia must be built with SK_ENCODE_PNG to encode\n     SkImage.\n\n    Returns nullptr if existing encoded data is missing or invalid, and\n    encoding fails.\n\n    @param fmt - PNG is the default value.\n    @param quality - a value from 0 to 100; 100 is the least lossy. May be ignored.\n\n    @return  base64 encoded string of data\n  */\n  encodeToBase64(fmt?: ImageFormat, quality?: number): string;\n\n  /** Read Image pixels\n   *\n   * @param srcX - optional x-axis upper left corner of the rectangle to read from\n   * @param srcY - optional y-axis upper left corner of the rectangle to read from\n   * @param imageInfo - optional describes the pixel format and dimensions of the data to read into\n   * @return Float32Array or Uint8Array with data or null if the read failed.\n   */\n  readPixels(\n    srcX?: number,\n    srcY?: number,\n    imageInfo?: ImageInfo\n  ): Float32Array | Uint8Array | null;\n\n  /**\n   * Returns raster image or lazy image. Copies SkImage backed by GPU texture\n   * into CPU memory if needed. Returns original SkImage if decoded in raster\n   * bitmap, or if encoded in a stream.\n   */\n  makeNonTextureImage(): SkImage;\n}\n"],"mappings":";;;;;;IAiBYA,UAAU,GAAAC,OAAA,CAAAD,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAA,IAKVE,UAAU,GAAAD,OAAA,CAAAC,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAA,IAMVC,WAAW,GAAAF,OAAA,CAAAE,WAAA,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA","ignoreList":[]}

package/lib/commonjs/skia/types/Image/ImageFactory.d.ts

@@ -41,6 +41,24 @@ export interface ImageFactory {
      * native buffer is invalid.
      */
     MakeImageFromNativeBuffer: (nativeBuffer: NativeBuffer) => SkImage;
+    /**
+     *
+     * Return an Image backed by a given native texture.
+     *
+     * The native texture must be a valid owning reference.
+     *
+     * This API might be used to integrate with other libraries using gpu textures,
+     * or to transfer images between different threads.
+     *
+     * @param texture A native texture handle
+     * @param width The width of the texture
+     * @param height The height of the texture
+     * @param mipmapped Whether the texture is mipmapped
+     * @throws Throws an error if the Image could not be created, for example when the given native texture is invalid.
+     *
+     * @returns Returns a valid SkImage, if the texture is invalid, an error is thrown.
+     */
+    MakeImageFromNativeTextureUnstable: (texture: unknown, width: number, height: number, mipmapped?: boolean) => SkImage;
     /**
      * Returns an image that will be a screenshot of the view represented by
      * the view tag

package/lib/commonjs/skia/types/Image/ImageFactory.js.map

@@ -1 +1 @@
-{"version":3,"names":["AlphaType","exports"],"sources":["ImageFactory.ts"],"sourcesContent":["import type { SkData } from \"../Data\";\nimport type { NativeBuffer } from \"../NativeBuffer\";\n\nimport type { ColorType } from \"./ColorType\";\nimport type { SkImage } from \"./Image\";\n\nexport enum AlphaType {\n  Unknown,\n  Opaque,\n  Premul,\n  Unpremul,\n}\n\nexport interface ImageInfo {\n  alphaType: AlphaType;\n  // TODO: add support for color space\n  // colorSpace: ColorSpace;\n  colorType: ColorType;\n  height: number;\n  width: number;\n}\n\nexport interface ImageFactory {\n  /**\n   * Return an Image backed by the encoded data, but attempt to defer decoding until the image\n   * is actually used/drawn. This deferral allows the system to cache the result, either on the\n   * CPU or on the GPU, depending on where the image is drawn.\n   * This decoding uses the codecs that have been compiled into CanvasKit. If the bytes are\n   * invalid (or an unrecognized codec), null will be returned. See Image.h for more details.\n   * @param data - Data object with bytes of data\n   * @returns If the encoded format is not supported, or subset is outside of the bounds of the decoded\n   *  image, nullptr is returned.\n   */\n  MakeImageFromEncoded: (encoded: SkData) => SkImage | null;\n\n  /**\n   * Return an Image backed by a given native buffer.\n   * The native buffer must be a valid owning reference.\n   *\n   * For instance, this API is used by\n   * [react-native-vision-camera](https://github.com/mrousavy/react-native-vision-camera)\n   * to render a Skia Camera preview.\n   *\n   * - On Android; This is an `AHardwareBuffer*`\n   * - On iOS, this is a `CVPixelBufferRef`\n   * @param nativeBuffer A strong `uintptr_t` pointer to the native buffer\n   * @throws Throws an error if the Image could not be created, for example when the given\n   * native buffer is invalid.\n   */\n  MakeImageFromNativeBuffer: (nativeBuffer: NativeBuffer) => SkImage;\n\n  /**\n   * Returns an image that will be a screenshot of the view represented by\n   * the view tag\n   * @param viewTag - The tag of the view to make an image from.\n   * @returns Returns a valid SkImage, if the view tag is invalid, nullptr is returned.\n   */\n  MakeImageFromViewTag: (viewTag: number) => Promise<SkImage | null>;\n\n  /**\n   * Returns an image with the given pixel data and format.\n   * Note that we will always make a copy of the pixel data, because of inconsistencies in\n   * behavior between GPU and CPU (i.e. the pixel data will be turned into a GPU texture and\n   * not modifiable after creation).\n   *\n   * @param info\n   * @param data - bytes representing the pixel data.\n   * @param bytesPerRow\n   */\n  MakeImage(info: ImageInfo, data: SkData, bytesPerRow: number): SkImage | null;\n}\n"],"mappings":";;;;;;IAMYA,SAAS,GAAAC,OAAA,CAAAD,SAAA,0BAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAAA,OAATA,SAAS;AAAA","ignoreList":[]}
+{"version":3,"names":["AlphaType","exports"],"sources":["ImageFactory.ts"],"sourcesContent":["import type { SkData } from \"../Data\";\nimport type { NativeBuffer } from \"../NativeBuffer\";\n\nimport type { ColorType } from \"./ColorType\";\nimport type { SkImage } from \"./Image\";\n\nexport enum AlphaType {\n  Unknown,\n  Opaque,\n  Premul,\n  Unpremul,\n}\n\nexport interface ImageInfo {\n  alphaType: AlphaType;\n  // TODO: add support for color space\n  // colorSpace: ColorSpace;\n  colorType: ColorType;\n  height: number;\n  width: number;\n}\n\nexport interface ImageFactory {\n  /**\n   * Return an Image backed by the encoded data, but attempt to defer decoding until the image\n   * is actually used/drawn. This deferral allows the system to cache the result, either on the\n   * CPU or on the GPU, depending on where the image is drawn.\n   * This decoding uses the codecs that have been compiled into CanvasKit. If the bytes are\n   * invalid (or an unrecognized codec), null will be returned. See Image.h for more details.\n   * @param data - Data object with bytes of data\n   * @returns If the encoded format is not supported, or subset is outside of the bounds of the decoded\n   *  image, nullptr is returned.\n   */\n  MakeImageFromEncoded: (encoded: SkData) => SkImage | null;\n\n  /**\n   * Return an Image backed by a given native buffer.\n   * The native buffer must be a valid owning reference.\n   *\n   * For instance, this API is used by\n   * [react-native-vision-camera](https://github.com/mrousavy/react-native-vision-camera)\n   * to render a Skia Camera preview.\n   *\n   * - On Android; This is an `AHardwareBuffer*`\n   * - On iOS, this is a `CVPixelBufferRef`\n   * @param nativeBuffer A strong `uintptr_t` pointer to the native buffer\n   * @throws Throws an error if the Image could not be created, for example when the given\n   * native buffer is invalid.\n   */\n  MakeImageFromNativeBuffer: (nativeBuffer: NativeBuffer) => SkImage;\n\n  /**\n   *\n   * Return an Image backed by a given native texture.\n   *\n   * The native texture must be a valid owning reference.\n   *\n   * This API might be used to integrate with other libraries using gpu textures,\n   * or to transfer images between different threads.\n   *\n   * @param texture A native texture handle\n   * @param width The width of the texture\n   * @param height The height of the texture\n   * @param mipmapped Whether the texture is mipmapped\n   * @throws Throws an error if the Image could not be created, for example when the given native texture is invalid.\n   *\n   * @returns Returns a valid SkImage, if the texture is invalid, an error is thrown.\n   */\n  MakeImageFromNativeTextureUnstable: (\n    texture: unknown,\n    width: number,\n    height: number,\n    mipmapped?: boolean\n  ) => SkImage;\n\n  /**\n   * Returns an image that will be a screenshot of the view represented by\n   * the view tag\n   * @param viewTag - The tag of the view to make an image from.\n   * @returns Returns a valid SkImage, if the view tag is invalid, nullptr is returned.\n   */\n  MakeImageFromViewTag: (viewTag: number) => Promise<SkImage | null>;\n\n  /**\n   * Returns an image with the given pixel data and format.\n   * Note that we will always make a copy of the pixel data, because of inconsistencies in\n   * behavior between GPU and CPU (i.e. the pixel data will be turned into a GPU texture and\n   * not modifiable after creation).\n   *\n   * @param info\n   * @param data - bytes representing the pixel data.\n   * @param bytesPerRow\n   */\n  MakeImage(info: ImageInfo, data: SkData, bytesPerRow: number): SkImage | null;\n}\n"],"mappings":";;;;;;IAMYA,SAAS,GAAAC,OAAA,CAAAD,SAAA,0BAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAATA,SAAS,CAATA,SAAS;EAAA,OAATA,SAAS;AAAA","ignoreList":[]}