react-native-skia 3.0.3 → 3.0.5

package/android/src/test/java/com/reactnative/skia/FrameSchedulerTest.java

@@ -0,0 +1,186 @@
+package com.reactnative.skia;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+
+import org.junit.Test;
+
+public class FrameSchedulerTest {
+    private enum Call {
+        POST_FRAME_CALLBACK,
+        POST_BEHIND_PENDING_DRAW,
+        PRESENT
+    }
+
+    private static final class RecordingHost implements FrameScheduler.Host {
+        final List<Call> calls = new ArrayList<>();
+        final Deque<Boolean> leftOverAfterPresent = new ArrayDeque<>();
+
+        @Override
+        public void postFrameCallback() {
+            calls.add(Call.POST_FRAME_CALLBACK);
+        }
+
+        @Override
+        public void postBehindPendingDraw() {
+            calls.add(Call.POST_BEHIND_PENDING_DRAW);
+        }
+
+        @Override
+        public boolean presentFrame() {
+            calls.add(Call.PRESENT);
+            return !leftOverAfterPresent.isEmpty() && leftOverAfterPresent.removeFirst();
+        }
+
+        List<Call> takeCalls() {
+            List<Call> taken = new ArrayList<>(calls);
+            calls.clear();
+            return taken;
+        }
+    }
+
+    private final RecordingHost mHost = new RecordingHost();
+    private final FrameScheduler mScheduler = new FrameScheduler(mHost);
+
+    @Test
+    public void surfaceViewFrameIsPresentedOnTheNextVsync() {
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        assertEquals(Arrays.asList(Call.POST_FRAME_CALLBACK), mHost.takeCalls());
+
+        mScheduler.onFrame(BackingViewKind.SURFACE_VIEW);
+        assertEquals(Arrays.asList(Call.PRESENT), mHost.takeCalls());
+    }
+
+    @Test
+    public void textureViewFrameIsPresentedBehindThePendingDraw() {
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        assertEquals(Arrays.asList(Call.POST_BEHIND_PENDING_DRAW), mHost.takeCalls());
+
+        mScheduler.onPosted();
+        assertEquals(Arrays.asList(Call.PRESENT), mHost.takeCalls());
+    }
+
+    @Test
+    public void textureViewIsNeverPresentedInsideAChoreographerFrame() {
+        mScheduler.onFrame(BackingViewKind.TEXTURE_VIEW);
+        assertEquals(Arrays.asList(Call.POST_BEHIND_PENDING_DRAW), mHost.takeCalls());
+    }
+
+    @Test
+    public void textureViewLeftoverIsPresentedBehindTheDrawOfTheNextVsync() {
+        mHost.leftOverAfterPresent.add(true);
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onPosted();
+        assertEquals(
+                Arrays.asList(Call.POST_BEHIND_PENDING_DRAW, Call.PRESENT, Call.POST_FRAME_CALLBACK),
+                mHost.takeCalls());
+
+        mScheduler.onFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onPosted();
+        assertEquals(Arrays.asList(Call.POST_BEHIND_PENDING_DRAW, Call.PRESENT), mHost.takeCalls());
+    }
+
+    @Test
+    public void textureViewRequestWhileARetryIsOutstandingWaitsForThatVsync() {
+        mHost.leftOverAfterPresent.add(true);
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onPosted();
+        assertEquals(
+                Arrays.asList(Call.POST_BEHIND_PENDING_DRAW, Call.PRESENT, Call.POST_FRAME_CALLBACK),
+                mHost.takeCalls());
+
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        assertEquals(Arrays.asList(), mHost.takeCalls());
+
+        mScheduler.onFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onPosted();
+        assertEquals(Arrays.asList(Call.POST_BEHIND_PENDING_DRAW, Call.PRESENT), mHost.takeCalls());
+    }
+
+    @Test
+    public void surfaceViewLeftoverIsPresentedOnTheNextVsync() {
+        mHost.leftOverAfterPresent.add(true);
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.onFrame(BackingViewKind.SURFACE_VIEW);
+        assertEquals(
+                Arrays.asList(Call.POST_FRAME_CALLBACK, Call.PRESENT, Call.POST_FRAME_CALLBACK),
+                mHost.takeCalls());
+
+        mScheduler.onFrame(BackingViewKind.SURFACE_VIEW);
+        assertEquals(Arrays.asList(Call.PRESENT), mHost.takeCalls());
+    }
+
+    @Test
+    public void requestsWaitingForTheSameFrameArePostedOnce() {
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.onFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        assertEquals(
+                Arrays.asList(Call.POST_FRAME_CALLBACK, Call.PRESENT, Call.POST_BEHIND_PENDING_DRAW),
+                mHost.takeCalls());
+    }
+
+    @Test
+    public void requestAfterTheFrameRanIsPostedAgain() {
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.onFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.onFrame(BackingViewKind.SURFACE_VIEW);
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onPosted();
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        assertEquals(
+                Arrays.asList(
+                        Call.POST_FRAME_CALLBACK,
+                        Call.PRESENT,
+                        Call.POST_FRAME_CALLBACK,
+                        Call.PRESENT,
+                        Call.POST_BEHIND_PENDING_DRAW,
+                        Call.PRESENT,
+                        Call.POST_BEHIND_PENDING_DRAW),
+                mHost.takeCalls());
+    }
+
+    @Test
+    public void kindSwitchWhileAFrameCallbackIsOutstandingPresentsBehindThePendingDraw() {
+        mScheduler.requestFrame(BackingViewKind.SURFACE_VIEW);
+        // updateView() replaced the SurfaceView with a TextureView meanwhile.
+        mScheduler.requestFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onFrame(BackingViewKind.TEXTURE_VIEW);
+        mScheduler.onPosted();
+        assertEquals(
+                Arrays.asList(Call.POST_FRAME_CALLBACK, Call.POST_BEHIND_PENDING_DRAW, Call.PRESENT),
+                mHost.takeCalls());
+    }
+
+    @Test
+    public void withoutABackingViewNothingIsPostedOrPresented() {
+        mScheduler.requestFrame(null);
+        mScheduler.onFrame(null);
+        assertEquals(Arrays.asList(), mHost.takeCalls());
+    }
+
+    @Test
+    public void cancelDropsOutstandingRequests() {
+        for (BackingViewKind kind : BackingViewKind.values()) {
+            mScheduler.requestFrame(kind);
+            mScheduler.cancel();
+            mScheduler.requestFrame(kind);
+            mScheduler.cancel();
+        }
+        assertEquals(
+                Arrays.asList(
+                        Call.POST_FRAME_CALLBACK,
+                        Call.POST_FRAME_CALLBACK,
+                        Call.POST_BEHIND_PENDING_DRAW,
+                        Call.POST_BEHIND_PENDING_DRAW),
+                mHost.takeCalls());
+    }
+}

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