react-native-skia 3.0.4 → 3.0.5

package/android/CMakeLists.txt

@@ -60,8 +60,6 @@ add_library(
 
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniPlatformContext.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidCanvasProvider.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/AHardwareBufferUtils.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkAndroidVideo.cpp"
 
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JSICache.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiPromises.cpp"

package/android/cpp/jni/JniPlatformContext.cpp

@@ -73,30 +73,6 @@ TSelf JniPlatformContext::initHybrid(jni::alias_ref<jhybridobject> jThis,
   return makeCxxInstance(jThis, pixelDensity);
 }
 
-jni::global_ref<jobject>
-JniPlatformContext::createVideo(const std::string &url) {
-  jni::Environment::ensureCurrentThreadIsAttached();
-
-  jni::ThreadScope ts; // Manages JNI thread attachment/detachment
-
-  // Get the JNI environment
-  JNIEnv *env = facebook::jni::Environment::current();
-
-  // Convert std::string to jstring
-  jstring jUrl = env->NewStringUTF(url.c_str());
-
-  static auto method =
-      javaPart_->getClass()->getMethod<jobject(jstring)>("createVideo");
-
-  // Call the method and receive a local reference to the video object
-  auto videoObject = method(javaPart_.get(), jUrl);
-  env->DeleteLocalRef(jUrl);
-
-  // Clean up the jstring local reference
-  auto result = jni::make_global(videoObject);
-  return result;
-}
-
 sk_sp<SkImage> JniPlatformContext::takeScreenshotFromViewTag(size_t tag) {
   // Call the java method for creating a view screenshot as a bitmap:
   auto env = jni::Environment::current();

package/android/cpp/jni/include/JniPlatformContext.h

@@ -44,8 +44,6 @@ public:
 
   sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag);
 
-  jni::global_ref<jobject> createVideo(const std::string &url);
-
 private:
   friend HybridBase;
   jni::global_ref<JniPlatformContext::javaobject> javaPart_;

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

@@ -1,10 +1,5 @@
 #pragma once
 
-#if __ANDROID_API__ >= 26
-#include <android/hardware_buffer.h>
-#endif
-#include <algorithm>
-#include <cstdint>
 #include <exception>
 #include <functional>
 #include <memory>
@@ -12,9 +7,7 @@
 
 #include "RNDawnContext.h"
 
-#include "AHardwareBufferUtils.h"
 #include "JniPlatformContext.h"
-#include "RNSkAndroidVideo.h"
 #include "RNSkPlatformContext.h"
 
 #pragma clang diagnostic push
@@ -54,139 +47,6 @@ public:
                                                     useP3ColorSpace);
   }
 
-  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
-    return DawnContext::getInstance().MakeImageFromBuffer(buffer);
-  }
-
-  std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {
-    auto jniVideo = _jniPlatformContext->createVideo(url);
-    return std::make_shared<RNSkAndroidVideo>(jniVideo);
-  }
-
-  void releaseNativeBuffer(uint64_t pointer) override {
-#if __ANDROID_API__ >= 26
-    auto *buffer = reinterpret_cast<AHardwareBuffer *>(pointer);
-    AHardwareBuffer_release(buffer);
-#endif
-  }
-
-  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
-#if __ANDROID_API__ >= 26
-    // A Graphite GPU texture can't be read with readPixels(nullptr); read it
-    // back to a raster image first or the buffer ends up uninitialized/black.
-    if (image && image->isTextureBacked()) {
-      image = DawnContext::getInstance().MakeRasterImage(image);
-    }
-    auto bytesPerPixel = image->imageInfo().bytesPerPixel();
-    int bytesPerRow = image->width() * bytesPerPixel;
-    auto buf = SkData::MakeUninitialized(image->width() * image->height() *
-                                         bytesPerPixel);
-    SkImageInfo info =
-        SkImageInfo::Make(image->width(), image->height(), image->colorType(),
-                          image->alphaType());
-    image->readPixels(nullptr, info, const_cast<void *>(buf->data()),
-                      bytesPerRow, 0, 0);
-    const void *pixelData = buf->data();
-
-    // Define the buffer description
-    AHardwareBuffer_Desc desc = {};
-    // TODO: use image info here
-    desc.width = image->width();
-    desc.height = image->height();
-    desc.layers = 1; // Single image layer
-    desc.format = GetBufferFormatFromSkColorType(
-        image->colorType()); // Assuming the image
-                             // is in this format
-    desc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-                 AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-                 AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT |
-                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-    desc.stride = bytesPerRow; // Stride in pixels, not in bytes
-
-    // Allocate the buffer
-    AHardwareBuffer *buffer = nullptr;
-    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
-      // Handle allocation failure
-      return 0;
-    }
-
-    // Map the buffer to gain access to its memory
-    void *mappedBuffer = nullptr;
-    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN, -1,
-                         nullptr, &mappedBuffer);
-    if (mappedBuffer == nullptr) {
-      // Handle mapping failure
-      AHardwareBuffer_release(buffer);
-      return 0;
-    }
-
-    // Copy the image data to the buffer
-    memcpy(mappedBuffer, pixelData, desc.height * bytesPerRow);
-
-    // Unmap the buffer
-    AHardwareBuffer_unlock(buffer, nullptr);
-
-    // Return the buffer pointer as a uint64_t. It's the caller's responsibility
-    // to manage this buffer.
-    return reinterpret_cast<uint64_t>(buffer);
-#else
-    return 0;
-#endif
-  }
-
-  uint64_t makeTestNativeBuffer(int width, int height) override {
-#if __ANDROID_API__ >= 26
-    // Allocate an RGBA8 AHardwareBuffer and fill it with a procedural test
-    // pattern (RGB gradient + diagonal stripes), entirely on the CPU. We read
-    // the buffer's actual row stride after locking (the allocator may pad it),
-    // so the upload is correct regardless of width alignment.
-    AHardwareBuffer_Desc desc = {};
-    desc.width = static_cast<uint32_t>(width);
-    desc.height = static_cast<uint32_t>(height);
-    desc.layers = 1;
-    desc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
-    desc.usage = AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY |
-                 AHARDWAREBUFFER_USAGE_CPU_READ_RARELY |
-                 AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-
-    AHardwareBuffer *buffer = nullptr;
-    if (AHardwareBuffer_allocate(&desc, &buffer) != 0) {
-      return 0;
-    }
-
-    AHardwareBuffer_Desc allocated = {};
-    AHardwareBuffer_describe(buffer, &allocated);
-    const size_t rowBytes = static_cast<size_t>(allocated.stride) * 4;
-
-    void *mappedBuffer = nullptr;
-    AHardwareBuffer_lock(buffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY, -1,
-                         nullptr, &mappedBuffer);
-    if (mappedBuffer == nullptr) {
-      AHardwareBuffer_release(buffer);
-      return 0;
-    }
-
-    auto *base = static_cast<uint8_t *>(mappedBuffer);
-    for (int y = 0; y < height; ++y) {
-      uint8_t *row = base + y * rowBytes;
-      for (int x = 0; x < width; ++x) {
-        uint8_t r = static_cast<uint8_t>((x * 255) / std::max(width - 1, 1));
-        uint8_t g = static_cast<uint8_t>((y * 255) / std::max(height - 1, 1));
-        uint8_t b = static_cast<uint8_t>(((x + y) & 0x20) ? 220 : 30);
-        row[x * 4 + 0] = r; // RGBA byte order
-        row[x * 4 + 1] = g;
-        row[x * 4 + 2] = b;
-        row[x * 4 + 3] = 0xFF;
-      }
-    }
-
-    AHardwareBuffer_unlock(buffer, nullptr);
-    return reinterpret_cast<uint64_t>(buffer);
-#else
-    return 0;
-#endif
-  }
-
   sk_sp<SkFontMgr> createFontMgr() override {
     return SkFontMgr_New_Android(nullptr, SkFontScanner_Make_FreeType());
   }

package/android/src/main/java/com/reactnative/skia/PlatformContext.java

@@ -32,11 +32,6 @@ public class PlatformContext {
         mHybridData = initHybrid(reactContext.getResources().getDisplayMetrics().density);
     }
 
-    @DoNotStrip
-    public Object createVideo(String url) {
-        return new RNSkVideo(mContext, url);
-    }
-
     private byte[] getStreamAsBytes(InputStream is) throws IOException {
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
         int nRead;

package/apple/RNSkApplePlatformContext.h

@@ -51,16 +51,6 @@ public:
 
   sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override;
 
-  sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override;
-
-  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
-
-  uint64_t makeTestNativeBuffer(int width, int height) override;
-
-  void releaseNativeBuffer(uint64_t pointer) override;
-
-  std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
-
   virtual void performStreamOperation(
       const std::string &sourceUri,
       const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override;

package/apple/RNSkApplePlatformContext.mm

@@ -1,25 +1,16 @@
 #import "RNSkApplePlatformContext.h"
 
-#import <CoreMedia/CMSampleBuffer.h>
 #import <React/RCTUtils.h>
-#include <algorithm>
 #include <set>
 #include <thread>
 #include <utility>
 
 #include "RNDawnContext.h"
-#include "RNSkAppleVideo.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include "include/core/SkBlendMode.h"
-#include "include/core/SkCanvas.h"
-#include "include/core/SkColor.h"
-#import "include/core/SkColorSpace.h"
 #include "include/core/SkFontMgr.h"
-#include "include/core/SkPaint.h"
-#include "include/core/SkSamplingOptions.h"
 #include "include/core/SkSurface.h"
 
 #include "include/ports/SkFontMgr_mac_ct.h"
@@ -70,174 +61,6 @@ void RNSkApplePlatformContext::performStreamOperation(
   std::thread(loader).detach();
 }
 
-void RNSkApplePlatformContext::releaseNativeBuffer(uint64_t pointer) {
-  CVPixelBufferRef pixelBuffer = reinterpret_cast<CVPixelBufferRef>(pointer);
-  if (pixelBuffer) {
-    CFRelease(pixelBuffer);
-  }
-}
-
-uint64_t RNSkApplePlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
-  // A Graphite GPU texture can't be read with readPixels(nullptr) (and can't be
-  // drawn onto a raster surface): both yield uninitialized/black pixels. Read
-  // it back to a raster image first.
-  if (image && image->isTextureBacked()) {
-    image = DawnContext::getInstance().MakeRasterImage(image);
-  }
-  // 0. If Image is not in BGRA, convert to BGRA as only BGRA is supported.
-  if (image->colorType() != kBGRA_8888_SkColorType) {
-    const SkImageInfo bgraInfo =
-        SkImageInfo::Make(image->dimensions(), kBGRA_8888_SkColorType,
-                          kPremul_SkAlphaType, SkColorSpace::MakeSRGB());
-    auto surface = SkSurfaces::Raster(bgraInfo);
-    if (!surface) {
-      throw std::runtime_error(
-          "Failed to allocate raster surface for BGRA conversion");
-    }
-    SkCanvas *canvas = surface->getCanvas();
-    canvas->clear(SK_ColorTRANSPARENT);
-    SkPaint paint;
-    paint.setBlendMode(SkBlendMode::kSrc);
-    canvas->drawImage(image.get(), 0.0f, 0.0f, SkSamplingOptions(), &paint);
-    auto bgraImage = surface->makeImageSnapshot();
-    if (bgraImage == nullptr) {
-      throw std::runtime_error(
-          "Failed to convert image to BGRA_8888 colortype! Only BGRA_8888 "
-          "NativeBuffers are supported.");
-    }
-    image = std::move(bgraImage);
-  }
-
-  // 1. Get image info
-  auto bytesPerPixel = image->imageInfo().bytesPerPixel();
-  int bytesPerRow = image->width() * bytesPerPixel;
-  auto buf = SkData::MakeUninitialized(image->width() * image->height() *
-                                       bytesPerPixel);
-  SkImageInfo info = SkImageInfo::Make(image->width(), image->height(),
-                                       image->colorType(), image->alphaType());
-  // 2. Copy pixels into our buffer
-  image->readPixels(nullptr, info, const_cast<void *>(buf->data()), bytesPerRow,
-                    0, 0);
-
-  // 3. Create an IOSurface (GPU + CPU memory)
-  CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
-      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
-      &kCFTypeDictionaryValueCallBacks);
-  int width = image->width();
-  int height = image->height();
-  int pitch = width * bytesPerPixel;
-  int size = width * height * bytesPerPixel;
-  OSType pixelFormat = kCVPixelFormatType_32BGRA;
-  CFDictionarySetValue(
-      dict, kIOSurfaceBytesPerRow,
-      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pitch));
-  CFDictionarySetValue(
-      dict, kIOSurfaceBytesPerElement,
-      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &bytesPerPixel));
-  CFDictionarySetValue(
-      dict, kIOSurfaceWidth,
-      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &width));
-  CFDictionarySetValue(
-      dict, kIOSurfaceHeight,
-      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &height));
-  CFDictionarySetValue(
-      dict, kIOSurfacePixelFormat,
-      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pixelFormat));
-  CFDictionarySetValue(
-      dict, kIOSurfaceAllocSize,
-      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &size));
-  IOSurfaceRef surface = IOSurfaceCreate(dict);
-  if (surface == nil) {
-    throw std::runtime_error("Failed to create " + std::to_string(width) + "x" +
-                             std::to_string(height) + " IOSurface!");
-  }
-
-  // 4. Copy over the memory from the pixels into the IOSurface
-  IOSurfaceLock(surface, 0, nil);
-  void *base = IOSurfaceGetBaseAddress(surface);
-  memcpy(base, buf->data(), buf->size());
-  IOSurfaceUnlock(surface, 0, nil);
-
-  // 5. Create a CVPixelBuffer from the IOSurface
-  CVPixelBufferRef pixelBuffer = nullptr;
-  CVReturn result =
-      CVPixelBufferCreateWithIOSurface(nil, surface, nil, &pixelBuffer);
-  if (result != kCVReturnSuccess) {
-    throw std::runtime_error(
-        "Failed to create CVPixelBuffer from SkImage! Return value: " +
-        std::to_string(result));
-  }
-
-  // 8. Return CVPixelBuffer casted to uint64_t
-  return reinterpret_cast<uint64_t>(pixelBuffer);
-}
-
-uint64_t RNSkApplePlatformContext::makeTestNativeBuffer(int width, int height) {
-  // Allocate a BGRA IOSurface and fill it with a procedural test pattern (RGB
-  // gradient + diagonal stripes), entirely on the CPU. No GPU / SkImage round
-  // trip, so this works the same on every backend.
-  const int bytesPerElement = 4;
-  const int pitch = width * bytesPerElement;
-  const int allocSize = width * height * bytesPerElement;
-  OSType pixelFormat = kCVPixelFormatType_32BGRA;
-  CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
-      kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
-      &kCFTypeDictionaryValueCallBacks);
-  auto setInt = [&](CFStringRef key, int value) {
-    CFNumberRef num =
-        CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
-    CFDictionarySetValue(dict, key, num);
-    CFRelease(num);
-  };
-  setInt(kIOSurfaceWidth, width);
-  setInt(kIOSurfaceHeight, height);
-  setInt(kIOSurfaceBytesPerRow, pitch);
-  setInt(kIOSurfaceBytesPerElement, bytesPerElement);
-  setInt(kIOSurfacePixelFormat, static_cast<int>(pixelFormat));
-  setInt(kIOSurfaceAllocSize, allocSize);
-  IOSurfaceRef surface = IOSurfaceCreate(dict);
-  CFRelease(dict);
-  if (surface == nil) {
-    throw std::runtime_error("Failed to create " + std::to_string(width) + "x" +
-                             std::to_string(height) + " test IOSurface!");
-  }
-
-  IOSurfaceLock(surface, 0, nil);
-  auto *base = static_cast<uint8_t *>(IOSurfaceGetBaseAddress(surface));
-  const size_t rowBytes = IOSurfaceGetBytesPerRow(surface);
-  for (int y = 0; y < height; ++y) {
-    uint8_t *row = base + y * rowBytes;
-    for (int x = 0; x < width; ++x) {
-      uint8_t r = static_cast<uint8_t>((x * 255) / std::max(width - 1, 1));
-      uint8_t g = static_cast<uint8_t>((y * 255) / std::max(height - 1, 1));
-      uint8_t b = static_cast<uint8_t>(((x + y) & 0x20) ? 220 : 30);
-      row[x * 4 + 0] = b; // BGRA byte order
-      row[x * 4 + 1] = g;
-      row[x * 4 + 2] = r;
-      row[x * 4 + 3] = 0xFF;
-    }
-  }
-  IOSurfaceUnlock(surface, 0, nil);
-
-  CVPixelBufferRef pixelBuffer = nullptr;
-  CVReturn result =
-      CVPixelBufferCreateWithIOSurface(nil, surface, nil, &pixelBuffer);
-  // The CVPixelBuffer retains the IOSurface; drop our reference so the
-  // CVPixelBuffer is its sole owner (freed by releaseNativeBuffer).
-  CFRelease(surface);
-  if (result != kCVReturnSuccess) {
-    throw std::runtime_error("Failed to create CVPixelBuffer for test native "
-                             "buffer! Return value: " +
-                             std::to_string(result));
-  }
-  return reinterpret_cast<uint64_t>(pixelBuffer);
-}
-
-std::shared_ptr<RNSkVideo>
-RNSkApplePlatformContext::createVideo(const std::string &url) {
-  return std::make_shared<RNSkAppleVideo>(url, this);
-}
-
 void RNSkApplePlatformContext::raiseError(const std::exception &err) {
   RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
 }
@@ -266,11 +89,6 @@ RNSkApplePlatformContext::makeOffscreenSurface(int width, int height,
                                                   useP3ColorSpace);
 }
 
-sk_sp<SkImage>
-RNSkApplePlatformContext::makeImageFromNativeBuffer(void *buffer) {
-  return DawnContext::getInstance().MakeImageFromBuffer(buffer);
-}
-
 sk_sp<SkFontMgr> RNSkApplePlatformContext::createFontMgr() {
   return SkFontMgr_New_CoreText(nullptr);
 }

package/cpp/api/JsiGPUTexture.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+#include <jsi/jsi.h>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+// Reads a GPUTexture argument: the react-native-webgpu object, whose
+// nativePointer (a non-spec extension) holds the WGPUTexture handle, or the
+// handle itself as a BigInt for libraries that export textures without
+// react-native-webgpu. The returned wgpu::Texture holds a reference of its
+// own, so the image or surface wrapping it keeps the texture alive while the
+// caller keeps ownership of the JS object.
+inline wgpu::Texture gpuTextureFromValue(jsi::Runtime &runtime,
+                                         const jsi::Value &value,
+                                         const char *method) {
+  uint64_t raw = 0;
+  if (value.isBigInt()) {
+    raw = value.asBigInt(runtime).asUint64(runtime);
+  } else if (value.isObject()) {
+    auto pointer =
+        value.asObject(runtime).getProperty(runtime, "nativePointer");
+    if (!pointer.isBigInt()) {
+      throw std::runtime_error(
+          std::string(method) +
+          " expects a GPUTexture created with react-native-webgpu on the "
+          "shared device (or a WGPUTexture pointer as a BigInt)");
+    }
+    raw = pointer.asBigInt(runtime).asUint64(runtime);
+  } else {
+    throw std::runtime_error(std::string(method) +
+                             " expects a GPUTexture or a WGPUTexture pointer");
+  }
+  auto texture = reinterpret_cast<WGPUTexture>(raw);
+  if (texture == nullptr) {
+    throw std::runtime_error(std::string(method) + ": the texture is null");
+  }
+  wgpuTextureAddRef(texture);
+  return wgpu::Texture::Acquire(texture);
+}
+
+} // namespace RNSkia

package/cpp/api/JsiSkApi.h

@@ -8,7 +8,6 @@
 
 #include "rnskia/RNDawnContext.h"
 
-#include "JsiNativeBuffer.h"
 #include "JsiSkAnimatedImage.h"
 #include "JsiSkAnimatedImageFactory.h"
 #include "JsiSkColor.h"
@@ -55,7 +54,6 @@
 #include "JsiSkTypefaceFontProviderFactory.h"
 #include "JsiSkVertices.h"
 #include "JsiSkottieFactory.h"
-#include "JsiVideo.h"
 #include "api/recorder/JsiRecorder.h"
 
 namespace RNSkia {
@@ -98,9 +96,7 @@ public:
         _typefaceFontProviderFactory(
             std::make_shared<JsiSkTypefaceFontProviderFactory>(context)),
         _paragraphBuilderFactory(
-            std::make_shared<JsiSkParagraphBuilderFactory>(context)),
-        _nativeBufferFactory(
-            std::make_shared<JsiNativeBufferFactory>(context)) {
+            std::make_shared<JsiSkParagraphBuilderFactory>(context)) {
     // We create the system font manager eagerly since it has proven to be too
     // slow to do it on demand
     JsiSkFontMgrFactory::getFontMgr(getContext());
@@ -109,10 +105,6 @@ public:
   // Constructor functions: each delegates to the class's createCtor host
   // function using the platform context resolved from native state, so the
   // prototype stays context-free and can be installed on any runtime.
-  JSI_HOST_FUNCTION(Video) {
-    return JsiVideo::createCtor(getContext())(runtime, thisValue, arguments,
-                                              count);
-  }
   JSI_HOST_FUNCTION(Font) {
     return JsiSkFont::createCtor(getContext())(runtime, thisValue, arguments,
                                                count);
@@ -234,12 +226,8 @@ public:
   std::shared_ptr<JsiSkParagraphBuilderFactory> getParagraphBuilderFactory() {
     return _paragraphBuilderFactory;
   }
-  std::shared_ptr<JsiNativeBufferFactory> getNativeBufferFactory() {
-    return _nativeBufferFactory;
-  }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "Video", &JsiSkApi::Video);
     installHostMethod(runtime, prototype, "getNativeDevice",
                       &JsiSkApi::getNativeDevice);
     installHostMethod(runtime, prototype, "Font", &JsiSkApi::Font);
@@ -292,8 +280,6 @@ public:
                   &JsiSkApi::getTypefaceFontProviderFactory);
     installGetter(runtime, prototype, "ParagraphBuilder",
                   &JsiSkApi::getParagraphBuilderFactory);
-    installGetter(runtime, prototype, "NativeBuffer",
-                  &JsiSkApi::getNativeBufferFactory);
   }
 
 private:
@@ -318,6 +304,5 @@ private:
   std::shared_ptr<JsiSkTypefaceFontProviderFactory>
       _typefaceFontProviderFactory;
   std::shared_ptr<JsiSkParagraphBuilderFactory> _paragraphBuilderFactory;
-  std::shared_ptr<JsiNativeBufferFactory> _nativeBufferFactory;
 };
 } // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -14,7 +14,6 @@
 #include "JsiSkShader.h"
 #include "api/third_party/base64.h"
 
-#include "JsiTextureInfo.h"
 #include "utils/RNSkTypedArray.h"
 
 #include "include/gpu/graphite/Context.h"
@@ -314,15 +313,6 @@ public:
     return std::make_shared<JsiSkImage>(getContext(), std::move(rasterImage));
   }
 
-  JSI_HOST_FUNCTION(getNativeTextureUnstable) {
-    auto image = getObject();
-    if (!image->isTextureBacked()) {
-      return jsi::Value::null();
-    }
-    auto texInfo = getContext()->getTexture(image);
-    return JsiTextureInfo::toValue(runtime, texInfo);
-  }
-
   bool isTextureBacked() { return getObject()->isTextureBacked(); }
 
   /**
@@ -351,8 +341,6 @@ public:
                       &JsiSkImage::readPixels);
     installMethod(runtime, prototype, "makeNonTextureImage",
                   &JsiSkImage::makeNonTextureImage);
-    installHostMethod(runtime, prototype, "getNativeTextureUnstable",
-                      &JsiSkImage::getNativeTextureUnstable);
     installMethod(runtime, prototype, "isTextureBacked",
                   &JsiSkImage::isTextureBacked);
   }