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

package/android/cpp/VideoPlayerHostObject.cpp

@@ -0,0 +1,225 @@
+#include "RNSVCheckedSizes.h"
+#include "VideoPlayerHostObject.h"
+#include "JNIHelpers.h"
+
+namespace RNSkiaVideo {
+VideoPlayerHostObject::VideoPlayerHostObject(jsi::Runtime& runtime,
+                                             const std::string& uri, int width,
+                                             int height)
+    : EventEmitter(runtime, JNIHelpers::getCallInvoker()) {}
+
+void VideoPlayerHostObject::initialize(const std::string& uri, int width, int height) {
+  auto receiver = std::shared_ptr<JEventReceiver>(shared_from_this(), this);
+  jEventDispatcher = make_global(NativeEventDispatcher::create(receiver));
+  player =
+      make_global(VideoPlayer::create(uri, width, height, jEventDispatcher));
+}
+
+VideoPlayerHostObject::~VideoPlayerHostObject() {
+  this->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) {
+  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 {
+          std::lock_guard<std::recursive_mutex> lock(playerMutex);
+          if (released.test()) {
+            return jsi::Value::null();
+          }
+
+          if (!glPrepared) {
+            player->setupGL();
+            glPrepared = true;
+          }
+          auto frame = player->decodeNextFrame();
+          if (!frame) return jsi::Value::null();
+          return frame->toJS(runtime);
+        });
+  } 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()) {
+            return jsi::Value::undefined();
+          }
+          if (count < 1 || !arguments[0].isNumber())
+            throw jsi::JSError(runtime, "seekTo expects media seconds");
+          auto time = checkedMediaSeconds(arguments[0].asNumber());
+          player->seekTo(time * 1000);
+          return jsi::Value::undefined();
+        });
+  } else if (propName == "currentTime") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return jsi::Value(
+        released.test() ? 0 : (double)player->getCurrentPosition() / 1000.0);
+  } else if (propName == "duration") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return jsi::Value(released.test() ? 0
+                                      : (double)player->getDuration() / 1000.0);
+  } else if (propName == "volume") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return jsi::Value(released.test() ? 0 : (double)player->getVolume());
+  } else if (propName == "playbackSpeed") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return jsi::Value(released.test() ? 1 : (double)player->getPlaybackSpeed());
+  } else if (propName == "isLooping") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return jsi::Value(!(released.test()) && player->getIsLooping());
+  } else if (propName == "isPlaying") {
+    std::lock_guard<std::recursive_mutex> lock(playerMutex);
+    return jsi::Value(!(released.test()) && player->getIsPlaying());
+  } 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();
+        });
+  }
+  return jsi::Value::undefined();
+}
+
+void VideoPlayerHostObject::set(facebook::jsi::Runtime& runtime,
+                                const facebook::jsi::PropNameID& propNameId,
+                                const facebook::jsi::Value& value) {
+  auto propName = propNameId.utf8(runtime);
+  std::lock_guard<std::recursive_mutex> lock(playerMutex);
+  if (released.test()) {
+    return;
+  }
+  if (propName == "volume") {
+    player->setVolume(value.asNumber());
+  } else if (propName == "playbackSpeed") {
+    player->setPlaybackSpeed(value.asNumber());
+  } else if (propName == "isLooping") {
+    player->setIsLooping(value.asBool());
+  }
+}
+
+void VideoPlayerHostObject::handleEvent(std::string eventName,
+                                        alias_ref<jobject> data) {
+  if (eventName == "ready") {
+    auto dimensions = static_ref_cast<JArrayInt>(data)->getRegion(0, 3);
+    int width = dimensions[0];
+    int height = dimensions[1];
+    int rotation = dimensions[2];
+    emit("ready", [=](jsi::Runtime& runtime) -> jsi::Value {
+      auto dimensions = jsi::Object(runtime);
+      dimensions.setProperty(runtime, "width", jsi::Value(width));
+      dimensions.setProperty(runtime, "height", jsi::Value(height));
+      dimensions.setProperty(runtime, "rotation", jsi::Value(rotation));
+      return dimensions;
+    });
+  } else 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 if (eventName == "bufferingUpdate") {
+    auto bufferedDuration = (double)static_ref_cast<JLong>(data)->value();
+    emit("bufferingUpdate", [=](jsi::Runtime& runtime) -> jsi::Value {
+      auto range = jsi::Object(runtime);
+      range.setProperty(runtime, "start", jsi::Value(0));
+      range.setProperty(runtime, "duration",
+                        jsi::Value(bufferedDuration / 1000));
+      auto ranges = jsi::Array(runtime, 1);
+      ranges.setValueAtIndex(runtime, 0, range);
+      return ranges;
+    });
+  } else if (eventName == "playingStatusChange") {
+    bool playing = static_ref_cast<JBoolean>(data)->value();
+    __android_log_print(ANDROID_LOG_INFO, "VideoPlayer",
+                        "playingStatusChange %d", playing);
+    emit("playingStatusChange",
+         [=](jsi::Runtime&) { return jsi::Value(playing); });
+  } else {
+    emit(eventName);
+  }
+}
+
+void VideoPlayerHostObject::release() {
+  std::lock_guard<std::recursive_mutex> lock(playerMutex);
+  if (!released.test_and_set()) {
+    if (jEventDispatcher) jEventDispatcher->invalidate();
+    if (player) player->release();
+    player = nullptr;
+    this->removeAllListeners();
+    jEventDispatcher = nullptr;
+  }
+}
+} // namespace RNSkiaVideo

package/android/cpp/VideoPlayerHostObject.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <mutex>
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <map>
+
+#include "RNSVEventEmitter.h"
+#include "RNSVHostObject.h"
+#include "VideoPlayer.h"
+
+using namespace facebook;
+
+namespace RNSkiaVideo {
+
+class JSI_EXPORT VideoPlayerHostObject : public RNSVHostObject,
+                                         JEventReceiver,
+                                         EventEmitter {
+public:
+  VideoPlayerHostObject(jsi::Runtime& runtime, const std::string& uri,
+                        int width, int height);
+  void initialize(const std::string& uri, int width, int height);
+  ~VideoPlayerHostObject();
+  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;
+  jni::global_ref<VideoPlayer> player;
+  bool glPrepared = false;
+  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

package/android/cpp/cpp-adapter.cpp

@@ -0,0 +1,316 @@
+#include "RNSVCheckedSizes.h"
+#include "NativeEventDispatcher.h"
+#include "NativeRgbaBuffer.h"
+#include "NativeHardwareBuffer.h"
+#include "RNSVMemoryBudget.h"
+#include "VideoCapabilities.h"
+#include "VideoCompositionFramesExtractorHostObject.h"
+#include "VideoCompositionFramesExtractorSyncHostObject.h"
+#include "VideoEncoderHostObject.h"
+#include "VideoPlayerHostObject.h"
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+
+using namespace facebook;
+using namespace RNSkiaVideo;
+
+void install(jsi::Runtime& jsiRuntime) {
+
+  auto RNSVModule = jsi::Object(jsiRuntime);
+  MemoryBudget::install(jsiRuntime, RNSVModule);
+  RNSVModule.setProperty(jsiRuntime, "configureNativeBufferInterop",
+    jsi::Function::createFromHostFunction(jsiRuntime,
+      jsi::PropNameID::forAscii(jsiRuntime, "configureNativeBufferInterop"), 1,
+      [](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* args, size_t count) -> jsi::Value {
+        if (count != 1 || !args[0].isBool())
+          throw jsi::JSError(runtime, "configureNativeBufferInterop requires a boolean");
+        try { NativeHardwareBuffer::configure(args[0].getBool()); }
+        catch (const std::exception& error) { throw jsi::JSError(runtime, error.what()); }
+        return jsi::Value::undefined();
+      }));
+  RNSVModule.setProperty(jsiRuntime, "getBackendInfo",
+    jsi::Function::createFromHostFunction(jsiRuntime,
+      jsi::PropNameID::forAscii(jsiRuntime, "getBackendInfo"), 0,
+      [](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value*, size_t) -> jsi::Value {
+        auto info = jsi::Object(runtime);
+        info.setProperty(runtime, "platform", jsi::String::createFromAscii(runtime, "android"));
+        const bool hardware = NativeHardwareBuffer::isEnabled();
+        info.setProperty(runtime, "decodeTransport", jsi::String::createFromAscii(runtime,
+            hardware ? "ahardwarebuffer-rgba-egl" : "cpu-rgba-readback"));
+        // Export renders into encoder-lent AHardwareBuffers, sampled by the
+        // encoder's EGL context; CPU readback stays the fallback.
+        info.setProperty(runtime, "encodeTransport", jsi::String::createFromAscii(runtime,
+            hardware ? "ahardwarebuffer-egl-sample" : "cpu-rgba-upload"));
+        info.setProperty(runtime, "exportFallback", jsi::String::createFromAscii(runtime, "cpu-rgba-upload"));
+        info.setProperty(runtime, "gpuDirectExport", hardware);
+        info.setProperty(runtime, "decodeCpuCopiesBeforeSkia", hardware ? 0 : 1);
+        info.setProperty(runtime, "cpuReadbackDecode", !hardware);
+        info.setProperty(runtime, "ownedFrameTransport", jsi::String::createFromAscii(runtime,
+            hardware ? "immutable-ahardwarebuffer-shared-leases" : "direct-buffer-java-scoped-copy"));
+        info.setProperty(runtime, "skiaImportTransport", jsi::String::createFromAscii(runtime,
+            hardware ? "native-buffer-webgpu-blit-snapshot" : "cpu-rgba-scoped-copy-webgpu-upload-snapshot"));
+        info.setProperty(runtime, "zeroCopyDecode", false);
+        info.setProperty(runtime, "zeroCopyEncode", false);
+        return info;
+      }));
+  auto createVideoPlayer = jsi::Function::createFromHostFunction(
+      jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "createVideoPlayer"), 2,
+      [](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)!");
+        }
+
+        int width = -1;
+        int height = -1;
+        if (count >= 2 && arguments[1].isObject()) {
+          auto res = arguments[1].asObject(runtime);
+          width = checkedPositiveInt(res.getProperty(runtime, "width").asNumber(), "decode width");
+          height = checkedPositiveInt(res.getProperty(runtime, "height").asNumber(), "decode height");
+        }
+        auto instance = std::make_shared<VideoPlayerHostObject>(
+            runtime, arguments[0].asString(runtime).utf8(runtime), width,
+            height);
+        instance->initialize(arguments[0].asString(runtime).utf8(runtime), width, height);
+
+        return jsi::Object::createFromHostObject(runtime, instance);
+      });
+
+  RNSVModule.setProperty(jsiRuntime, "createVideoPlayer",
+                         std::move(createVideoPlayer));
+
+  auto createVideoCompositionFramesExtractor =
+      jsi::Function::createFromHostFunction(
+          jsiRuntime,
+          jsi::PropNameID::forAscii(jsiRuntime,
+                                    "createVideoCompositionFramesExtractor"),
+          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,
+                                 "SkiaVideo.createRNSVCompositionPlayer(.."
+                                 ") expects one arguments (object)!");
+            }
+
+            auto instance =
+                std::make_shared<VideoCompositionFramesExtractorHostObject>(
+                    runtime, arguments[0].asObject(runtime));
+            instance->initialize(runtime, arguments[0].asObject(runtime));
+
+            return jsi::Object::createFromHostObject(runtime, instance);
+          });
+  RNSVModule.setProperty(jsiRuntime, "createVideoCompositionFramesExtractor",
+                         std::move(createVideoCompositionFramesExtractor));
+
+  auto createVideoCompositionFramesExtractorSync =
+      jsi::Function::createFromHostFunction(
+          jsiRuntime,
+          jsi::PropNameID::forAscii(
+              jsiRuntime, "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,
+                                 "createVideoCompositionFramesExtractorSync(.."
+                                 ") expects one arguments (object)!");
+            }
+
+            auto instance =
+                std::make_shared<VideoCompositionFramesExtractorSyncHostObject>(
+                    runtime, arguments[0].asObject(runtime));
+            return jsi::Object::createFromHostObject(runtime, instance);
+          });
+
+  RNSVModule.setProperty(jsiRuntime,
+                         "createVideoCompositionFramesExtractorSync",
+                         std::move(createVideoCompositionFramesExtractorSync));
+
+  auto createVideoEncoder = jsi::Function::createFromHostFunction(
+      jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "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 one arguments (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::optional<std::string> encoderName = std::nullopt;
+        if (options.hasProperty(runtime, "encoderName")) {
+          auto value = options.getProperty(runtime, "encoderName");
+          if (value.isString()) {
+            encoderName = value.asString(runtime).utf8(runtime);
+          }
+        }
+        std::optional<std::string> codec = std::nullopt;
+        if (options.hasProperty(runtime, "codec")) {
+          auto value = options.getProperty(runtime, "codec");
+          if (value.isString()) {
+            codec = value.asString(runtime).utf8(runtime);
+          }
+        }
+        int audioSampleRate = 44100;
+        int audioChannelCount = 2;
+        int audioBitRate = 128000;
+        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");
+          }
+        }
+        if (options.hasProperty(runtime, "audioBitRate")) {
+          auto value = options.getProperty(runtime, "audioBitRate");
+          if (value.isNumber()) {
+            audioBitRate = checkedPositiveInt(value.asNumber(), "audio bitrate");
+          }
+        }
+
+        local_ref<VideoComposition> composition = nullptr;
+        if (count >= 2 && arguments[1].isObject()) {
+          auto jsComposition = arguments[1].asObject(runtime);
+          composition = VideoComposition::fromJSIObject(runtime, jsComposition);
+        }
+
+        auto instance = std::make_shared<VideoEncoderHostObject>(
+            outPath, width, height, frameRate, bitRate, encoderName, codec,
+            composition, audioSampleRate, audioChannelCount, audioBitRate);
+        return jsi::Object::createFromHostObject(runtime, instance);
+      });
+  RNSVModule.setProperty(jsiRuntime, "createVideoEncoder",
+                         std::move(createVideoEncoder));
+
+  auto isEncodingSupported = jsi::Function::createFromHostFunction(
+      jsiRuntime, jsi::PropNameID::forAscii(jsiRuntime, "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(VideoEncoder::isCodecSupported(codec));
+      });
+  RNSVModule.setProperty(jsiRuntime, "isEncodingSupported",
+                         std::move(isEncodingSupported));
+
+  auto getDecodingCapabilitiesFor = jsi::Function::createFromHostFunction(
+      jsiRuntime,
+      jsi::PropNameID::forAscii(jsiRuntime, "getDecodingCapabilitiesFor"), 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, "getDecodingCapabilitiesFor expects a MIME type");
+        auto mimetype = arguments[0].asString(runtime).utf8(runtime);
+
+        auto decoderInfo =
+            VideoCapabilities::getDecodingCapabilitiesFor(mimetype);
+        if (decoderInfo == nullptr) {
+          return jsi::Value::null();
+        }
+        auto result = jsi::Object(runtime);
+        result.setProperty(runtime, "maxInstances",
+                           jsi::Value(decoderInfo->getMaxInstances()));
+        result.setProperty(runtime, "maxWidth",
+                           jsi::Value(decoderInfo->getMaxWidth()));
+        result.setProperty(runtime, "maxHeight",
+                           jsi::Value(decoderInfo->getMaxHeight()));
+
+        return result;
+      });
+
+  RNSVModule.setProperty(jsiRuntime, "getDecodingCapabilitiesFor",
+                         std::move(getDecodingCapabilitiesFor));
+
+  auto getValidEncoderConfigurations = jsi::Function::createFromHostFunction(
+      jsiRuntime,
+      jsi::PropNameID::forAscii(jsiRuntime, "getValidEncoderConfigurations"),
+      4,
+      [](jsi::Runtime& runtime, const jsi::Value& thisValue,
+         const jsi::Value* arguments, size_t count) -> jsi::Value {
+        if (count < 4) throw jsi::JSError(runtime, "getValidEncoderConfigurations expects dimensions, frame rate and bitrate");
+        int width = checkedPositiveInt(arguments[0].asNumber(), "encoder width");
+        int height = checkedPositiveInt(arguments[1].asNumber(), "encoder height");
+        int framerate = checkedPositiveInt(arguments[2].asNumber(), "encoder frame rate");
+        int bitrate = checkedPositiveInt(arguments[3].asNumber(), "encoder bitrate");
+
+        std::optional<std::string> codec = std::nullopt;
+        if (count > 4 && arguments[4].isString()) {
+          codec = arguments[4].asString(runtime).utf8(runtime);
+        }
+
+        auto encoderInfos = VideoCapabilities::getValidEncoderConfigurations(
+            width, height, framerate, bitrate, codec);
+
+        if (encoderInfos == nullptr) {
+          return jsi::Value::null();
+        }
+        auto result = jsi::Array(runtime, encoderInfos->size());
+        size_t i = 0;
+        for (const auto& encoderInfo : *encoderInfos) {
+          auto jsObject = jsi::Object(runtime);
+          jsObject.setProperty(runtime, "encoderName",
+                               jsi::String::createFromUtf8(
+                                   runtime, encoderInfo->getEncoderName()));
+          jsObject.setProperty(
+              runtime, "hardwareAccelerated",
+              jsi::Value(encoderInfo->getHardwareAccelerated()));
+          jsObject.setProperty(runtime, "width",
+                               jsi::Value(encoderInfo->getWidth()));
+          jsObject.setProperty(runtime, "height",
+                               jsi::Value(encoderInfo->getHeight()));
+          jsObject.setProperty(runtime, "frameRate",
+                               jsi::Value(encoderInfo->getFrameRate()));
+          jsObject.setProperty(runtime, "bitRate",
+                               jsi::Value(encoderInfo->getBitrate()));
+
+          result.setValueAtIndex(runtime, i, jsObject);
+          i++;
+        }
+        return result;
+      });
+
+  RNSVModule.setProperty(jsiRuntime, "getValidEncoderConfigurations",
+                         std::move(getValidEncoderConfigurations));
+
+  jsiRuntime.global().setProperty(jsiRuntime, "RNSkiaVideo",
+                                  std::move(RNSVModule));
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_azzapp_rnskv_ReactNativeSkiaVideoModule_nativeInstall(JNIEnv* env,
+                                                               jobject clazz,
+                                                               jlong jsiPtr) {
+  auto runtime = reinterpret_cast<jsi::Runtime*>(jsiPtr);
+  if (runtime) {
+    install(*runtime);
+  }
+}
+
+jint JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(
+      vm, [] { NativeEventDispatcher::registerNatives(); NativeRgbaBuffer::registerNatives();
+        NativeHardwareBuffer::registerNatives(); });
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+ReactNativeSkiaVideo_kotlinVersion=2.1.20
+ReactNativeSkiaVideo_minSdkVersion=28
+ReactNativeSkiaVideo_targetSdkVersion=36
+ReactNativeSkiaVideo_compileSdkVersion=36
+ReactNativeSkiaVideo_ndkVersion=27.1.12297006