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

package/ios/ReactNativeSkiaVideo.mm

@@ -0,0 +1,310 @@
+#import "ReactNativeSkiaVideo.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTCallInvoker.h>
+#import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <jsi/jsi.h>
+
+#import "RNSVJSIUtils.h"
+#import "NativeResourceStats.h"
+#include "RNSVMemoryBudget.h"
+#import "VideoComposition.h"
+#import "VideoCompositionFramesExtractorHostObject.h"
+#import "VideoCompositionFramesExtractorSyncHostObject.h"
+#import "VideoEncoderHostObject.h"
+#include "RNSVCheckedSizes.h"
+#import "VideoPlayerHostObject.h"
+
+// In bridgeless mode `self.bridge` is an RCTBridgeProxy; its `runtime`
+// accessor is not declared in public headers.
+@interface RCTBridge (JSIRuntime)
+- (void*)runtime;
+@end
+
+@implementation ReactNativeSkiaVideo
+
+@synthesize bridge = _bridge;
+@synthesize callInvoker = _callInvoker;
+
+RCT_EXPORT_MODULE()
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  using namespace facebook;
+  using namespace RNSkiaVideo;
+
+  auto jsiRuntime = reinterpret_cast<jsi::Runtime*>(self.bridge.runtime);
+  if (jsiRuntime == nullptr) {
+    return @false;
+  }
+  std::shared_ptr<react::CallInvoker> jsCallInvoker =
+      self.callInvoker.callInvoker;
+  if (jsCallInvoker == nullptr) {
+    return @false;
+  }
+  auto& runtime = *jsiRuntime;
+  auto RNSVModule = jsi::Object(runtime);
+
+  auto createVideoPlayer = jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forAscii(runtime, "createVideoPlayer"), 3,
+      [jsCallInvoker](jsi::Runtime& runtime, const jsi::Value& thisValue,
+                      const jsi::Value* arguments, size_t count) -> jsi::Value {
+        if (count < 1 || !arguments[0].isString()) {
+          throw jsi::JSError(runtime,
+                             "ReactNativeSkiaVideo.createVideoPlayer(."
+                             ".) expects two arguments (string, object)!");
+        }
+
+        NSString* urlStr;
+        try {
+          urlStr = [NSString stringWithUTF8String:arguments[0]
+                                                      .asString(runtime)
+                                                      .utf8(runtime)
+                                                      .c_str()];
+        } catch (NSError* error) {
+          throw jsi::JSError(
+              runtime, "SkiaVideo.createRNSVPlayer(..) could not parse url");
+        }
+        CGSize resolution = CGSize();
+        if (count >= 2 && arguments[1].isObject()) {
+          auto res = arguments[1].asObject(runtime);
+          resolution.width = checkedPositiveInt(res.getProperty(runtime, "width").asNumber(), "decode width");
+          resolution.height = checkedPositiveInt(res.getProperty(runtime, "height").asNumber(), "decode height");
+        }
+
+        // { textureMode?: 'copy' | 'direct' } — copy is the default.
+        bool directTexture = false;
+        if (count >= 3 && arguments[2].isObject()) {
+          auto options = arguments[2].asObject(runtime);
+          if (options.hasProperty(runtime, "textureMode")) {
+            auto mode = options.getProperty(runtime, "textureMode");
+            if (mode.isString()) {
+              directTexture = mode.asString(runtime).utf8(runtime) == "direct";
+            }
+          }
+        }
+
+        NSURL* url = [NSURL URLWithString:urlStr];
+
+        auto instance = std::make_shared<VideoPlayerHostObject>(
+            runtime, jsCallInvoker, url, resolution, directTexture);
+        instance->initialize(url, resolution);
+        return jsi::Object::createFromHostObject(runtime, instance);
+      });
+  RNSVModule.setProperty(runtime, "createVideoPlayer",
+                         std::move(createVideoPlayer));
+
+  runtime.global().setProperty(runtime, "RNSkiaVideo", RNSVModule);
+
+  auto createVideoCompositionFramesExtractor =
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(runtime,
+                                    "createVideoCompositionFramesExtractor"),
+          1,
+          [jsCallInvoker](jsi::Runtime& runtime, const jsi::Value& thisValue,
+                          const jsi::Value* arguments,
+                          size_t count) -> jsi::Value {
+            if (count != 1 || !arguments[0].isObject()) {
+              throw jsi::JSError(runtime,
+                                 "ReactNativeSkiaVideo."
+                                 "createVideoCompositionFramesExtractor(.."
+                                 ") expects one arguments (object)!");
+            }
+
+            jsi::Object jsObject = arguments[0].asObject(runtime);
+            auto videoComposition = VideoComposition::fromJS(runtime, jsObject);
+            auto instance =
+                std::make_shared<VideoCompositionFramesExtractorHostObject>(
+                    runtime, jsCallInvoker, videoComposition);
+            return jsi::Object::createFromHostObject(runtime, instance);
+          });
+  RNSVModule.setProperty(runtime, "createVideoCompositionFramesExtractor",
+                         std::move(createVideoCompositionFramesExtractor));
+
+  auto createVideoCompositionFramesExtractorSync =
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(
+              runtime, "createVideoCompositionFramesExtractorSync"),
+          1,
+          [](jsi::Runtime& runtime, const jsi::Value& thisValue,
+             const jsi::Value* arguments, size_t count) -> jsi::Value {
+            if (count != 1 || !arguments[0].isObject()) {
+              throw jsi::JSError(runtime,
+                                 "ReactNativeSkiaVideo."
+                                 "createVideoCompositionFramesExtractorSync(..)"
+                                 " expects one arguments (object)!");
+            }
+
+            jsi::Object jsObject = arguments[0].asObject(runtime);
+            auto videoComposition = VideoComposition::fromJS(runtime, jsObject);
+            auto instance =
+                std::make_shared<VideoCompositionFramesExtractorSyncHostObject>(
+                    videoComposition);
+            return jsi::Object::createFromHostObject(runtime, instance);
+          });
+
+  RNSVModule.setProperty(runtime, "createVideoCompositionFramesExtractorSync",
+                         std::move(createVideoCompositionFramesExtractorSync));
+
+  auto createVideoEncoder = jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forAscii(runtime, "createVideoEncoder"), 2,
+      [](jsi::Runtime& runtime, const jsi::Value& thisValue,
+         const jsi::Value* arguments, size_t count) -> jsi::Value {
+        if (count < 1 || !arguments[0].isObject()) {
+          throw jsi::JSError(
+              runtime,
+              "ReactNativeSkiaVideo.createVideoEncoder(..) expects an options "
+              "object and an optional composition object!");
+        }
+
+        auto options = arguments[0].asObject(runtime);
+        auto outPath = options.getProperty(runtime, "outPath")
+                           .asString(runtime)
+                           .utf8(runtime);
+        int width = checkedPositiveInt(options.getProperty(runtime, "width").asNumber(), "encoder width");
+        int height = checkedPositiveInt(options.getProperty(runtime, "height").asNumber(), "encoder height");
+        int frameRate = checkedPositiveInt(options.getProperty(runtime, "frameRate").asNumber(), "encoder frame rate");
+        int bitRate = checkedPositiveInt(options.getProperty(runtime, "bitRate").asNumber(), "encoder bitrate");
+        std::string codec = "h264";
+        if (options.hasProperty(runtime, "codec")) {
+          auto value = options.getProperty(runtime, "codec");
+          if (value.isString()) {
+            codec = value.asString(runtime).utf8(runtime);
+          }
+        }
+        int audioBitRate = 128000;
+        int audioSampleRate = 44100;
+        int audioChannelCount = 2;
+        if (options.hasProperty(runtime, "audioBitRate")) {
+          auto value = options.getProperty(runtime, "audioBitRate");
+          if (value.isNumber()) {
+            audioBitRate = checkedPositiveInt(value.asNumber(), "audio bitrate");
+          }
+        }
+        if (options.hasProperty(runtime, "audioSampleRate")) {
+          auto value = options.getProperty(runtime, "audioSampleRate");
+          if (value.isNumber()) {
+            audioSampleRate = checkedPositiveInt(value.asNumber(), "audio sample rate");
+          }
+        }
+        if (options.hasProperty(runtime, "audioChannelCount")) {
+          auto value = options.getProperty(runtime, "audioChannelCount");
+          if (value.isNumber()) {
+            audioChannelCount = checkedPositiveInt(value.asNumber(), "audio channel count");
+          }
+        }
+
+        std::shared_ptr<VideoComposition> composition = nullptr;
+        if (count >= 2 && arguments[1].isObject()) {
+          auto jsComposition = arguments[1].asObject(runtime);
+          composition = VideoComposition::fromJS(runtime, jsComposition);
+        }
+
+        // encoderMode: 'copy' (default) | 'direct'
+        bool directEncoder = false;
+        if (options.hasProperty(runtime, "encoderMode")) {
+          auto value = options.getProperty(runtime, "encoderMode");
+          if (value.isString()) {
+            directEncoder = value.asString(runtime).utf8(runtime) == "direct";
+          }
+        }
+
+        auto instance = std::make_shared<VideoEncoderHostObject>(
+            outPath, width, height, frameRate, bitRate, codec, audioBitRate,
+            audioSampleRate, audioChannelCount, composition, directEncoder);
+        return jsi::Object::createFromHostObject(runtime, instance);
+      });
+  RNSVModule.setProperty(runtime, "createVideoEncoder",
+                         std::move(createVideoEncoder));
+
+  auto isEncodingSupported = jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forAscii(runtime, "isEncodingSupported"), 1,
+      [](jsi::Runtime& runtime, const jsi::Value& thisValue,
+         const jsi::Value* arguments, size_t count) -> jsi::Value {
+        if (count < 1 || !arguments[0].isString()) {
+          throw jsi::JSError(runtime,
+                             "ReactNativeSkiaVideo.isEncodingSupported(..) "
+                             "expects a codec name!");
+        }
+        auto codec = arguments[0].asString(runtime).utf8(runtime);
+        return jsi::Value(VideoEncoderHostObject::isCodecSupported(codec));
+      });
+  RNSVModule.setProperty(runtime, "isEncodingSupported",
+                         std::move(isEncodingSupported));
+
+  // Worklet runtime threads never drain their autorelease pool, so any
+  // per-frame ObjC garbage created by JS code running there (e.g. the Metal
+  // command buffers autoreleased by Skia's surface.flush) accumulates for the
+  // lifetime of the app. This lets JS run a block of work inside a pool.
+  auto runWithAutoreleasePool = jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forAscii(runtime, "runWithAutoreleasePool"), 1,
+      [](jsi::Runtime& runtime, const jsi::Value& thisValue,
+         const jsi::Value* arguments, size_t count) -> jsi::Value {
+        if (count < 1 || !arguments[0].isObject() ||
+            !arguments[0].asObject(runtime).isFunction(runtime)) {
+          throw jsi::JSError(runtime,
+                             "ReactNativeSkiaVideo.runWithAutoreleasePool(..) "
+                             "expects a function!");
+        }
+        auto fn = arguments[0].asObject(runtime).asFunction(runtime);
+        @autoreleasepool {
+          return fn.call(runtime);
+        }
+      });
+  RNSVModule.setProperty(runtime, "runWithAutoreleasePool",
+                         std::move(runWithAutoreleasePool));
+
+  MemoryBudget::install(runtime, RNSVModule);
+  RNSVModule.setProperty(runtime, "getResourceStats",
+      jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forAscii(runtime, "getResourceStats"), 0,
+          [](jsi::Runtime& rt, const jsi::Value&, const jsi::Value*, size_t) {
+            auto result = jsi::Object(rt);
+            auto add = [&](const char* name, const ResourceCounter& counter) {
+              result.setProperty(rt, (std::string(name) + "Current").c_str(),
+                                 static_cast<double>(counter.current.load()));
+              result.setProperty(rt, (std::string(name) + "Peak").c_str(),
+                                 static_cast<double>(counter.peak.load()));
+            };
+            add("frameBuffers", NativeResourceStats::frameBuffers);
+            add("frameBytes", NativeResourceStats::frameBytes);
+            add("decoderBuffers", NativeResourceStats::decoderBuffers);
+            add("decoderBytes", NativeResourceStats::decoderBytes);
+            add("decoders", NativeResourceStats::decoders);
+            add("encoders", NativeResourceStats::encoders);
+            add("encoderSubmittingBuffers", NativeResourceStats::encoderSubmittingBuffers);
+            add("encoderSubmittingBytes", NativeResourceStats::encoderSubmittingBytes);
+            return jsi::Value(std::move(result));
+          }));
+  RNSVModule.setProperty(runtime, "getBackendInfo",
+      jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forAscii(runtime, "getBackendInfo"), 0,
+          [](jsi::Runtime& rt, const jsi::Value&, const jsi::Value*, size_t) {
+            auto result = jsi::Object(rt);
+            result.setProperty(rt, "platform", "ios");
+            result.setProperty(rt, "frameTransport", "cvpixelbuffer-bgra");
+            result.setProperty(rt, "preview", "webgpu-native-blit+gpu-owned-snapshot");
+            result.setProperty(rt, "gpuUploadScratchCapacityPerRuntime", 1);
+            // The export probes the GPU path at setup and warns when it falls back.
+            result.setProperty(rt, "export", "gpu-iosurface-bounded-pixelbuffer-pool");
+            result.setProperty(rt, "exportFallback", "cpu-readback-bounded-pixelbuffer-pool");
+            // Decoded frames are sampled through their IOSurface during a GPU
+            // export, copied into owned snapshots only if that import fails.
+            result.setProperty(rt, "exportSource", "iosurface-in-place");
+            result.setProperty(rt, "nativeFrameCapacity", 2);
+            result.setProperty(rt, "encoderPoolCapacity", 3);
+            result.setProperty(rt, "gpuDirectExport", true);
+            return jsi::Value(std::move(result));
+          }));
+  runtime.global().setProperty(runtime, "RNSkiaVideo", RNSVModule);
+  return @true;
+}
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams&)params {
+  return std::make_shared<facebook::react::NativeReactNativeSkiaVideoSpecJSI>(
+      params);
+}
+
+@end

package/ios/SeekPolicy.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace RNSkiaVideo {
+
+/**
+ * How far ahead a seek is served by reading the reader on rather than by
+ * building a new one.
+ *
+ * A drag lands a seek every few frames; measured on a 4K HEVC clip, creating
+ * an AVAssetReader costs more than decoding the second of video it skips.
+ */
+constexpr double kSeekReadOnSeconds = 1.0;
+
+/**
+ * Whether a seek to `target` can be served by the reader already running at
+ * `last`. Backwards never can: an AVAssetReader only moves forward.
+ */
+inline bool seekReadsOn(bool readerRunning, bool lastValid, double last,
+                        double target) {
+  if (!readerRunning || !lastValid) {
+    return false;
+  }
+  double ahead = target - last;
+  return ahead >= 0 && ahead <= kSeekReadOnSeconds;
+}
+
+} // namespace RNSkiaVideo

package/ios/VideoComposition.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#import <CoreGraphics/CoreGraphics.h>
+
+#include <jsi/jsi.h>
+#include "RNSVCheckedSizes.h"
+#include <set>
+
+namespace RNSkiaVideo {
+using namespace facebook;
+
+class VideoCompositionItem {
+public:
+  std::string id;
+  std::string path;
+  double compositionStartTime;
+  double startTime;
+  double duration;
+  CGSize resolution;
+  /**
+   * Cap for the longest side of the decoded frames, or 0 for the file's own
+   * size. Applied here rather than by the caller because only the decoder knows
+   * the track's encoded orientation: a portrait clip is a landscape frame plus a
+   * rotation, so a caller passing a portrait size for one gets a squashed
+   * picture. See VideoCompositionItemDecoder#setupReader.
+   */
+  double maxLongSide = 0;
+  /**
+   * `textureMode: 'direct'` hands Skia the decoder's own pixel buffers,
+   * without the per-frame copy into a persistent texture that `'copy'` (the
+   * default) does. iOS only.
+   */
+  bool directTexture = false;
+  bool isVideo = true;
+  bool audioEnabled = false;
+  double audioVolume = 1.0;
+};
+
+class VideoComposition {
+public:
+  double duration;
+  std::vector<std::shared_ptr<VideoCompositionItem>> items;
+  /** Decoders opened around their item's time, see DecoderWindow. */
+  bool lazyDecoders = false;
+
+  bool hasAudio() const {
+    for (const auto& item : items) {
+      if (item->audioEnabled) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  static std::shared_ptr<VideoComposition> fromJS(jsi::Runtime& runtime,
+                                                  jsi::Object& jsComposition) {
+    auto composition = std::make_shared<VideoComposition>();
+    composition->duration =
+        checkedMediaSeconds(jsComposition.getProperty(runtime, "duration").asNumber());
+    if (jsComposition.hasProperty(runtime, "lazyDecoders")) {
+      auto lazyProp = jsComposition.getProperty(runtime, "lazyDecoders");
+      composition->lazyDecoders = lazyProp.isBool() && lazyProp.getBool();
+    }
+    auto jsItems = jsComposition.getProperty(runtime, "items")
+                       .asObject(runtime)
+                       .asArray(runtime);
+    auto size = jsItems.size(runtime);
+    std::set<std::string> ids;
+    for (size_t i = 0; i < size; i++) {
+      auto jsItem = jsItems.getValueAtIndex(runtime, i).asObject(runtime);
+      auto item = std::make_shared<VideoCompositionItem>();
+      item->id =
+          jsItem.getProperty(runtime, "id").asString(runtime).utf8(runtime);
+      if (item->id.empty() || !ids.insert(item->id).second)
+        throw jsi::JSError(runtime, "Composition item IDs must be nonempty and unique");
+      item->path =
+          jsItem.getProperty(runtime, "path").asString(runtime).utf8(runtime);
+      item->compositionStartTime =
+          checkedMediaSeconds(jsItem.getProperty(runtime, "compositionStartTime").asNumber());
+      item->startTime = checkedMediaSeconds(jsItem.getProperty(runtime, "startTime").asNumber());
+      item->duration = checkedMediaSeconds(jsItem.getProperty(runtime, "duration").asNumber());
+      checkedMediaSeconds(item->startTime + item->duration);
+      checkedMediaSeconds(item->compositionStartTime + item->duration);
+      item->resolution = CGSize();
+      if (jsItem.hasProperty(runtime, "resolution")) {
+        auto resProp = jsItem.getProperty(runtime, "resolution");
+        if (resProp.isObject()) {
+          auto res = resProp.asObject(runtime);
+          item->resolution.width = checkedPositiveInt(res.getProperty(runtime, "width").asNumber(), "decode width");
+          item->resolution.height =
+              checkedPositiveInt(res.getProperty(runtime, "height").asNumber(), "decode height");
+        }
+      }
+
+      if (jsItem.hasProperty(runtime, "maxLongSide")) {
+        auto capProp = jsItem.getProperty(runtime, "maxLongSide");
+        if (capProp.isNumber()) {
+          item->maxLongSide = checkedStorageInteger(capProp.asNumber(), "decode maxLongSide");
+          if (item->maxLongSide > std::numeric_limits<int>::max())
+            throw jsi::JSError(runtime, "Invalid decode maxLongSide");
+        }
+      }
+
+      if (jsItem.hasProperty(runtime, "textureMode")) {
+        auto modeProp = jsItem.getProperty(runtime, "textureMode");
+        if (modeProp.isString()) {
+          item->directTexture =
+              modeProp.asString(runtime).utf8(runtime) == "direct";
+        }
+      }
+
+      if (jsItem.hasProperty(runtime, "kind")) {
+        auto kindProp = jsItem.getProperty(runtime, "kind");
+        if (kindProp.isString()) {
+          item->isVideo = kindProp.asString(runtime).utf8(runtime) != "audio";
+        }
+      }
+      if (!item->isVideo) {
+        item->audioEnabled = true;
+        if (jsItem.hasProperty(runtime, "volume")) {
+          auto volumeProp = jsItem.getProperty(runtime, "volume");
+          if (volumeProp.isNumber()) {
+            item->audioVolume = volumeProp.asNumber();
+          }
+        }
+      } else if (jsItem.hasProperty(runtime, "audio")) {
+        auto audioProp = jsItem.getProperty(runtime, "audio");
+        if (audioProp.isBool()) {
+          item->audioEnabled = audioProp.getBool();
+        } else if (audioProp.isObject()) {
+          item->audioEnabled = true;
+          auto audio = audioProp.asObject(runtime);
+          if (audio.hasProperty(runtime, "volume")) {
+            auto volumeProp = audio.getProperty(runtime, "volume");
+            if (volumeProp.isNumber()) {
+              item->audioVolume = volumeProp.asNumber();
+            }
+          }
+        }
+      }
+
+      composition->items.push_back(item);
+    }
+    return composition;
+  }
+};
+
+} // namespace RNSkiaVideo

package/ios/VideoCompositionFramesExtractorHostObject.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#import "DecoderWindow.h"
+#import "RNSVEventEmitter.h"
+#import "RNSVHostObject.h"
+#import "VideoComposition.h"
+#import "VideoCompositionItemDecoder.h"
+#import "VideoFrame.h"
+#import <AVFoundation/AVFoundation.h>
+#import <QuartzCore/QuartzCore.h>
+#import <atomic>
+#import <jsi/jsi.h>
+#import <map>
+#import <set>
+#import <vector>
+
+@interface RNSVDisplayLinkWrapper : NSObject
+
+@property(nonatomic, strong) CADisplayLink* displayLink;
+@property(nonatomic, copy) void (^updateBlock)(CADisplayLink* displayLink);
+
+- (instancetype)initWithUpdateBlock:
+    (void (^)(CADisplayLink* displayLink))updateBlock;
+- (void)start;
+- (void)invalidate;
+
+@end
+
+namespace RNSkiaVideo {
+using namespace facebook;
+
+class JSI_EXPORT VideoCompositionFramesExtractorHostObject
+    : public RNSVHostObject,
+      EventEmitter {
+public:
+  VideoCompositionFramesExtractorHostObject(
+      jsi::Runtime& runtime, std::shared_ptr<react::CallInvoker> callInvoker,
+      std::shared_ptr<VideoComposition> videoComposition);
+  ~VideoCompositionFramesExtractorHostObject();
+  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;
+
+private:
+  NSObject* lock;
+  std::shared_ptr<VideoComposition> composition;
+  DecoderWindow window;
+  std::map<std::string, std::shared_ptr<VideoCompositionItemDecoder>>
+      itemDecoders;
+  // Items whose decoder could not be opened lazily: not tried again.
+  std::set<std::string> failedItems;
+  // Shared by the decoders and the audio; decoder queue only.
+  NSMutableDictionary<NSString*, AVURLAsset*>* assetCache;
+  // Tells whether a seek happened while a decoder was being opened.
+  uint64_t seekGeneration = 0;
+  // What the decoders were last advanced to, so a paused player stops
+  // asking them again at every vsync.
+  CMTime lastAdvancedTime = kCMTimeInvalid;
+  uint64_t lastAdvancedGeneration = 0;
+  // Seeks and reader advancement share the serial decoder queue. UI calls
+  // update the desired clock; they never replace a reader being decoded.
+  uint64_t lastAppliedSeekGeneration = 0;
+  std::map<std::string, std::shared_ptr<VideoFrame>> currentFrames;
+  // Incremented every time decodeCompositionFrames acquires a new frame for
+  // at least one item. Exposed to JS as `framesVersion`, so the player can
+  // tell an unchanged frame set from a fresh one and skip redrawing it.
+  uint64_t framesVersion = 0;
+  dispatch_queue_t decoderQueue;
+  std::atomic<bool> decoderTickPending{false};
+  RNSVDisplayLinkWrapper* displayLink;
+  NSDate* startDate;
+  CMTime pausePosition = kCMTimeZero;
+  bool playWhenReady = false;
+  bool isPlaying = false;
+  bool isLooping = false;
+  bool initialized = false;
+  /** Set by a seek, cleared by the first frame drawn after it. */
+  std::atomic<bool> seekPending = false;
+  bool completeEmitted = false;
+  // Plays the audio of the composition; when present it is also the master
+  // clock of the playback.
+  AVPlayer* audioPlayer;
+  std::atomic_flag released = ATOMIC_FLAG_INIT;
+
+  void prepare();
+  void scheduleDecode();
+  void decodeTick();
+  void init();
+  void play();
+  void pause();
+  void seekTo(CMTime time);
+  CMTime getCurrentTime();
+  void release();
+  bool opensAt(const std::shared_ptr<VideoCompositionItem>& item,
+               double position) const;
+  void updateWindow(
+      CMTime time, std::vector<std::shared_ptr<VideoCompositionItem>>& opening,
+      std::vector<std::shared_ptr<VideoCompositionItemDecoder>>& closing);
+  void
+  openDecoders(const std::vector<std::shared_ptr<VideoCompositionItem>>& items,
+               CMTime time, uint64_t generation);
+};
+
+} // namespace RNSkiaVideo