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

package/android/cpp/VideoCapabilities.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <optional>
+#include <jsi/jsi.h>
+
+namespace RNSkiaVideo {
+using namespace facebook;
+using namespace jni;
+
+struct DecoderInfo : JavaClass<DecoderInfo> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/azzapp/rnskv/VideoCapabilities$DecoderInfo;";
+  jint getMaxInstances() const;
+  jint getMaxWidth() const;
+  jint getMaxHeight() const;
+};
+
+struct EncoderInfo : JavaClass<EncoderInfo> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/azzapp/rnskv/VideoCapabilities$EncoderInfo;";
+  std::string getEncoderName() const;
+  jboolean getHardwareAccelerated() const;
+  jint getWidth() const;
+  jint getHeight() const;
+  jint getFrameRate() const;
+  jint getBitrate() const;
+};
+
+struct VideoCapabilities : JavaClass<VideoCapabilities> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/azzapp/rnskv/VideoCapabilities;";
+  static jni::local_ref<DecoderInfo>
+  getDecodingCapabilitiesFor(std::string mimeType);
+  static jni::local_ref<JList<EncoderInfo>>
+  getValidEncoderConfigurations(int width, int height, int framerate,
+                                int bitrate,
+                                std::optional<std::string> codec);
+};
+
+} // namespace RNSkiaVideo

package/android/cpp/VideoComposition.cpp

@@ -0,0 +1,170 @@
+#include "RNSVCheckedSizes.h"
+#include <set>
+#include "VideoComposition.h"
+#include "NativeHardwareBuffer.h"
+
+namespace RNSkiaVideo {
+
+using namespace facebook::jni;
+
+local_ref<VideoCompositionItem>
+VideoCompositionItem::create(std::string& id, std::string& path,
+                             double compositionStartTime, double startTime,
+                             double duration) {
+  auto inst = newInstance();
+  auto cls = javaClassStatic();
+  inst->setFieldValue(cls->getField<JString>("id"), make_jstring(id).get());
+  inst->setFieldValue(cls->getField<JString>("path"), make_jstring(path).get());
+  inst->setFieldValue(cls->getField<jdouble>("compositionStartTime"),
+                      compositionStartTime);
+  inst->setFieldValue(cls->getField<jdouble>("startTime"), startTime);
+  inst->setFieldValue(cls->getField<jdouble>("duration"), duration);
+  return inst;
+}
+
+std::string VideoCompositionItem::getId() const {
+  static const auto getIdMethod = getClass()->getMethod<jstring()>("getId");
+  return getIdMethod(self())->toStdString();
+}
+
+std::string VideoCompositionItem::getPath() const {
+  static const auto getPathMethod = getClass()->getMethod<jstring()>("getPath");
+  return getPathMethod(self())->toStdString();
+}
+
+jdouble VideoCompositionItem::getCompositionStartTime() const {
+  static const auto getCompositionStartTimeMethod =
+      getClass()->getMethod<jdouble()>("getCompositionStartTime");
+  return getCompositionStartTimeMethod(self());
+}
+
+jdouble VideoCompositionItem::getStartTime() const {
+  static const auto getStartTimeMethod =
+      getClass()->getMethod<jdouble()>("getStartTime");
+  return getStartTimeMethod(self());
+}
+
+jdouble VideoCompositionItem::getDuration() const {
+  static const auto getDurationMethod =
+      getClass()->getMethod<jdouble()>("getDuration");
+  return getDurationMethod(self());
+}
+
+local_ref<VideoComposition>
+VideoComposition::create(jdouble duration,
+                         alias_ref<JList<VideoCompositionItem>> items) {
+  return newInstance(duration, items);
+}
+
+local_ref<VideoComposition>
+VideoComposition::fromJSIObject(jsi::Runtime& runtime,
+                                jsi::Object& jsComposition) {
+  auto duration = checkedMediaSeconds(jsComposition.getProperty(runtime, "duration").asNumber());
+  auto jsItems = jsComposition.getProperty(runtime, "items")
+                     .asObject(runtime)
+                     .asArray(runtime);
+  auto size = jsItems.size(runtime);
+  local_ref<JList<VideoCompositionItem>> items =
+      JArrayList<VideoCompositionItem>::create(size);
+  if (size > INT32_MAX) throw jsi::JSError(runtime, "Too many composition items");
+  std::set<std::string> ids;
+  for (size_t i = 0; i < size; i++) {
+    auto jsItem = jsItems.getValueAtIndex(runtime, i).asObject(runtime);
+    auto id = jsItem.getProperty(runtime, "id").asString(runtime).utf8(runtime);
+    if (id.empty() || !ids.insert(id).second) throw jsi::JSError(runtime, "Composition item IDs must be nonempty and unique");
+    auto path =
+        jsItem.getProperty(runtime, "path").asString(runtime).utf8(runtime);
+    auto compositionStartTime =
+        checkedMediaSeconds(jsItem.getProperty(runtime, "compositionStartTime").asNumber());
+    auto startTime = checkedMediaSeconds(jsItem.getProperty(runtime, "startTime").asNumber());
+    auto duration = checkedMediaSeconds(jsItem.getProperty(runtime, "duration").asNumber());
+
+    auto item = VideoCompositionItem::create(id, path, compositionStartTime,
+                                             startTime, duration);
+    auto itemCls = VideoCompositionItem::javaClassStatic();
+    if (jsItem.hasProperty(runtime, "resolution")) {
+      auto resProp = jsItem.getProperty(runtime, "resolution");
+      if (resProp.isObject()) {
+        auto res = resProp.asObject(runtime);
+        item->setFieldValue(itemCls->getField<jint>("width"),
+                            checkedPositiveInt(res.getProperty(runtime, "width").asNumber(), "decode width"));
+        item->setFieldValue(itemCls->getField<jint>("height"),
+                            checkedPositiveInt(res.getProperty(runtime, "height").asNumber(), "decode height"));
+      }
+    }
+    if (jsItem.hasProperty(runtime, "textureMode")) {
+      auto modeProp = jsItem.getProperty(runtime, "textureMode");
+      if (modeProp.isString() &&
+          modeProp.asString(runtime).utf8(runtime) == "direct") {
+        item->setFieldValue(itemCls->getField<jboolean>("directTexture"),
+                            (jboolean)JNI_TRUE);
+      }
+    }
+    if (jsItem.hasProperty(runtime, "maxLongSide")) {
+      auto capProp = jsItem.getProperty(runtime, "maxLongSide");
+      if (capProp.isNumber() && capProp.asNumber() > 0) {
+        item->setFieldValue(itemCls->getField<jint>("maxLongSide"),
+                            checkedPositiveInt(capProp.asNumber(), "decode maxLongSide"));
+      }
+    }
+    bool isVideo = true;
+    if (jsItem.hasProperty(runtime, "kind")) {
+      auto kindProp = jsItem.getProperty(runtime, "kind");
+      if (kindProp.isString()) {
+        isVideo = kindProp.asString(runtime).utf8(runtime) != "audio";
+      }
+    }
+    bool audioEnabled = false;
+    double audioVolume = 1.0;
+    if (!isVideo) {
+      audioEnabled = true;
+      if (jsItem.hasProperty(runtime, "volume")) {
+        auto volumeProp = jsItem.getProperty(runtime, "volume");
+        if (volumeProp.isNumber()) {
+          audioVolume = volumeProp.asNumber();
+        }
+      }
+    } else if (jsItem.hasProperty(runtime, "audio")) {
+      auto audioProp = jsItem.getProperty(runtime, "audio");
+      if (audioProp.isBool()) {
+        audioEnabled = audioProp.getBool();
+      } else if (audioProp.isObject()) {
+        audioEnabled = true;
+        auto audio = audioProp.asObject(runtime);
+        if (audio.hasProperty(runtime, "volume")) {
+          auto volumeProp = audio.getProperty(runtime, "volume");
+          if (volumeProp.isNumber()) {
+            audioVolume = volumeProp.asNumber();
+          }
+        }
+      }
+    }
+    item->setFieldValue(itemCls->getField<jboolean>("isVideo"),
+                        (jboolean)isVideo);
+    item->setFieldValue(itemCls->getField<jboolean>("audioEnabled"),
+                        (jboolean)audioEnabled);
+    item->setFieldValue(itemCls->getField<jdouble>("audioVolume"), audioVolume);
+
+    items->add(item);
+  }
+  auto composition = VideoComposition::create(duration, items);
+  composition->setFieldValue(VideoComposition::javaClassStatic()->getField<jboolean>(
+      "hardwareBufferEnabled"), static_cast<jboolean>(NativeHardwareBuffer::isEnabled()));
+  if (jsComposition.hasProperty(runtime, "lazyDecoders")) {
+    auto lazyProp = jsComposition.getProperty(runtime, "lazyDecoders");
+    if (lazyProp.isBool() && lazyProp.getBool()) {
+      composition->setFieldValue(
+          VideoComposition::javaClassStatic()->getField<jboolean>(
+              "lazyDecoders"),
+          (jboolean)JNI_TRUE);
+    }
+  }
+  return composition;
+}
+
+bool VideoComposition::hasDirectTextures() const {
+  static const auto hasDirectTexturesMethod =
+      getClass()->getMethod<jboolean()>("hasDirectTextures");
+  return hasDirectTexturesMethod(self());
+}
+} // namespace RNSkiaVideo

package/android/cpp/VideoComposition.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <fbjni/ByteBuffer.h>
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+
+namespace RNSkiaVideo {
+
+using namespace facebook;
+using namespace jni;
+
+struct VideoCompositionItem : public JavaClass<VideoCompositionItem> {
+  static constexpr auto kJavaDescriptor =
+      "Lcom/azzapp/rnskv/VideoComposition$Item;";
+  static local_ref<VideoCompositionItem>
+  create(std::string& id, std::string& path, double compositionStartTime,
+         double startTime, double duration);
+
+  std::string getId() const;
+  std::string getPath() const;
+  double getCompositionStartTime() const;
+  double getStartTime() const;
+  double getDuration() const;
+};
+
+struct VideoComposition : public JavaClass<VideoComposition> {
+  static constexpr auto kJavaDescriptor = "Lcom/azzapp/rnskv/VideoComposition;";
+  static local_ref<VideoComposition>
+  create(double duration, alias_ref<JList<VideoCompositionItem>> items);
+  static local_ref<VideoComposition> fromJSIObject(jsi::Runtime& runtime,
+                                                   jsi::Object& jsComposition);
+  /** Whether an item hands its decoder's buffers over (textureMode: direct). */
+  bool hasDirectTextures() const;
+};
+} // namespace RNSkiaVideo

package/android/cpp/VideoCompositionFramesExtractor.cpp

@@ -0,0 +1,82 @@
+#include "VideoCompositionFramesExtractor.h"
+
+namespace RNSkiaVideo {
+using namespace facebook::jni;
+
+local_ref<VideoCompositionFramesExtractor>
+VideoCompositionFramesExtractor::create(
+    alias_ref<VideoComposition> composition,
+    alias_ref<NativeEventDispatcher> dispatcher) {
+  return newInstance(composition, dispatcher);
+}
+
+void VideoCompositionFramesExtractor::prepare() const {
+  static const auto prepareMethod = getClass()->getMethod<void()>("prepare");
+  prepareMethod(self());
+}
+
+void VideoCompositionFramesExtractor::play() const {
+  static const auto playMethod = getClass()->getMethod<void()>("play");
+  playMethod(self());
+}
+
+void VideoCompositionFramesExtractor::pause() const {
+  static const auto pauseMethod = getClass()->getMethod<void()>("pause");
+  pauseMethod(self());
+}
+
+void VideoCompositionFramesExtractor::seekTo(jlong position) const {
+  static const auto seekToMethod = getClass()->getMethod<void(jlong)>("seekTo");
+  seekToMethod(self(), position);
+}
+
+jboolean VideoCompositionFramesExtractor::getIsPlaying() const {
+  static const auto getIsPlayingMethod =
+      getClass()->getMethod<jboolean()>("getIsPlaying");
+  return getIsPlayingMethod(self());
+}
+
+jboolean VideoCompositionFramesExtractor::getIsLooping() const {
+  static const auto getIsLoopingMethod =
+      getClass()->getMethod<jboolean()>("getIsLooping");
+  return getIsLoopingMethod(self());
+}
+
+void VideoCompositionFramesExtractor::setIsLooping(jboolean isLooping) const {
+  static const auto setIsLoopingMethod =
+      getClass()->getMethod<void(jboolean)>("setIsLooping");
+  setIsLoopingMethod(self(), isLooping);
+}
+
+jlong VideoCompositionFramesExtractor::getCurrentPosition() const {
+  static const auto getCurrentPositionMethod =
+      getClass()->getMethod<jlong()>("getCurrentPosition");
+  return getCurrentPositionMethod(self());
+}
+
+jlong VideoCompositionFramesExtractor::getFramesVersion() const {
+  static const auto getFramesVersionMethod =
+      getClass()->getMethod<jlong()>("getFramesVersion");
+  return getFramesVersionMethod(self());
+}
+
+void VideoCompositionFramesExtractor::makeGLContextCurrent() const {
+  static const auto makeGLContextCurrentMethod =
+      getClass()->getMethod<void()>("makeGLContextCurrent");
+  makeGLContextCurrentMethod(self());
+}
+
+local_ref<JMap<JString, VideoFrame>>
+VideoCompositionFramesExtractor::decodeCompositionFrames() {
+  static const auto decodeCompositionFramesMethod =
+      getClass()->getMethod<JMap<JString, VideoFrame>()>(
+          "decodeCompositionFrames");
+  return decodeCompositionFramesMethod(self());
+}
+
+void VideoCompositionFramesExtractor::release() const {
+  static const auto releaseMethod = getClass()->getMethod<void()>("release");
+  releaseMethod(self());
+}
+
+} // namespace RNSkiaVideo

package/android/cpp/VideoCompositionFramesExtractor.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+#include "NativeEventDispatcher.h"
+#include "VideoComposition.h"
+#include "VideoFrame.h"
+
+namespace RNSkiaVideo {
+
+using namespace facebook;
+using namespace jni;
+
+struct VideoCompositionFramesExtractor
+    : public jni::JavaClass<VideoCompositionFramesExtractor> {
+
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/azzapp/rnskv/VideoCompositionFramesExtractor;";
+
+  local_ref<VideoCompositionFramesExtractor> static create(
+      alias_ref<VideoComposition> composition,
+      alias_ref<RNSkiaVideo::NativeEventDispatcher> dispatcher);
+
+  void prepare() const;
+
+  void play() const;
+
+  void pause() const;
+
+  void seekTo(jlong position) const;
+
+  jboolean getIsPlaying() const;
+
+  jlong getCurrentPosition() const;
+
+  jlong getFramesVersion() const;
+
+  jboolean getIsLooping() const;
+
+  void setIsLooping(jboolean isLooping) const;
+
+  local_ref<JMap<JString, VideoFrame>> decodeCompositionFrames();
+
+  void makeGLContextCurrent() const;
+  void release() const;
+};
+} // namespace RNSkiaVideo

package/android/cpp/VideoCompositionFramesExtractorHostObject.cpp

@@ -0,0 +1,230 @@
+#include "RNSVCheckedSizes.h"
+#include "VideoCompositionFramesExtractorHostObject.h"
+#include "ReturnedVideoFrames.h"
+#include "JNIHelpers.h"
+
+namespace RNSkiaVideo {
+
+VideoCompositionFramesExtractorHostObject::
+    VideoCompositionFramesExtractorHostObject(jsi::Runtime& runtime,
+                                              jsi::Object jsComposition)
+    : EventEmitter(runtime, JNIHelpers::getCallInvoker()) {}
+
+void VideoCompositionFramesExtractorHostObject::initialize(
+    jsi::Runtime& runtime, jsi::Object jsComposition) {
+  auto receiver = std::shared_ptr<JEventReceiver>(shared_from_this(), this);
+  jEventDispatcher = make_global(NativeEventDispatcher::create(receiver));
+  auto composition = VideoComposition::fromJSIObject(runtime, jsComposition);
+  player = make_global(
+      VideoCompositionFramesExtractor::create(composition, jEventDispatcher));
+}
+
+VideoCompositionFramesExtractorHostObject::
+    ~VideoCompositionFramesExtractorHostObject() {
+  this->release();
+}
+
+std::vector<jsi::PropNameID>
+VideoCompositionFramesExtractorHostObject::getPropertyNames(jsi::Runtime& rt) {
+  std::vector<jsi::PropNameID> result;
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("prepare")));
+  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("decodeCompositionFrames")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("on")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("dispose")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("currentTime")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("framesVersion")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("isLooping")));
+  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("isPlaying")));
+  return result;
+}
+
+// The methods are created once per runtime (see RNSVHostObject):
+// `decodeCompositionFrames` is read at every vsync of the UI runtime.
+jsi::Value VideoCompositionFramesExtractorHostObject::get(
+    jsi::Runtime& runtime, const jsi::PropNameID& propNameId) {
+  auto propName = propNameId.utf8(runtime);
+  if (propName == "prepare") {
+    return getFunction(
+        runtime, propName, 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          if (!released.test() && !prepared.test_and_set()) {
+            player->prepare();
+          }
+          return jsi::Value::undefined();
+        });
+  } else if (propName == "decodeCompositionFrames") {
+    return getFunction(
+        runtime, propName, 0,
+        [this](jsi::Runtime& runtime, const jsi::Value& thisValue,
+               const jsi::Value* arguments, size_t count) -> jsi::Value {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          if (released.test() || !prepared.test()) {
+            return jsi::Object(runtime);
+          }
+          auto frames = player->decodeCompositionFrames();
+          ReturnedVideoFrames returned(frames);
+          auto version = player->getFramesVersion();
+          bool hardware = false;
+          for (auto& entry : *frames) {
+            auto frame = entry.second;
+            if (frame->isHardwareBuffer()) { hardware = true; break; }
+          }
+          if (hardware) {
+            // A previous JS frame may already have been disposed after copying
+            // into its owned Skia image. New leases keep paused rewrapping valid.
+            auto result = jsi::Object(runtime);
+            for (auto& entry : *frames) {
+              auto frame = entry.second;
+              result.setProperty(runtime, entry.first->toStdString().c_str(), frame->toJS(runtime));
+            }
+            returned.close();
+            return result;
+          }
+          // The frames object is only rebuilt when the decoder produced a
+          // new frame. On a 120 Hz display most calls see the same frames as
+          // the previous one, and rewrapping them would be several JNI calls
+          // and JS allocations per item per vsync.
+          auto result = getVersionedObject(
+              runtime, "frames", (double)version,
+              [&](jsi::Object& result) {
+                for (auto& entry : *frames) {
+                  auto id = entry.first->toStdString();
+                  auto frame = entry.second;
+                  result.setProperty(runtime, id.c_str(), frame->toJS(runtime));
+                }
+              });
+          returned.close();
+          return result;
+        });
+  } 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 {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          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 {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          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 {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          if (!released.test()) {
+            if (count != 1) {
+              throw jsi::JSError(
+                  runtime,
+                  "VideoCompositionFramesExtractorHostObject."
+                  "seekTo(..) expects 1 arguments (number)!");
+            }
+            auto posSec = checkedMediaSeconds(arguments[0].asNumber());
+            player->seekTo((long)(posSec * 1000000));
+          }
+          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 {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          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();
+                });
+          }
+          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") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return {released.test() ? 0
+                            : (double)player->getCurrentPosition() / 1000000.0};
+  } else if (propName == "framesVersion") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return {released.test() || !prepared.test()
+                ? 0
+                : (double)player->getFramesVersion()};
+  } else if (propName == "isLooping") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return {!released.test() && player->getIsLooping()};
+  } else if (propName == "isPlaying") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return {!released.test() && player->getIsPlaying()};
+  }
+  return jsi::Value::undefined();
+}
+
+void VideoCompositionFramesExtractorHostObject::set(
+    facebook::jsi::Runtime& runtime,
+    const facebook::jsi::PropNameID& propNameId,
+    const facebook::jsi::Value& value) {
+  std::lock_guard<std::recursive_mutex> lock(playerMutex);
+  if (released.test()) {
+    return;
+  }
+  auto propName = propNameId.utf8(runtime);
+  if (propName == "isLooping") {
+    player->setIsLooping(value.asBool());
+  }
+}
+
+void VideoCompositionFramesExtractorHostObject::handleEvent(
+    std::string eventName, alias_ref<jobject> data) {
+  if (eventName == "error") {
+    auto message = static_ref_cast<JString>(data)->toStdString();
+    emit("error", [=](jsi::Runtime& runtime) -> jsi::Value {
+      auto dimensions = jsi::Object(runtime);
+      dimensions.setProperty(runtime, "message",
+                             jsi::String::createFromUtf8(runtime, message));
+      return dimensions;
+    });
+  } else {
+    emit(eventName);
+  }
+}
+
+void VideoCompositionFramesExtractorHostObject::release() {
+  std::lock_guard<std::recursive_mutex> lock(playerMutex);
+  if (!released.test_and_set()) {
+    if (jEventDispatcher) jEventDispatcher->invalidate();
+    removeAllListeners();
+    if (player) player->release();
+    player = nullptr;
+    jEventDispatcher = nullptr;
+  }
+}
+} // namespace RNSkiaVideo

package/android/cpp/VideoCompositionFramesExtractorHostObject.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <mutex>
+
+#include "NativeEventDispatcher.h"
+#include "RNSVHostObject.h"
+#include "VideoCompositionFramesExtractor.h"
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <map>
+
+using namespace facebook;
+
+namespace RNSkiaVideo {
+
+class JSI_EXPORT VideoCompositionFramesExtractorHostObject
+    : public RNSVHostObject,
+      EventEmitter,
+      JEventReceiver {
+public:
+  VideoCompositionFramesExtractorHostObject(jsi::Runtime& runtime, jsi::Object);
+  void initialize(jsi::Runtime& runtime, jsi::Object composition);
+  ~VideoCompositionFramesExtractorHostObject() override;
+  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 handleEvent(std::string eventName, alias_ref<jobject> data) override;
+
+private:
+  global_ref<NativeEventDispatcher> jEventDispatcher;
+  global_ref<VideoCompositionFramesExtractor> player;
+  std::atomic_flag prepared = ATOMIC_FLAG_INIT;
+  std::atomic_flag released = ATOMIC_FLAG_INIT;
+  // Held by every use of `player` and by release(): the UI thread draws
+  // while the JS thread disposes, and a use that passed the released check
+  // went on with a player release() had just reset.
+  std::recursive_mutex playerMutex;
+  void release();
+};
+
+} // namespace RNSkiaVideo