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

package/android/src/main/java/com/azzapp/rnskv/VideoPlayer.java

@@ -0,0 +1,361 @@
+package com.azzapp.rnskv;
+
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+import androidx.media3.common.MediaItem;
+import androidx.media3.common.PlaybackException;
+import androidx.media3.common.Player;
+import androidx.media3.common.VideoSize;
+import androidx.media3.common.PlaybackParameters;
+import androidx.media3.common.util.UnstableApi;
+import androidx.media3.exoplayer.ExoPlayer;
+
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGL10;
+
+/**
+ * A class that wraps ExoPlayer to play video, and extract frames from it using OpenGL
+ */
+@UnstableApi
+public class VideoPlayer {
+
+  private ExoPlayer player;
+
+  private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+  private boolean isInitialized = false;
+
+  private float volume = 1f;
+
+  private float playbackSpeed = 1f;
+
+  private long duration = 0L;
+
+  private long currentPosition = 0L;
+
+  private boolean isPlaying = false;
+
+  private Boolean isLooping = false;
+
+  private boolean isSeeking = false;
+
+  private EGLResourcesHolder eglResourcesHolder;
+
+  private GLFrameExtractor glFrameExtractor;
+
+  private int videoWidth;
+  private int videoHeight;
+
+  private final int outputWidth;
+  private final int outputHeight;
+
+  private volatile boolean released = false;
+
+  private final NativeEventDispatcher eventDispatcher;
+
+  /**
+   * Create a new VideoPlayer with the given URI
+   */
+  @UnstableApi
+  public VideoPlayer(String uriStr, int width, int height, NativeEventDispatcher eventDispatcher) {
+    this.eventDispatcher = eventDispatcher;
+    outputWidth = width;
+    outputHeight = height;
+    mainHandler.post(() -> {
+      if (released) {
+        return;
+      }
+      player = new ExoPlayer.Builder(ReactNativeSkiaVideoModule.currentReactApplicationContext()).build();
+
+      MediaItem mediaItem = new MediaItem.Builder().setUri(Uri.parse(uriStr)).build();
+      player.setMediaItem(mediaItem);
+
+      player.addListener(new Player.Listener() {
+        private boolean isBuffering = false;
+
+        public void setBuffering(boolean buffering) {
+          if (isBuffering != buffering) {
+            isBuffering = buffering;
+            dispatchEventIfNoReleased(isBuffering ? "bufferingStart" : "bufferingEnd", null);
+          }
+        }
+
+        @Override
+        public void onPlaybackStateChanged(final int playbackState) {
+          if (released) {
+            return;
+          }
+          if (playbackState == Player.STATE_BUFFERING) {
+            setBuffering(true);
+          } else if (playbackState == Player.STATE_READY) {
+            if (!isInitialized) {
+              isInitialized = true;
+              duration = player.getDuration();
+              VideoSize videoSize = player.getVideoSize();
+;
+              videoHeight = videoSize.height;
+              videoWidth = videoSize.width;
+              if (glFrameExtractor != null) {
+                player.setVideoSurface(glFrameExtractor.getSurface());
+              }
+              handleReady();
+            }
+            if (isSeeking) {
+              isSeeking = false;
+              dispatchEventIfNoReleased("seekComplete", null);
+            }
+          } else if (playbackState == Player.STATE_ENDED) {
+            dispatchEventIfNoReleased("complete", null);
+          }
+
+          if (playbackState != Player.STATE_BUFFERING) {
+            setBuffering(false);
+          }
+        }
+
+        @Override
+        public void onPlayerError(@NonNull final PlaybackException error) {
+          setBuffering(false);
+          if (error.errorCode == PlaybackException.ERROR_CODE_BEHIND_LIVE_WINDOW) {
+            // See https://exoplayer.dev/live-streaming.html#behindlivewindowexception-and-error_code_behind_live_window
+            player.seekToDefaultPosition();
+            player.prepare();
+          } else {
+            dispatchEventIfNoReleased("error", error.getMessage());
+          }
+        }
+
+        @Override
+        public void onIsPlayingChanged(boolean playing) {
+          isPlaying = playing;
+          dispatchEventIfNoReleased("playingStatusChange", playing);
+        }
+      });
+
+      player.prepare();
+
+      dispatchBufferingUpdate();
+    });
+  }
+
+  long previousBufferedPosition = 0;
+
+  private void handleReady() {
+    updateCurrentPosition();
+    dispatchEventIfNoReleased("ready", new int[]{videoWidth, videoHeight, 0});
+  }
+
+  private void dispatchBufferingUpdate() {
+    if (released || player == null) {
+      return;
+    }
+    long bufferedPosition = player.getBufferedPosition();
+    if (bufferedPosition != previousBufferedPosition) {
+      previousBufferedPosition = bufferedPosition;
+      dispatchEventIfNoReleased("bufferingUpdate", bufferedPosition);
+    }
+    mainHandler.postDelayed(this::dispatchBufferingUpdate, 500);
+  }
+
+  private void updateCurrentPosition() {
+    if (released || player == null) {
+      return;
+    }
+    this.currentPosition = player.getCurrentPosition();
+    mainHandler.postDelayed(this::updateCurrentPosition, 50);
+  }
+
+  /**
+   * Start playing the video
+   */
+  public void play() {
+    mainHandler.post(() -> { if (!released && player != null) player.play(); });
+  }
+
+  /**
+   * Pause the video
+   */
+  public void pause() {
+    mainHandler.post(() -> { if (!released && player != null) player.pause(); });
+  }
+
+  /**
+   * Seek to a specific location in the video
+   */
+  public void seekTo(long location) {
+    isSeeking = true;
+    mainHandler.post(() -> { if (!released && player != null) player.seekTo(location); });
+  }
+
+  public void setupGL() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      throw new RuntimeException("setupGL should be called on UI Thread");
+    }
+    if (released || eglResourcesHolder != null) {
+      return;
+    }
+    eglResourcesHolder = EGLResourcesHolder.createWithPBBufferSurface(EGL10.EGL_NO_CONTEXT);
+    eglResourcesHolder.runWithContextCurrent(() ->
+      glFrameExtractor = new GLFrameExtractor(false, NativeHardwareBuffer.isEnabled()));
+    if (player != null) {
+      player.setVideoSurface(glFrameExtractor.getSurface());
+    }
+  }
+
+  /**
+   * @return whether the video is playing
+   */
+  public boolean getIsPlaying() {
+    return isPlaying;
+  }
+
+  /**
+   * @return the current position in the video
+   */
+  public long getCurrentPosition() {
+    return currentPosition;
+  }
+
+  /**
+   * @return the duration of the video
+   */
+  public long getDuration() {
+    return duration;
+  }
+
+  /**
+   * @return the volume of the video between 0 and 1
+   */
+  public float getVolume() {
+    return volume;
+  }
+
+  /**
+   * Set the volume of the video
+   *
+   * @param value the volume to set between 0 and 1
+   */
+  public void setVolume(float value) {
+    volume = value;
+    mainHandler.post(() -> {
+      if (!released && player != null) player.setVolume(Math.max(0f, Math.min(1f, value)));
+    });
+  }
+
+  /**
+   * @return whether the video is looping
+   */
+  public boolean getIsLooping() {
+    return isLooping;
+  }
+
+  /**
+   * Set whether the video should loop
+   *
+   * @param value whether the video should loop
+   */
+  public void setIsLooping(boolean value) {
+    isLooping = value;
+    mainHandler.post(() -> {
+      if (!released && player != null) {
+        player.setRepeatMode(value ? Player.REPEAT_MODE_ALL : Player.REPEAT_MODE_OFF);
+      }
+    });
+  }
+
+  /**
+   * @return the playback speed of the video
+   */
+  public float getPlaybackSpeed() {
+    return playbackSpeed;
+  }
+
+  /**
+   * Set the playback speed of the video
+   *
+   * @param value the playback speed to set (must be greater than 0)
+   */
+  public void setPlaybackSpeed(float value) {
+    playbackSpeed = Math.max(0.1f, value); // Minimum speed of 0.1x
+    mainHandler.post(() -> {
+      if (!released && player != null) {
+        player.setPlaybackParameters(new PlaybackParameters(playbackSpeed, 1.0f));
+      }
+    });
+  }
+
+  /**
+   * Decode the next frame of the video
+   *
+   * @return whether the frame was decoded successfully
+   */
+  public VideoFrame decodeNextFrame() {
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      throw new RuntimeException("decodeNextFrame should be called on UI Thread");
+    }
+    if (eglResourcesHolder == null || glFrameExtractor == null) {
+      return null;
+    }
+    if (!glFrameExtractor.hasPendingFrame()) {
+      // Polled at every vsync, including while paused: skip the EGL context
+      // switch, the expensive part of this method, when nothing is new.
+      return null;
+    }
+    boolean downscale = outputWidth > 0 && outputHeight > 0;
+    int width = downscale ? outputWidth : videoWidth;
+    int height = downscale ? outputHeight : videoHeight;
+    if (width > 0 && height > 0) {
+      return eglResourcesHolder.withContextCurrent(() ->
+        glFrameExtractor.decodeNextFrame(width, height) ? glFrameExtractor.snapshotFrame(0) : null);
+    }
+    return null;
+  }
+
+  /**
+   * Release the video player and its resources
+   */
+  public void release() {
+    if (released) {
+      return;
+    }
+    released = true;
+    mainHandler.removeCallbacksAndMessages(null);
+    // The GL objects were created (setupGL) and are used (decodeNextFrame) on
+    // the main thread, with the extractor's EGL context current. dispose()
+    // reaches here from the JS thread, where no context is bound: GL deletes
+    // issued there are silently ignored and the textures, shared with the
+    // Skia context, leak. Tear everything down on the main thread instead,
+    // with the right context current, once the player stopped rendering into
+    // the surface.
+    mainHandler.post(() -> {
+      if (player != null) {
+        player.stop();
+        player.release();
+        player = null;
+      }
+      if (glFrameExtractor != null) {
+        GLFrameExtractor extractor = glFrameExtractor;
+        glFrameExtractor = null;
+        if (eglResourcesHolder != null) {
+          eglResourcesHolder.runWithContextCurrent(extractor::release);
+        } else {
+          extractor.release();
+        }
+      }
+      if (eglResourcesHolder != null) {
+        eglResourcesHolder.release();
+        eglResourcesHolder = null;
+      }
+    });
+  }
+
+  private void dispatchEventIfNoReleased(String eventName, Object value) {
+    if (released) {
+      return;
+    }
+    eventDispatcher.dispatchEvent(eventName, value);
+  }
+}

package/cpp/RNSVCheckedSizes.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+namespace RNSkiaVideo {
+
+inline size_t checkedStorageInteger(double value, const char* label) {
+  // The JS boundary must stay in the exactly representable integer range;
+  // comparing to SIZE_MAX as a double alone rounds that limit up on 64-bit.
+  if (!std::isfinite(value) || value < 0 || std::floor(value) != value ||
+      value > 9007199254740991.0 ||
+      (sizeof(size_t) < 8 && value > static_cast<double>(std::numeric_limits<size_t>::max()))) {
+    throw std::invalid_argument(std::string("Invalid ") + label);
+  }
+  return static_cast<size_t>(value);
+}
+
+inline int checkedPositiveInt(double value, const char* label) {
+  if (!std::isfinite(value) || value <= 0 || std::floor(value) != value ||
+      value > std::numeric_limits<int>::max()) {
+    throw std::invalid_argument(std::string("Invalid ") + label);
+  }
+  return static_cast<int>(value);
+}
+
+inline size_t checkedSizeProduct(size_t left, size_t right, const char* label) {
+  if (right && left > std::numeric_limits<size_t>::max() / right) {
+    throw std::invalid_argument(std::string("Invalid ") + label + ": size overflow");
+  }
+  return left * right;
+}
+
+inline size_t checkedPixelStorage(int width, int height, size_t rowBytes) {
+  if (width <= 0 || height <= 0 ||
+      rowBytes < checkedSizeProduct(static_cast<size_t>(width), 4, "pixel stride")) {
+    throw std::invalid_argument("Invalid pixel dimensions/stride");
+  }
+  return checkedSizeProduct(rowBytes, static_cast<size_t>(height), "pixel storage");
+}
+
+inline double checkedMediaSeconds(double seconds) {
+  // All native decode/encode boundaries use a nanosecond CMTime timescale.
+  if (!std::isfinite(seconds) || seconds < 0 ||
+      seconds >= static_cast<double>(std::numeric_limits<int64_t>::max()) / 1e9) {
+    throw std::invalid_argument("Invalid media seconds");
+  }
+  return seconds;
+}
+} // namespace RNSkiaVideo

package/cpp/RNSVEventEmitter.cpp

@@ -0,0 +1,199 @@
+#include "RNSVEventEmitter.h"
+#include "RNSVRuntimeLifecycleMonitor.h"
+
+#include <map>
+#include <mutex>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+namespace RNSkiaVideo {
+
+// Native producers and queued callbacks hold no HostObject pointer. JS handles
+// live in this state until they can be released on the owning JS thread.
+struct EventEmitter::State : RuntimeLifecycleListener {
+  using ListenerMap = std::map<std::string,
+      std::map<uint64_t, std::shared_ptr<jsi::Function>>>;
+  std::mutex mutex;
+  jsi::Runtime* runtime;
+  bool closed = false;
+  uint64_t nextId = 1;
+  uint64_t generation = 0;
+  ListenerMap listeners;
+  std::vector<ListenerMap> retiredListeners;
+  std::map<uint64_t, jsi::Value> payloads;
+
+  explicit State(jsi::Runtime& runtime) : runtime(&runtime) {}
+
+  void onRuntimeDestroyed(jsi::Runtime* destroyedRuntime) override {
+    ListenerMap releasedListeners;
+    std::vector<ListenerMap> releasedRetired;
+    std::map<uint64_t, jsi::Value> releasedPayloads;
+    {
+      std::lock_guard<std::mutex> lock(mutex);
+      if (runtime != destroyedRuntime) return;
+      closed = true;
+      ++generation;
+      releasedListeners = std::move(listeners);
+      releasedRetired = std::move(retiredListeners);
+      releasedPayloads = std::move(payloads);
+      runtime = nullptr;
+    }
+    // Releasing a JS handle can destroy a native HostObject which calls back
+    // into this state. Release handles outside its mutex to allow reentry.
+  }
+};
+
+EventEmitter::EventEmitter(jsi::Runtime& runtime,
+                           std::shared_ptr<react::CallInvoker> callInvoker)
+    : state(std::make_shared<State>(runtime)), callInvoker(std::move(callInvoker)) {
+  RuntimeLifecycleMonitor::addListener(runtime, state);
+}
+
+EventEmitter::~EventEmitter() {
+  retireListeners(true);
+}
+
+jsi::Function EventEmitter::on(std::string eventName, jsi::Function listener) {
+  std::lock_guard<std::mutex> lock(state->mutex);
+  if (!state->runtime || state->closed) {
+    throw std::runtime_error("Video event source is no longer alive");
+  }
+  const auto id = state->nextId++;
+  state->listeners[eventName].emplace(
+      id, std::make_shared<jsi::Function>(std::move(listener)));
+  std::weak_ptr<State> weakState = state;
+  return jsi::Function::createFromHostFunction(
+      *state->runtime, jsi::PropNameID::forAscii(*state->runtime, "dispose"), 0,
+      [weakState, eventName = std::move(eventName), id](
+          jsi::Runtime&, const jsi::Value&, const jsi::Value*, size_t) {
+        if (auto retained = weakState.lock()) {
+          std::shared_ptr<jsi::Function> released;
+          {
+            std::lock_guard<std::mutex> lock(retained->mutex);
+            auto entry = retained->listeners.find(eventName);
+            if (entry != retained->listeners.end()) {
+              auto found = entry->second.find(id);
+              if (found != entry->second.end()) {
+                released = std::move(found->second);
+                entry->second.erase(found);
+              }
+              if (entry->second.empty()) retained->listeners.erase(entry);
+            }
+          }
+        }
+        return jsi::Value::undefined();
+      });
+}
+
+void EventEmitter::emit(std::string eventName) {
+  emit(std::move(eventName), [](jsi::Runtime&) {
+    return jsi::Value::undefined();
+  });
+}
+
+void EventEmitter::emit(std::string eventName, jsi::Value data) {
+  uint64_t id;
+  {
+    std::lock_guard<std::mutex> lock(state->mutex);
+    if (state->closed || !state->runtime) return;
+    id = state->nextId++;
+    state->payloads.emplace(id, std::move(data));
+  }
+  enqueue(std::move(eventName), {}, id);
+}
+
+void EventEmitter::emit(std::string eventName,
+                        std::function<jsi::Value(jsi::Runtime&)> dataFactory) {
+  enqueue(std::move(eventName), std::move(dataFactory));
+}
+
+void EventEmitter::enqueue(
+    std::string eventName,
+    std::function<jsi::Value(jsi::Runtime&)> dataFactory, uint64_t payloadId) {
+  uint64_t generation;
+  {
+    std::lock_guard<std::mutex> lock(state->mutex);
+    if (state->closed || !state->runtime) return;
+    generation = state->generation;
+  }
+  std::weak_ptr<State> weakState = state;
+  callInvoker->invokeAsync([weakState, eventName = std::move(eventName),
+                            dataFactory = std::move(dataFactory), payloadId,
+                            generation]() {
+    auto retained = weakState.lock();
+    if (!retained) return;
+    jsi::Runtime* runtime;
+    std::vector<std::shared_ptr<jsi::Function>> listeners;
+    std::vector<State::ListenerMap> retiredListeners;
+    std::map<uint64_t, jsi::Value>::node_type stalePayload;
+    jsi::Value data;
+    {
+      std::lock_guard<std::mutex> lock(retained->mutex);
+      runtime = retained->runtime;
+      retiredListeners = std::move(retained->retiredListeners);
+      if (!runtime || retained->closed || retained->generation != generation) {
+        stalePayload = retained->payloads.extract(payloadId);
+        return;
+      }
+      auto entry = retained->listeners.find(eventName);
+      if (entry != retained->listeners.end()) {
+        for (const auto& listener : entry->second) listeners.push_back(listener.second);
+      }
+      if (payloadId) {
+        auto payload = retained->payloads.find(payloadId);
+        if (payload != retained->payloads.end()) {
+          data = std::move(payload->second);
+          retained->payloads.erase(payload);
+        }
+      }
+    }
+    // Listener calls may unsubscribe or dispose the source; never hold the
+    // state mutex across JS execution. Factories only run on the JS thread.
+    if (listeners.empty()) return;
+    if (dataFactory) data = dataFactory(*runtime);
+    for (const auto& listener : listeners) {
+      {
+        std::lock_guard<std::mutex> lock(retained->mutex);
+        if (retained->closed || retained->generation != generation) break;
+      }
+      listener->call(*runtime, data);
+    }
+  });
+}
+
+jsi::Runtime* EventEmitter::getRuntime() {
+  std::lock_guard<std::mutex> lock(state->mutex);
+  return state->closed ? nullptr : state->runtime;
+}
+
+void EventEmitter::retireListeners(bool close) {
+  auto retained = state;
+  {
+    std::lock_guard<std::mutex> lock(retained->mutex);
+    if (!retained->runtime) return;
+    retained->closed |= close;
+    ++retained->generation;
+    if (!retained->listeners.empty()) {
+      retained->retiredListeners.push_back(std::move(retained->listeners));
+      retained->listeners.clear();
+    }
+  }
+  // A queued cleanup retains the state, not the HostObject. Runtime teardown
+  // also clears it, so a dropped callback cannot leave dangling JS handles.
+  callInvoker->invokeAsync([retained]() {
+    std::vector<State::ListenerMap> listeners;
+    std::map<uint64_t, jsi::Value> payloads;
+    {
+      std::lock_guard<std::mutex> lock(retained->mutex);
+      listeners = std::move(retained->retiredListeners);
+      if (retained->closed) payloads = std::move(retained->payloads);
+    }
+  });
+}
+
+void EventEmitter::removeAllListeners() {
+  retireListeners(false);
+}
+
+} // namespace RNSkiaVideo

package/cpp/RNSVEventEmitter.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace RNSkiaVideo {
+using namespace facebook;
+class EventEmitter {
+public:
+  EventEmitter(jsi::Runtime& runtime,
+               std::shared_ptr<react::CallInvoker> callInvoker);
+  ~EventEmitter();
+  jsi::Function on(std::string eventName, jsi::Function listener);
+  void emit(std::string eventName);
+  void emit(std::string eventName, jsi::Value data);
+  void emit(std::string eventName,
+            std::function<jsi::Value(jsi::Runtime&)> dataFactory);
+  void removeAllListeners();
+  jsi::Runtime* getRuntime();
+
+private:
+  struct State;
+  std::shared_ptr<State> state;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  void enqueue(std::string eventName,
+               std::function<jsi::Value(jsi::Runtime&)> dataFactory,
+               uint64_t payloadId = 0);
+  void retireListeners(bool close);
+};
+} // namespace RNSkiaVideo