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

package/ios/NativeResourceStats.h

@@ -0,0 +1,32 @@
+#pragma once
+#import <CoreVideo/CoreVideo.h>
+#include <atomic>
+#include <cstdint>
+namespace RNSkiaVideo {
+struct ResourceCounter {
+  std::atomic<uint64_t> current{0};
+  std::atomic<uint64_t> peak{0};
+  void add(uint64_t amount) {
+    uint64_t value = current.fetch_add(amount) + amount;
+    uint64_t previous = peak.load();
+    while (value > previous && !peak.compare_exchange_weak(previous, value)) {}
+  }
+  void remove(uint64_t amount) { current.fetch_sub(amount); }
+};
+struct NativeResourceStats {
+  inline static ResourceCounter frameBuffers;
+  inline static ResourceCounter frameBytes;
+  inline static ResourceCounter decoderBuffers;
+  inline static ResourceCounter decoderBytes;
+  inline static ResourceCounter decoders;
+  inline static ResourceCounter encoders;
+  // Codec-owned references after append require process/Instruments measures.
+  inline static ResourceCounter encoderSubmittingBuffers;
+  inline static ResourceCounter encoderSubmittingBytes;
+};
+inline size_t pixelBufferBytes(CVPixelBufferRef buffer) {
+  size_t bytes = CVPixelBufferGetDataSize(buffer);
+  return bytes ? bytes : CVPixelBufferGetBytesPerRow(buffer) *
+                             CVPixelBufferGetHeight(buffer);
+}
+} // namespace RNSkiaVideo

package/ios/RNSVColorSpace.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <CoreVideo/CoreVideo.h>
+
+namespace RNSkiaVideo {
+
+/**
+ * Rec.709 — the one color space this library decodes into, draws in and
+ * encodes out.
+ *
+ * Skia is handed plain BGRA textures and does no color management, so every
+ * frame has to reach it already in the space the canvas assumes. Since the
+ * iPhone 12 the camera records HLG HDR by default, and an HLG buffer decoded
+ * as-is into BGRA and drawn as sRGB comes out washed out, with crushed
+ * contrast. Asking AVFoundation for these properties makes it tone-map to
+ * SDR on the way out, on its own fast path.
+ *
+ * Applied unconditionally rather than only to HDR sources: a source already
+ * in Rec.709 costs nothing, and a BT.601 one gets the conversion it always
+ * needed. It also spares the decoders an inspection of the track's transfer
+ * function before its format descriptions are even loaded.
+ */
+static inline NSDictionary* SDRColorProperties() {
+  return @{
+    AVVideoColorPrimariesKey : AVVideoColorPrimaries_ITU_R_709_2,
+    AVVideoTransferFunctionKey : AVVideoTransferFunction_ITU_R_709_2,
+    AVVideoYCbCrMatrixKey : AVVideoYCbCrMatrix_ITU_R_709_2,
+  };
+}
+
+/**
+ * Stamps Rec.709 onto a buffer handed to AVAssetWriter. The writer's own
+ * output settings already declare it, but a buffer carrying no color
+ * attachment at all leaves some muxers to guess, and a file with no
+ * colorimetry is read differently by every player.
+ */
+static inline void TagBufferAsSDR(CVPixelBufferRef buffer) {
+  CVBufferSetAttachment(buffer, kCVImageBufferColorPrimariesKey,
+                        kCVImageBufferColorPrimaries_ITU_R_709_2,
+                        kCVAttachmentMode_ShouldPropagate);
+  CVBufferSetAttachment(buffer, kCVImageBufferTransferFunctionKey,
+                        kCVImageBufferTransferFunction_ITU_R_709_2,
+                        kCVAttachmentMode_ShouldPropagate);
+  CVBufferSetAttachment(buffer, kCVImageBufferYCbCrMatrixKey,
+                        kCVImageBufferYCbCrMatrix_ITU_R_709_2,
+                        kCVAttachmentMode_ShouldPropagate);
+}
+
+} // namespace RNSkiaVideo

package/ios/RNSVJSIUtils.h

@@ -0,0 +1,46 @@
+#pragma once
+#import <Foundation/Foundation.h>
+#import <jsi/jsi.h>
+#include <stdexcept>
+#include <type_traits>
+
+namespace RNSkiaVideo {
+
+using namespace facebook;
+
+// The worklet runtime threads that drive video exports never drain their
+// autorelease pool, so every autoreleased object created by a host function
+// (Metal command buffers, CoreMedia wrappers, AVFoundation internals…) would
+// accumulate for the lifetime of the app. JSI entry points doing ObjC work
+// run inside this helper. Convert NSError into an owning C++ exception after
+// the pool drains, avoiding a leaked CF retain on every failed export.
+template <typename F>
+static jsi::Value runPooled(F&& body) {
+  NSError* pendingError = nil;
+  jsi::Value result = jsi::Value::undefined();
+  @autoreleasepool {
+    try {
+      if constexpr (std::is_void_v<std::invoke_result_t<F>>) body();
+      else result = body();
+    } catch (NSError* error) {
+      pendingError = error;
+    }
+  }
+  if (pendingError) {
+    throw std::runtime_error([[pendingError localizedDescription] UTF8String]);
+  }
+  return result;
+}
+
+static jsi::Value NSErrorToJSI(jsi::Runtime& runtime, NSError* error) {
+  auto jsError = jsi::Object(runtime);
+  auto message = error == nil ? @"Unknown error" : [error description];
+  jsError.setProperty(
+      runtime, "message",
+      jsi::String::createFromUtf8(runtime, [message UTF8String]));
+  jsError.setProperty(runtime, "code",
+                      error != nil ? jsi::Value((double)[error code])
+                                   : jsi::Value::null());
+  return jsError;
+}
+} // namespace RNSkiaVideo

package/ios/RNSVScopedPixelBuffer.h

@@ -0,0 +1,17 @@
+#pragma once
+#import <CoreVideo/CoreVideo.h>
+
+namespace RNSkiaVideo {
+// Adopts the +1 returned by CoreVideo/AVPlayer copy APIs. The owner always
+// releases it, including when reserving a frame lease throws.
+class ScopedPixelBuffer {
+public:
+  explicit ScopedPixelBuffer(CVPixelBufferRef buffer) : buffer(buffer) {}
+  ~ScopedPixelBuffer() { if (buffer) CVPixelBufferRelease(buffer); }
+  ScopedPixelBuffer(const ScopedPixelBuffer&) = delete;
+  ScopedPixelBuffer& operator=(const ScopedPixelBuffer&) = delete;
+  CVPixelBufferRef get() const { return buffer; }
+private:
+  CVPixelBufferRef buffer;
+};
+}

package/ios/RNSVVideoPlayer.h

@@ -0,0 +1,46 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RNSVVideoPlayerDelegate <NSObject>
+
+- (void)readyToPlay:(NSDictionary*)assetInfos;
+- (void)frameAvailable:(CMTime)time;
+- (void)bufferingStart;
+- (void)bufferingEnd;
+- (void)bufferingUpdate:(NSArray<NSValue*>*)loadedTimeRanges;
+- (void)videoError:(nullable NSError*)error;
+- (void)complete;
+- (void)isPlaying:(BOOL)playing;
+
+@end
+
+@interface RNSVVideoPlayer : NSObject
+
+@property(nonatomic, readonly) CMTime currentTime;
+@property(nonatomic, readonly) CMTime duration;
+@property(nonatomic) float volume;
+@property(nonatomic) float playbackSpeed;
+@property(nonatomic, readonly) BOOL disposed;
+@property(nonatomic, readonly) BOOL isInitialized;
+@property(nonatomic, readonly) BOOL isPlaying;
+@property(nonatomic) BOOL isLooping;
+@property(nonatomic) CGSize resolution;
+
+- (instancetype)initWithURL:(NSURL*)url
+                   delegate:(id<RNSVVideoPlayerDelegate>)delegate
+                 resolution:(CGSize)resolution;
+/**
+ * Returns the pixel buffer for the given item time, or NULL if none is
+ * available. Ownership is transferred to the caller (CVPixelBufferRelease).
+ */
+- (nullable CVPixelBufferRef)copyPixelBufferForTime:(CMTime)time;
+- (void)pause;
+- (void)play;
+- (void)seekTo:(CMTime)time completionHandler:(void (^)(BOOL))completionHandle;
+- (void)dispose;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNSVVideoPlayer.mm

@@ -0,0 +1,410 @@
+//
+// Port from flutter video player, see:
+// https://github.com/flutter/packages/blob/41f5a16e13f4c9327e75d431d338c33f2fb35870/packages/video_player/video_player_avfoundation/darwin/Classes/FVPVideoPlayerPlugin.m
+//
+
+#import "RNSVVideoPlayer.h"
+#import "AVAssetTrackUtils.h"
+#import "RNSVColorSpace.h"
+#import <QuartzCore/QuartzCore.h>
+#include <atomic>
+
+static void* timeRangeContext = &timeRangeContext;
+static void* statusContext = &statusContext;
+static void* presentationSizeContext = &presentationSizeContext;
+static void* durationContext = &durationContext;
+static void* playbackLikelyToKeepUpContext = &playbackLikelyToKeepUpContext;
+static void* rateContext = &rateContext;
+
+@implementation RNSVVideoPlayer {
+  AVPlayer* _player;
+  AVPlayerItemVideoOutput* _videoOutput;
+  CADisplayLink* _displayLink;
+  id<RNSVVideoPlayerDelegate> _delegate;
+  Boolean _complete;
+  Boolean _waitingForFrame;
+  float _playbackSpeed;
+  std::atomic<bool> _disposed;
+  std::atomic<bool> _tracksLoading;
+}
+
+- (instancetype)initWithURL:(NSURL*)url
+                   delegate:(id<RNSVVideoPlayerDelegate>)delegate
+                 resolution:(CGSize)resolution {
+  self = [super init];
+  _disposed = false;
+  _tracksLoading = false;
+  _delegate = delegate;
+  _complete = NO;
+  _waitingForFrame = YES;
+  _playbackSpeed = 1.0f;
+
+  AVAsset* asset = [AVAsset assetWithURL:url];
+  self.resolution = resolution;
+  // IOSurface-backed: the frames are wrapped into Metal texture views without
+  // a copy, and their recycling is gated on the surface's use count.
+  // Output settings rather than plain pixel buffer attributes: the dictionary
+  // takes both, and only this form carries the color properties that make
+  // AVFoundation tone-map an HDR source to Rec.709 (see RNSVColorSpace.h).
+  NSMutableDictionary* outputSettings = [@{
+    (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
+    (id)kCVPixelBufferIOSurfacePropertiesKey : @{},
+    (id)kCVPixelBufferMetalCompatibilityKey : @YES,
+    AVVideoColorPropertiesKey : RNSkiaVideo::SDRColorProperties(),
+  } mutableCopy];
+  if (!CGSizeEqualToSize(CGSizeZero, resolution)) {
+    [outputSettings setValue:@(resolution.width)
+                      forKey:(id)kCVPixelBufferWidthKey];
+    [outputSettings setValue:@(resolution.height)
+                      forKey:(id)kCVPixelBufferHeightKey];
+  }
+
+  _videoOutput =
+      [[AVPlayerItemVideoOutput alloc] initWithOutputSettings:outputSettings];
+
+  _displayLink =
+      [CADisplayLink displayLinkWithTarget:self
+                                  selector:@selector(displayLinkFired:)];
+  [_displayLink addToRunLoop:[NSRunLoop currentRunLoop]
+                     forMode:NSRunLoopCommonModes];
+
+  AVPlayerItem* item = [AVPlayerItem playerItemWithAsset:asset];
+  _player = [AVPlayer playerWithPlayerItem:item];
+  _player.actionAtItemEnd = AVPlayerActionAtItemEndNone;
+  [self addObserversForItem:item player:_player];
+
+  return self;
+}
+
+- (BOOL)disposed { return _disposed.load(); }
+
+- (CMTime)currentTime {
+  return _player.currentTime;
+}
+
+- (CMTime)duration {
+  return _player.currentItem.duration;
+}
+
+- (void)pause {
+  _isPlaying = NO;
+  [self updatePlayingState];
+}
+
+- (void)play {
+  _isPlaying = YES;
+  [self updatePlayingState];
+}
+
+- (void)setIsLooping:(BOOL)isLooping {
+  _isLooping = isLooping;
+  _player.actionAtItemEnd =
+      isLooping ? AVPlayerActionAtItemEndNone : AVPlayerActionAtItemEndPause;
+  // restart only if video as ended
+  if (_complete) {
+    _complete = NO;
+    [_player.currentItem seekToTime:kCMTimeZero completionHandler:nil];
+  }
+}
+
+- (float)volume {
+  return _player.volume;
+}
+
+- (void)setVolume:(float)volume {
+  _player.volume =
+      (float)((volume < 0.0) ? 0.0 : ((volume > 1.0) ? 1.0 : volume));
+}
+
+- (float)playbackSpeed {
+  return _playbackSpeed;
+}
+
+- (void)setPlaybackSpeed:(float)playbackSpeed {
+  _playbackSpeed = MAX(0.1f, playbackSpeed);
+  if (_isPlaying) {
+    _player.rate = _playbackSpeed;
+  }
+}
+
+- (nullable CVPixelBufferRef)copyPixelBufferForTime:(CMTime)time {
+  if ([_videoOutput hasNewPixelBufferForItemTime:time]) {
+    // The frame retains this immutable buffer until its explicit disposal.
+    return [_videoOutput copyPixelBufferForItemTime:time
+                                 itemTimeForDisplay:nil];
+  }
+  return NULL;
+}
+
+- (void)seekTo:(CMTime)time
+    completionHandler:(void (^)(BOOL))completionHandler {
+  CMTime previousCMTime = _player.currentTime;
+  CMTime duration = _player.currentItem.asset.duration;
+  CMTime tolerance =
+      duration.value == time.value ? CMTimeMake(1, 1000) : kCMTimeZero;
+  __weak RNSVVideoPlayer* weakSelf = self;
+  [_player seekToTime:time
+        toleranceBefore:tolerance
+         toleranceAfter:tolerance
+      completionHandler:^(BOOL completed) {
+        RNSVVideoPlayer* owner = weakSelf;
+        if (!owner || owner->_disposed) return;
+        if (CMTimeCompare(owner->_player.currentTime, previousCMTime) != 0) {
+          // Ensure that a frame is drawn once available, even if currently
+          // paused. In theory a race is possible here where the new frame has
+          // already drawn by the time this code runs, and the display link
+          // stays on indefinitely, but that should be relatively harmless. This
+          // must use the display link rather than just informing the engine
+          // that a new frame is available because the seek completing doesn't
+          // guarantee that the pixel buffer is already available.
+          [owner expectFrame];
+        }
+
+        if (completionHandler) {
+          completionHandler(completed);
+        }
+      }];
+}
+
+- (void)addObserversForItem:(AVPlayerItem*)item player:(AVPlayer*)player {
+  [item addObserver:self
+         forKeyPath:@"loadedTimeRanges"
+            options:NSKeyValueObservingOptionInitial |
+                    NSKeyValueObservingOptionNew
+            context:timeRangeContext];
+  [item addObserver:self
+         forKeyPath:@"status"
+            options:NSKeyValueObservingOptionInitial |
+                    NSKeyValueObservingOptionNew
+            context:statusContext];
+  [item addObserver:self
+         forKeyPath:@"presentationSize"
+            options:NSKeyValueObservingOptionInitial |
+                    NSKeyValueObservingOptionNew
+            context:presentationSizeContext];
+  [item addObserver:self
+         forKeyPath:@"duration"
+            options:NSKeyValueObservingOptionInitial |
+                    NSKeyValueObservingOptionNew
+            context:durationContext];
+  [item addObserver:self
+         forKeyPath:@"playbackLikelyToKeepUp"
+            options:NSKeyValueObservingOptionInitial |
+                    NSKeyValueObservingOptionNew
+            context:playbackLikelyToKeepUpContext];
+
+  // Add observer to AVPlayer instead of AVPlayerItem since the AVPlayerItem
+  // does not have a "rate" property
+  [player addObserver:self
+           forKeyPath:@"rate"
+              options:NSKeyValueObservingOptionInitial |
+                      NSKeyValueObservingOptionNew
+              context:rateContext];
+
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(itemDidPlayToEndTime:)
+             name:AVPlayerItemDidPlayToEndTimeNotification
+           object:item];
+}
+
+- (void)displayLinkFired:(CADisplayLink*)sender {
+  if (_disposed) return;
+  CMTime outputItemTime =
+      [_videoOutput itemTimeForHostTime:CACurrentMediaTime()];
+  if ([_videoOutput hasNewPixelBufferForItemTime:outputItemTime]) {
+    [_delegate frameAvailable:outputItemTime];
+    if (_waitingForFrame) {
+      _waitingForFrame = NO;
+      // If the display link was only running temporarily to pick up a new frame
+      // while the video was paused, stop it again.
+      if (!self.isPlaying) {
+        _displayLink.paused = YES;
+      }
+    }
+  }
+}
+
+- (void)itemDidPlayToEndTime:(NSNotification*)notification {
+  if (_disposed) return;
+  if (notification.object == _player.currentItem && _isLooping) {
+    AVPlayerItem* item = [notification object];
+    // [item seekToTime:kCMTimeZero completionHandler:nil];
+    __weak RNSVVideoPlayer* weakSelf = self;
+    [item seekToTime:kCMTimeZero
+          toleranceBefore:kCMTimeZero
+           toleranceAfter:kCMTimeZero
+        completionHandler:^(BOOL finished) {
+          __strong RNSVVideoPlayer* strongSelf = weakSelf;
+          if (!strongSelf || strongSelf->_disposed)
+            return;
+          if (finished) {
+            [strongSelf->_delegate frameAvailable:kCMTimeZero];
+          }
+        }];
+  } else {
+    [_delegate complete];
+    _complete = YES;
+  }
+}
+
+- (void)observeValueForKeyPath:(NSString*)path
+                      ofObject:(id)object
+                        change:(NSDictionary*)change
+                       context:(void*)context {
+  if (_disposed) return;
+  if (context == timeRangeContext) {
+    NSArray<NSValue*>* timeRanges = [object loadedTimeRanges];
+    if (timeRanges != nil) {
+      [_delegate bufferingUpdate:[object loadedTimeRanges]];
+    }
+  } else if (context == statusContext) {
+    AVPlayerItem* item = (AVPlayerItem*)object;
+    switch (item.status) {
+      case AVPlayerItemStatusFailed:
+        [_delegate videoError:item.error];
+        break;
+      case AVPlayerItemStatusUnknown:
+        break;
+      case AVPlayerItemStatusReadyToPlay:
+        [item addOutput:_videoOutput];
+        [self dispatchReadyToPlay];
+        [self updatePlayingState];
+        break;
+    }
+  } else if (context == presentationSizeContext || context == durationContext) {
+    AVPlayerItem* item = (AVPlayerItem*)object;
+    if (item.status == AVPlayerItemStatusReadyToPlay) {
+      // Due to an apparent bug, when the player item is ready, it still may not
+      // have determined its presentation size or duration. When these
+      // properties are finally set, re-check if all required properties and
+      // instantiate the event sink if it is not already set up.
+      [self dispatchReadyToPlay];
+      [self updatePlayingState];
+    }
+  } else if (context == playbackLikelyToKeepUpContext) {
+    [self updatePlayingState];
+    if ([[_player currentItem] isPlaybackLikelyToKeepUp]) {
+      [_delegate bufferingEnd];
+    } else {
+      [_delegate bufferingStart];
+    }
+  } else if (context == rateContext) {
+    AVPlayer* player = (AVPlayer*)object;
+    [_delegate isPlaying:player.rate > 0];
+  }
+}
+
+- (void)dispatchReadyToPlay {
+  if (_disposed) return;
+  if (!_isInitialized) {
+    AVPlayerItem* currentItem = _player.currentItem;
+    CGSize resolution = CGSizeEqualToSize(self.resolution, CGSizeZero)
+                            ? currentItem.presentationSize
+                            : self.resolution;
+    CGFloat width = resolution.width;
+    CGFloat height = resolution.height;
+
+    // Wait until tracks are loaded to check duration or if there are any
+    // videos.
+    AVAsset* asset = currentItem.asset;
+    if ([asset statusOfValueForKey:@"tracks"
+                             error:nil] != AVKeyValueStatusLoaded) {
+      if (_tracksLoading.exchange(true)) return;
+      __weak RNSVVideoPlayer* weakSelf = self;
+      __weak AVAsset* weakAsset = asset;
+      void (^trackCompletionHandler)(void) = ^{
+        RNSVVideoPlayer* owner = weakSelf;
+        if (!owner) return;
+        owner->_tracksLoading = false;
+        AVAsset* loadedAsset = weakAsset;
+        if (owner->_disposed || !loadedAsset || [loadedAsset statusOfValueForKey:@"tracks"
+                                 error:nil] != AVKeyValueStatusLoaded) {
+          // Cancelled, or something failed.
+          return;
+        }
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf dispatchReadyToPlay];
+        });
+      };
+      [asset loadValuesAsynchronouslyForKeys:@[ @"tracks" ]
+                           completionHandler:trackCompletionHandler];
+      return;
+    }
+
+    NSArray* videoTracks = [asset tracksWithMediaType:AVMediaTypeVideo];
+    NSArray* allTracks = asset.tracks;
+    BOOL hasVideoTracks = videoTracks.count != 0;
+    BOOL hasNoTracks = allTracks.count == 0;
+
+    // The player has not yet initialized when it has no size, unless it is an
+    // audio-only track. HLS m3u8 video files never load any tracks, and are
+    // also not yet initialized until they have a size.
+    if ((hasVideoTracks || hasNoTracks) && height == CGSizeZero.height &&
+        width == CGSizeZero.width) {
+      return;
+    }
+    AVAssetTrack* track = [videoTracks firstObject];
+    int rotation =
+        RNSkiaVideo::AVAssetTrackUtils::GetTrackRotationInDegree(track);
+
+    // The player may be initialized but still needs to determine the duration.
+    CMTime duration = currentItem.duration;
+    if (CMTIME_IS_INDEFINITE(duration) || duration.timescale == 0 ||
+        duration.value == 0) {
+      return;
+    }
+
+    _isInitialized = YES;
+    [_delegate readyToPlay:@{
+      @"width" : @(width),
+      @"height" : @(height),
+      @"rotation" : @(rotation)
+    }];
+  }
+}
+
+- (void)updatePlayingState {
+  if (!_isInitialized) {
+    return;
+  }
+  if (_isPlaying && _player.rate == 0) {
+    _player.rate = _playbackSpeed;
+  } else if (!_isPlaying && _player.rate != 0) {
+    [_player pause];
+  }
+  // If the texture is still waiting for an expected frame, the display link
+  // needs to keep running until it arrives regardless of the play/pause state.
+  _displayLink.paused = !_isPlaying && !_waitingForFrame;
+}
+
+- (void)expectFrame {
+  _waitingForFrame = YES;
+  _displayLink.paused = NO;
+}
+
+- (void)removeKeyValueObservers {
+  AVPlayerItem* currentItem = _player.currentItem;
+  [currentItem removeObserver:self forKeyPath:@"status"];
+  [currentItem removeObserver:self forKeyPath:@"loadedTimeRanges"];
+  [currentItem removeObserver:self forKeyPath:@"presentationSize"];
+  [currentItem removeObserver:self forKeyPath:@"duration"];
+  [currentItem removeObserver:self forKeyPath:@"playbackLikelyToKeepUp"];
+  [_player removeObserver:self forKeyPath:@"rate"];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)dispose {
+  if (_disposed.exchange(true)) {
+    return;
+  }
+  [_player.currentItem cancelPendingSeeks];
+  [_player.currentItem.asset cancelLoading];
+  [self removeKeyValueObservers];
+  [_displayLink invalidate];
+  [_player replaceCurrentItemWithPlayerItem:nil];
+  _player = nil;
+  _displayLink = nil;
+}
+
+@end

package/ios/ReactNativeSkiaVideo.h

@@ -0,0 +1,8 @@
+#import <React/RCTCallInvokerModule.h>
+
+#import "RNReactNativeSkiaVideoSpec.h"
+
+@interface ReactNativeSkiaVideo
+    : NSObject <NativeReactNativeSkiaVideoSpec, RCTCallInvokerModule>
+
+@end