react-native-skia-webgpu-video 0.0.0-stage → 0.1.0-beta.1

package/ios/VideoFrame.h

@@ -0,0 +1,66 @@
+// Based on the MIT-licensed Skia Video implementation by François de Campredon.
+#pragma once
+
+#import <CoreVideo/CoreVideo.h>
+#import <jsi/jsi.h>
+#include <list>
+#include <memory>
+#include <mutex>
+
+namespace RNSkiaVideo {
+using namespace facebook;
+
+/**
+ * Scoped immutable decoder buffer. The pointer is a CVPixelBufferRef, never
+ * a Metal texture or IOSurfaceRef. Complete sampling (or make an owned image
+ * and wait for that copy) before dispose(). No age-based buffer retirement.
+ */
+class JSI_EXPORT VideoFrame : public jsi::HostObject,
+                             public std::enable_shared_from_this<VideoFrame> {
+public:
+  VideoFrame(CVPixelBufferRef buffer, double width, double height, int rotation,
+             uint64_t producerId, uint64_t transferredMemoryToken = 0);
+  ~VideoFrame() override;
+  void releaseBuffer();
+  bool hasBuffer() const;
+  size_t bufferBytes() const;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
+  jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
+
+private:
+#if defined(RNSV_NATIVE_TESTS)
+  friend class NativeFrameTestDriver;
+#endif
+  mutable std::mutex mutex;
+  CVPixelBufferRef pixelBuffer = NULL;
+  size_t bytes = 0;
+  uint64_t memoryToken = 0;
+  uint64_t frameId;
+  uint64_t producerId;
+  double width;
+  double height;
+  int rotation;
+};
+
+/**
+ * Compatibility name for the bounded outstanding-frame registry. Weak entries
+ * free their slot after disposal/collection. Full means backpressure; a live
+ * consumer buffer is never destroyed to admit another frame.
+ */
+class VideoFrameRing {
+public:
+  explicit VideoFrameRing(size_t capacity = 2) : capacity(capacity) {}
+  bool canAcquire();
+  void push(const std::shared_ptr<VideoFrame>& frame);
+  // Stop tracking; outstanding consumers retain their own immutable buffer.
+  void releaseAll();
+
+private:
+  std::mutex mutex;
+  size_t capacity;
+  std::list<std::weak_ptr<VideoFrame>> frames;
+  void removeReleased();
+};
+
+uint64_t allocateVideoProducerId();
+} // namespace RNSkiaVideo

package/ios/VideoFrame.mm

@@ -0,0 +1,108 @@
+// Based on the MIT-licensed Skia Video implementation by François de Campredon.
+#import "VideoFrame.h"
+#import "NativeResourceStats.h"
+#include "RNSVMemoryBudget.h"
+#include <atomic>
+#include <stdexcept>
+
+namespace RNSkiaVideo {
+static std::atomic<uint64_t> nextFrameId{1};
+static std::atomic<uint64_t> nextProducerId{1};
+uint64_t allocateVideoProducerId() { return nextProducerId.fetch_add(1); }
+
+VideoFrame::VideoFrame(CVPixelBufferRef buffer, double, double, int rotation,
+                       uint64_t producerId, uint64_t transferredMemoryToken)
+    : frameId(nextFrameId.fetch_add(1)), producerId(producerId),
+      width(CVPixelBufferGetWidth(buffer)), height(CVPixelBufferGetHeight(buffer)),
+      rotation(rotation) {
+  bytes = pixelBufferBytes(buffer);
+  memoryToken = transferredMemoryToken ? transferredMemoryToken :
+      MemoryBudget::instance().reserve(bytes, "iOS decoded frame");
+  pixelBuffer = CVPixelBufferRetain(buffer);
+  NativeResourceStats::frameBuffers.add(1);
+  NativeResourceStats::frameBytes.add(bytes);
+}
+VideoFrame::~VideoFrame() { releaseBuffer(); }
+void VideoFrame::releaseBuffer() {
+  std::lock_guard<std::mutex> guard(mutex);
+  if (pixelBuffer) {
+    CVPixelBufferRelease(pixelBuffer);
+    pixelBuffer = NULL;
+    NativeResourceStats::frameBuffers.remove(1);
+    NativeResourceStats::frameBytes.remove(bytes);
+    MemoryBudget::instance().release(memoryToken);
+    memoryToken = 0;
+  }
+}
+bool VideoFrame::hasBuffer() const {
+  std::lock_guard<std::mutex> guard(mutex);
+  return pixelBuffer != NULL;
+}
+size_t VideoFrame::bufferBytes() const { return bytes; }
+void VideoFrameRing::removeReleased() {
+  for (auto it = frames.begin(); it != frames.end();) {
+    auto frame = it->lock();
+    if (!frame || !frame->hasBuffer()) it = frames.erase(it);
+    else ++it;
+  }
+}
+bool VideoFrameRing::canAcquire() {
+  std::lock_guard<std::mutex> guard(mutex);
+  removeReleased();
+  return frames.size() < capacity;
+}
+void VideoFrameRing::push(const std::shared_ptr<VideoFrame>& frame) {
+  std::lock_guard<std::mutex> guard(mutex);
+  removeReleased();
+  if (frames.size() >= capacity) {
+    throw std::runtime_error("Native video frame capacity reached; dispose "
+                             "consumed frames after completing GPU work");
+  }
+  frames.push_back(frame);
+}
+void VideoFrameRing::releaseAll() {
+  std::lock_guard<std::mutex> guard(mutex);
+  // Removing the producer cannot revoke a consumer already sampling this
+  // buffer. Its explicit dispose()/final shared owner releases the lease.
+  frames.clear();
+}
+std::vector<jsi::PropNameID> VideoFrame::getPropertyNames(jsi::Runtime& rt) {
+  std::vector<jsi::PropNameID> result;
+  for (const auto* name : {"id", "producerId", "width", "height", "rotation",
+                           "texture", "nativeBuffer", "dispose"}) {
+    result.push_back(jsi::PropNameID::forAscii(rt, name));
+  }
+  return result;
+}
+jsi::Value VideoFrame::get(jsi::Runtime& runtime,
+                          const jsi::PropNameID& propNameId) {
+  auto name = propNameId.utf8(runtime);
+  if (name == "id") return jsi::Value(static_cast<double>(frameId));
+  if (name == "producerId") return jsi::Value(static_cast<double>(producerId));
+  if (name == "width") return jsi::Value(width);
+  if (name == "height") return jsi::Value(height);
+  if (name == "rotation") return jsi::Value(rotation);
+  if (name == "dispose") {
+    std::weak_ptr<VideoFrame> weak = shared_from_this();
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, "dispose"), 0,
+        [weak](jsi::Runtime&, const jsi::Value&, const jsi::Value*, size_t) {
+          if (auto frame = weak.lock()) frame->releaseBuffer();
+          return jsi::Value::undefined();
+        });
+  }
+  if (name == "texture" || name == "nativeBuffer") {
+    std::lock_guard<std::mutex> guard(mutex);
+    if (!pixelBuffer) return jsi::Value::undefined();
+    auto pointer = jsi::BigInt::fromUint64(
+        runtime, reinterpret_cast<uintptr_t>(pixelBuffer));
+    if (name == "nativeBuffer") return pointer;
+    auto descriptor = jsi::Object(runtime);
+    descriptor.setProperty(runtime, "kind",
+                           jsi::String::createFromAscii(runtime, "native-buffer"));
+    descriptor.setProperty(runtime, "nativeBuffer", pointer);
+    return descriptor;
+  }
+  return jsi::Value::undefined();
+}
+} // namespace RNSkiaVideo

package/ios/VideoPlayerHostObject.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "RNSVEventEmitter.h"
+#include "RNSVHostObject.h"
+#include "RNSVVideoPlayer.h"
+#include "VideoFrame.h"
+
+using namespace facebook;
+namespace RNSkiaVideo { class VideoPlayerHostObject; }
+
+@interface RNSVSkiaVideoPlayerDelegateImpl : NSObject <RNSVVideoPlayerDelegate>
+
+- (instancetype)initWithHost:
+    (std::weak_ptr<RNSkiaVideo::VideoPlayerHostObject>)host;
+- (void)dispose;
+
+@end
+
+namespace RNSkiaVideo {
+
+class JSI_EXPORT VideoPlayerHostObject : public RNSVHostObject, public EventEmitter {
+public:
+  VideoPlayerHostObject(jsi::Runtime& runtime,
+                        std::shared_ptr<react::CallInvoker> callInvoker,
+                        NSURL* url, CGSize resolution, bool directTexture);
+  ~VideoPlayerHostObject();
+  void initialize(NSURL* url, CGSize resolution);
+  jsi::Value get(jsi::Runtime&, const jsi::PropNameID& name) override;
+  void set(jsi::Runtime&, const jsi::PropNameID& name,
+           const jsi::Value& value) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& rt) override;
+
+  void readyToPlay(float width, float height, int rotation);
+  void frameAvailableEventHandler(CMTime time);
+
+private:
+  NSObject* lock;
+  RNSVVideoPlayer* player;
+  RNSVSkiaVideoPlayerDelegateImpl* playerDelegate;
+  std::shared_ptr<VideoFrame> currentFrame;
+  VideoFrameRing frameRing;
+  uint64_t producerId = allocateVideoProducerId();
+  std::shared_ptr<VideoFrame> makeFrame(CVPixelBufferRef buffer);
+  CMTime lastFrameAvailable = kCMTimeInvalid;
+  CMTime lastFrameDrawn = kCMTimeInvalid;
+  float width = 0;
+  float height = 0;
+  int rotation = 0;
+  std::atomic_flag released = ATOMIC_FLAG_INIT;
+  void release();
+};
+} // namespace RNSkiaVideo

package/ios/VideoPlayerHostObject.mm

@@ -0,0 +1,332 @@
+//
+//  VideoPlayerHostObject.m
+//  azzapp-react-native-skia-video
+//
+//  Created by François de Campredon on 03/05/2024.
+//
+
+#import "VideoPlayerHostObject.h"
+#import "RNSVJSIUtils.h"
+#import "RNSVScopedPixelBuffer.h"
+#include "RNSVCheckedSizes.h"
+
+namespace RNSkiaVideo {
+using namespace facebook;
+
+VideoPlayerHostObject::VideoPlayerHostObject(
+    jsi::Runtime& runtime, std::shared_ptr<react::CallInvoker> callInvoker,
+    NSURL* url, CGSize resolution, bool directTexture)
+    : EventEmitter(runtime, callInvoker) {
+  lock = [[NSObject alloc] init];
+  (void)directTexture;
+  (void)url;
+  (void)resolution;
+}
+
+void VideoPlayerHostObject::initialize(NSURL* url, CGSize resolution) {
+  playerDelegate = [[RNSVSkiaVideoPlayerDelegateImpl alloc]
+      initWithHost:std::weak_ptr<VideoPlayerHostObject>(
+          std::static_pointer_cast<VideoPlayerHostObject>(shared_from_this()))];
+  player = [[RNSVVideoPlayer alloc] initWithURL:url
+                                       delegate:playerDelegate
+                                     resolution:resolution];
+}
+
+VideoPlayerHostObject::~VideoPlayerHostObject() {
+  release();
+}
+
+std::vector<jsi::PropNameID>
+VideoPlayerHostObject::getPropertyNames(jsi::Runtime& rt) {
+  std::vector<jsi::PropNameID> result;
+  result.push_back(
+      jsi::PropNameID::forUtf8(rt, std::string("decodeNextFrame")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("play")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("pause")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("seekTo")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("currentTime")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("duration")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("volume")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("playbackSpeed")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("isLooping")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("isPlaying")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("dispose")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("on")));
+  return result;
+}
+
+// The methods are created once per runtime (see RNSVHostObject):
+// `decodeNextFrame` is read by useVideoPlayer at every vsync of the UI
+// runtime, and a fresh host function on each read is two garbage collected
+// allocations per frame for nothing.
+jsi::Value VideoPlayerHostObject::get(jsi::Runtime& runtime,
+                                      const jsi::PropNameID& propNameId) {
+  @synchronized(lock) {
+  auto propName = propNameId.utf8(runtime);
+  if (propName == "decodeNextFrame") {
+    return getFunction(
+        runtime, propName, 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          @synchronized(lock) {
+          if (released.test() || !CMTIME_IS_VALID(lastFrameAvailable) ||
+              CMTimeCompare(lastFrameDrawn, lastFrameAvailable) == 0) {
+            return jsi::Value::null();
+          }
+          if (!frameRing.canAcquire()) return jsi::Value::null();
+          ScopedPixelBuffer buffer([player copyPixelBufferForTime:lastFrameAvailable]);
+          if (!buffer.get()) {
+            return jsi::Value::null();
+          }
+          currentFrame = makeFrame(buffer.get());
+          lastFrameDrawn = lastFrameAvailable;
+          return jsi::Object::createFromHostObject(runtime, currentFrame);
+          }
+        });
+  } else if (propName == "play") {
+    return getFunction(
+        runtime, propName, 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          @synchronized(lock) { if (!released.test()) {
+            [player play];
+          } }
+          return jsi::Value::undefined();
+        });
+  } else if (propName == "pause") {
+    return getFunction(
+        runtime, propName, 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          @synchronized(lock) { if (!released.test()) {
+            [player pause];
+          } }
+          return jsi::Value::undefined();
+        });
+  } else if (propName == "seekTo") {
+    return getFunction(
+        runtime, propName, 1,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          if (count < 1 || !arguments[0].isNumber())
+            throw jsi::JSError(runtime, "seekTo expects media seconds");
+          auto time = checkedMediaSeconds(arguments[0].asNumber());
+          @synchronized(lock) { if (!released.test()) {
+            std::weak_ptr<VideoPlayerHostObject> weak =
+                std::static_pointer_cast<VideoPlayerHostObject>(shared_from_this());
+            [player seekTo:CMTimeMakeWithSeconds(time, 600)
+                completionHandler:^(BOOL) {
+                  if (auto owner = weak.lock()) {
+                    if (!owner->released.test()) {
+                      owner->emit("seekComplete", jsi::Value::null());
+                    }
+                  }
+                }];
+          } }
+          return jsi::Value::undefined();
+        });
+  } else if (propName == "on") {
+    return getFunction(
+        runtime, propName, 2,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          if (released.test()) {
+            // Nothing to listen to anymore: hand out a no-op unsubscribe.
+            return jsi::Function::createFromHostFunction(
+                runtime, jsi::PropNameID::forAscii(runtime, "dispose"), 0,
+                [](jsi::Runtime& runtime, const jsi::Value& thisValue,
+                   const jsi::Value* arguments, size_t count) -> jsi::Value {
+                  return jsi::Value::undefined();
+                });
+          }
+          if (count < 2 || !arguments[0].isString() || !arguments[1].isObject() ||
+              !arguments[1].asObject(runtime).isFunction(runtime))
+            throw jsi::JSError(runtime, "on expects an event name and listener");
+          auto name = arguments[0].asString(runtime).utf8(runtime);
+          auto handler = arguments[1].asObject(runtime).asFunction(runtime);
+          return this->on(name, std::move(handler));
+        });
+  } else if (propName == "dispose") {
+    return getFunction(
+        runtime, propName, 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          this->release();
+          return jsi::Value::undefined();
+        });
+  } else if (propName == "currentTime") {
+    if (released.test()) {
+      return jsi::Value(0);
+    }
+    double seconds = CMTimeGetSeconds(player.currentTime);
+    return jsi::Value(isnan(seconds) ? -1 : seconds);
+  } else if (propName == "duration") {
+    if (released.test()) {
+      return jsi::Value(0);
+    }
+    double seconds = CMTimeGetSeconds(player.duration);
+    return jsi::Value(isnan(seconds) ? -1 : seconds);
+  } else if (propName == "volume") {
+    if (released.test()) {
+      return jsi::Value(0);
+    }
+    float volume = player.volume;
+    return jsi::Value(volume);
+  } else if (propName == "playbackSpeed") {
+    if (released.test()) {
+      return jsi::Value(1);
+    }
+    float playbackSpeed = player.playbackSpeed;
+    return jsi::Value(playbackSpeed);
+  } else if (propName == "isLooping") {
+    if (released.test()) {
+      return jsi::Value(false);
+    }
+    return jsi::Value(player.isLooping);
+  } else if (propName == "isPlaying") {
+    if (released.test()) {
+      return jsi::Value(false);
+    }
+    return jsi::Value(player.isPlaying);
+  }
+
+  return jsi::Value::undefined();
+  }
+}
+
+void VideoPlayerHostObject::set(jsi::Runtime& runtime,
+                                const jsi::PropNameID& propNameId,
+                                const jsi::Value& value) {
+  @synchronized(lock) {
+  if (released.test()) {
+    return;
+  }
+  auto propName = propNameId.utf8(runtime);
+  if (propName == "volume") {
+    player.volume = value.asNumber();
+  } else if (propName == "playbackSpeed") {
+    player.playbackSpeed = value.asNumber();
+  } else if (propName == "isLooping") {
+    player.isLooping = value.asBool();
+  }
+  }
+}
+
+void VideoPlayerHostObject::frameAvailableEventHandler(CMTime time) {
+  if (released.test()) return;
+  @synchronized(lock) { if (!released.test()) lastFrameAvailable = time; }
+}
+
+void VideoPlayerHostObject::readyToPlay(float width, float height,
+                                        int rotation) {
+  if (released.test()) return;
+  @synchronized(lock) {
+  if (released.test()) return;
+  this->width = width;
+  this->height = height;
+  this->rotation = rotation;
+  }
+}
+
+std::shared_ptr<VideoFrame>
+VideoPlayerHostObject::makeFrame(CVPixelBufferRef buffer) {
+  auto frame = std::make_shared<VideoFrame>(buffer, width, height, rotation,
+                                           producerId);
+  frameRing.push(frame);
+  return frame;
+}
+
+void VideoPlayerHostObject::release() {
+  if (!released.test_and_set()) {
+    removeAllListeners();
+    RNSVVideoPlayer* disposingPlayer;
+    RNSVSkiaVideoPlayerDelegateImpl* disposingDelegate;
+    @synchronized(lock) {
+    frameRing.releaseAll();
+    if (currentFrame) {
+      currentFrame = nullptr;
+    }
+    disposingDelegate = playerDelegate;
+    disposingPlayer = player;
+    playerDelegate = nil;
+    player = nil;
+    }
+    [disposingDelegate dispose];
+    [disposingPlayer dispose];
+  }
+}
+
+} // namespace RNSkiaVideo
+
+using namespace facebook;
+
+@implementation RNSVSkiaVideoPlayerDelegateImpl {
+  std::weak_ptr<RNSkiaVideo::VideoPlayerHostObject> _host;
+}
+- (instancetype)initWithHost:
+    (std::weak_ptr<RNSkiaVideo::VideoPlayerHostObject>)host {
+  self = [super init];
+  if (self) _host = std::move(host);
+  return self;
+}
+- (void)readyToPlay:(NSDictionary*)assetInfos {
+  auto host = _host.lock();
+  if (!host) return;
+  float width = [(NSNumber*)assetInfos[@"width"] floatValue];
+  float height = [(NSNumber*)assetInfos[@"height"] floatValue];
+  int rotation = [(NSNumber*)assetInfos[@"rotation"] intValue];
+  host->readyToPlay(width, height, rotation);
+  host->emit("ready", [=](jsi::Runtime& runtime) -> jsi::Value {
+    auto result = jsi::Object(runtime);
+    result.setProperty(runtime, "width", width);
+    result.setProperty(runtime, "height", height);
+    result.setProperty(runtime, "rotation", rotation);
+    return result;
+  });
+}
+- (void)frameAvailable:(CMTime)time {
+  if (auto host = _host.lock()) host->frameAvailableEventHandler(time);
+}
+- (void)bufferingStart {
+  if (auto host = _host.lock()) host->emit("bufferingStart");
+}
+- (void)bufferingEnd {
+  if (auto host = _host.lock()) host->emit("bufferingEnd");
+}
+- (void)bufferingUpdate:(NSArray<NSValue*>*)loadedTimeRanges {
+  if (auto host = _host.lock()) {
+    host->emit("bufferingUpdate", [=](jsi::Runtime& runtime) -> jsi::Value {
+      auto ranges = jsi::Array(runtime, loadedTimeRanges.count);
+      for (size_t i = 0; i < loadedTimeRanges.count; ++i) {
+        auto range = loadedTimeRanges[i].CMTimeRangeValue;
+        auto result = jsi::Object(runtime);
+        result.setProperty(runtime, "start", CMTimeGetSeconds(range.start));
+        result.setProperty(runtime, "duration", CMTimeGetSeconds(range.duration));
+        ranges.setValueAtIndex(runtime, i, result);
+      }
+      return ranges;
+    });
+  }
+}
+- (void)videoError:(nullable NSError*)error {
+  if (auto host = _host.lock()) {
+    host->emit("error", [=](jsi::Runtime& runtime) -> jsi::Value {
+      return RNSkiaVideo::NSErrorToJSI(runtime, error);
+    });
+  }
+}
+- (void)complete {
+  if (auto host = _host.lock()) host->emit("complete");
+}
+- (void)isPlaying:(BOOL)playing {
+  if (auto host = _host.lock()) {
+    host->emit("playingStatusChange", [playing](jsi::Runtime&) {
+      return jsi::Value(playing ? true : false);
+    });
+  }
+}
+- (void)dispose {
+  // The weak reference deliberately remains unchanged: callbacks racing with
+  // host destruction either hold a valid owner or fail to lock it.
+}
+@end

package/lib/module/NativeReactNativeSkiaVideo.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('ReactNativeSkiaVideo');
+//# sourceMappingURL=NativeReactNativeSkiaVideo.js.map

package/lib/module/NativeReactNativeSkiaVideo.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","get"],"sourceRoot":"../../src","sources":["NativeReactNativeSkiaVideo.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAMlD,eAAeA,mBAAmB,CAACC,GAAG,CAAO,sBAAsB,CAAC","ignoreList":[]}

package/lib/module/RNSkiaVideoModule.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { Platform } from "react-native";
+import NativeReactNativeSkiaVideo from "./NativeReactNativeSkiaVideo.js";
+if (!NativeReactNativeSkiaVideo) {
+  throw new Error(`The package 'react-native-skia-webgpu-video' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
+    ios: "- You have run 'pod install'\n",
+    default: ""
+  }) + "- You rebuilt the app after installing the package\n" + "- You are not using Expo Go\n");
+}
+const installed = NativeReactNativeSkiaVideo.install();
+if (!installed || global.RNSkiaVideo == null) {
+  throw new Error("The package 'react-native-skia-webgpu-video' failed to install its JSI bindings.");
+}
+const module = global.RNSkiaVideo;
+if (module.frameProtocolVersion !== 1) {
+  throw new Error("Skia 3 video native bindings are outdated. Rebuild the native app and remove the legacy Skia Video package.");
+}
+export default module;
+//# sourceMappingURL=RNSkiaVideoModule.js.map

package/lib/module/RNSkiaVideoModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","NativeReactNativeSkiaVideo","Error","select","ios","default","installed","install","global","RNSkiaVideo","module","frameProtocolVersion"],"sourceRoot":"../../src","sources":["RNSkiaVideoModule.ts"],"mappings":";;AAAA,SAASA,QAAQ,QAAQ,cAAc;AAEvC,OAAOC,0BAA0B,MAAM,iCAA8B;AAErE,IAAI,CAACA,0BAA0B,EAAE;EAC/B,MAAM,IAAIC,KAAK,CACb,yFAAyF,GACvFF,QAAQ,CAACG,MAAM,CAAC;IAAEC,GAAG,EAAE,gCAAgC;IAAEC,OAAO,EAAE;EAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BACJ,CAAC;AACH;AAEA,MAAMC,SAAS,GAAGL,0BAA0B,CAACM,OAAO,CAAC,CAAC;AACtD,IAAI,CAACD,SAAS,IAAKE,MAAM,CAASC,WAAW,IAAI,IAAI,EAAE;EACrD,MAAM,IAAIP,KAAK,CACb,kFACF,CAAC;AACH;AAEA,MAAMQ,MAAM,GAAIF,MAAM,CAASC,WAAgC;AAC/D,IAAIC,MAAM,CAACC,oBAAoB,KAAK,CAAC,EAAE;EACrC,MAAM,IAAIT,KAAK,CACb,6GACF,CAAC;AACH;AACA,eAAeQ,MAAM","ignoreList":[]}

package/lib/module/canvas.js

@@ -0,0 +1,18 @@
+"use strict";
+
+/** Fail early when JS was patched but the installed native binary was not rebuilt. */
+export const getVideoCanvas = surface => {
+  "worklet";
+
+  const checked = surface;
+  if (typeof checked.enableCheckedSubmissions !== "function") {
+    throw new Error("Skia checked submission patch is missing from the native binary. Apply the patch and rebuild the native app.");
+  }
+  checked.enableCheckedSubmissions();
+  const canvas = surface.getCanvas();
+  if (typeof canvas.dispose !== "function") {
+    throw new Error("Skia canvas lifecycle patch is missing from the native binary. Apply the patch and rebuild the native app.");
+  }
+  return canvas;
+};
+//# sourceMappingURL=canvas.js.map

package/lib/module/canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getVideoCanvas","surface","checked","enableCheckedSubmissions","Error","canvas","getCanvas","dispose"],"sourceRoot":"../../src","sources":["canvas.ts"],"mappings":";;AAEA;AACA,OAAO,MAAMA,cAAc,GAAIC,OAAkB,IAAe;EAC9D,SAAS;;EACT,MAAMC,OAAO,GAAGD,OAEf;EACD,IAAI,OAAOC,OAAO,CAACC,wBAAwB,KAAK,UAAU,EAAE;IAC1D,MAAM,IAAIC,KAAK,CACb,8GACF,CAAC;EACH;EACAF,OAAO,CAACC,wBAAwB,CAAC,CAAC;EAClC,MAAME,MAAM,GAAGJ,OAAO,CAACK,SAAS,CAAC,CAAC;EAClC,IAAI,OAAOD,MAAM,CAACE,OAAO,KAAK,UAAU,EAAE;IACxC,MAAM,IAAIH,KAAK,CACb,4GACF,CAAC;EACH;EACA,OAAOC,MAAM;AACf,CAAC","ignoreList":[]}

package/lib/module/exportCache.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { Skia } from "react-native-skia";
+
+/** Private contract, used only on this library's dedicated export runtime. */
+export const assertExportRecorderCacheSupport = () => {
+  "worklet";
+
+  if (typeof Skia.__rnskvTrimRecorderCache !== "function") {
+    throw new Error("Skia export cache patch is missing from the native binary. Apply the patch and rebuild the native app.");
+  }
+};
+
+/** Close all export consumers first. Never call this from preview/UI cleanup:
+ * that recorder can also cache resources for unrelated application views. */
+export const trimExportRecorderCache = () => {
+  "worklet";
+
+  assertExportRecorderCacheSupport();
+  Skia.__rnskvTrimRecorderCache();
+};
+//# sourceMappingURL=exportCache.js.map

package/lib/module/exportCache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Skia","assertExportRecorderCacheSupport","__rnskvTrimRecorderCache","Error","trimExportRecorderCache"],"sourceRoot":"../../src","sources":["exportCache.ts"],"mappings":";;AAAA,SAASA,IAAI,QAAQ,mBAAmB;;AAExC;AACA,OAAO,MAAMC,gCAAgC,GAAGA,CAAA,KAAM;EACpD,SAAS;;EACT,IACE,OACED,IAAI,CAGJE,wBAAwB,KAAK,UAAU,EACzC;IACA,MAAM,IAAIC,KAAK,CACb,wGACF,CAAC;EACH;AACF,CAAC;;AAED;AACA;AACA,OAAO,MAAMC,uBAAuB,GAAGA,CAAA,KAAM;EAC3C,SAAS;;EACTH,gCAAgC,CAAC,CAAC;EAEhCD,IAAI,CACJE,wBAAwB,CAAC,CAAC;AAC9B,CAAC","ignoreList":[]}