react-native-alpha-video-gpu 0.0.0-stage → 1.0.0

package/react-native/android/src/main/java/dev/mediacache/alphavideo/gpu/reactnative/AlphaVideoGpuViewManager.java

@@ -0,0 +1,187 @@
+package dev.mediacache.alphavideo.gpu.reactnative;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import dev.mediacache.alphavideo.gpu.AlphaVideoGpuView;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/** React Native view manager for {@link AlphaVideoGpuView}. */
+public class AlphaVideoGpuViewManager extends AlphaVideoGpuViewManagerSpec<AlphaVideoGpuView> {
+
+    public static final String REACT_CLASS = "AlphaVideoGpuView";
+
+    @Override
+    @NonNull
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    @NonNull
+    protected AlphaVideoGpuView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        AlphaVideoGpuView view = new AlphaVideoGpuView(reactContext);
+        view.setPlayerCallback(new PlayerEventForwarder(view));
+        return view;
+    }
+
+    @ReactProp(name = "source")
+    @Override
+    public void setSource(AlphaVideoGpuView view, @Nullable ReadableMap source) {
+        String sourceUri = null;
+        if (source != null && source.hasKey("uri") && !source.isNull("uri")) {
+            sourceUri = source.getString("uri");
+        }
+
+        // Adopt a cacheKey carried inside the source map before touching the source:
+        // setSource() starts the read that uses the key, and React gives no
+        // ordering guarantee between this setter and the standalone `cacheKey` one, so
+        // relying on that prop alone can store under the URL instead.
+        if (source != null && source.hasKey("cacheKey") && !source.isNull("cacheKey")) {
+            String sourceCacheKey = source.getString("cacheKey");
+            if (sourceCacheKey != null && !sourceCacheKey.isEmpty()) {
+                view.setCacheKey(sourceCacheKey);
+            }
+        }
+
+        Map<String, String> headers = new LinkedHashMap<>();
+        if (source != null && source.hasKey("headers") && !source.isNull("headers")) {
+            ReadableArray flat = source.getArray("headers");
+            for (int i = 0; flat != null && i + 1 < flat.size(); i += 2) {
+                headers.put(flat.getString(i), flat.getString(i + 1));
+            }
+        }
+        view.setHeaders(headers);
+        view.setDataSource(source != null && source.hasKey("dataSource") && !source.isNull("dataSource")
+            ? source.getString("dataSource") : null);
+        view.setSource(sourceUri == null || sourceUri.isEmpty() ? null : sourceUri);
+    }
+
+    @ReactProp(name = "autoPlay", defaultBoolean = true)
+    @Override
+    public void setAutoPlay(AlphaVideoGpuView view, boolean autoPlay) {
+        view.setAutoPlay(autoPlay);
+    }
+
+    @ReactProp(name = "loop", defaultBoolean = true)
+    @Override
+    public void setLoop(AlphaVideoGpuView view, boolean loop) {
+        view.setLoop(loop);
+    }
+
+    @ReactProp(name = "playbackSpeed", defaultFloat = 1.0f)
+    @Override
+    public void setPlaybackSpeed(AlphaVideoGpuView view, float speed) {
+        view.setPlaybackSpeed(speed);
+    }
+    
+    @ReactProp(name = "cacheKey")
+    @Override
+    public void setCacheKey(AlphaVideoGpuView view, @Nullable String cacheKey) {
+        // Pass cacheKey directly to the View so it can use it for downloads
+        view.setCacheKey(cacheKey);
+    }
+    
+    /** "auto" (default), "disk", "memory" or "none"; see AlphaVideoGpuView.setStorage. */
+    @ReactProp(name = "storage")
+    @Override
+    public void setStorage(AlphaVideoGpuView view, @Nullable String storage) {
+        view.setStorage(storage);
+    }
+
+    /** 0 for the default, 512 MB. */
+    @ReactProp(name = "maxStorageBytes", defaultDouble = 0)
+    @Override
+    public void setMaxStorageBytes(AlphaVideoGpuView view, double maxStorageBytes) {
+        view.setMaxStorageBytes((long) maxStorageBytes);
+    }
+
+    @ReactProp(name = "enableFrameEvents", defaultBoolean = false)
+    @Override
+    public void setEnableFrameEvents(AlphaVideoGpuView view, boolean enable) {
+        view.setEnableFrameEvents(enable);
+    }
+    
+    @ReactProp(name = "paused", defaultBoolean = false)
+    @Override
+    public void setPaused(AlphaVideoGpuView view, boolean paused) {
+        view.setPaused(paused);
+    }
+    
+    @ReactProp(name = "streamingPrefetchAhead", defaultInt = 8)
+    @Override
+    public void setStreamingPrefetchAhead(AlphaVideoGpuView view, int frames) {
+        view.setStreamingPrefetchAhead(frames);
+    }
+    
+    /**
+     * Memory strategy for frame storage.
+     * - "vram" (default): Store frames in GPU VRAM. Best for many simultaneous players.
+     * - "ram": Store decoded frames in RAM, upload per-frame. Lower VRAM usage.
+     */
+    @ReactProp(name = "memoryStrategy")
+    @Override
+    public void setMemoryStrategy(AlphaVideoGpuView view, @Nullable String strategy) {
+        view.setMemoryStrategy(strategy != null ? strategy : "vram");
+    }
+    
+    /**
+     * Enable streaming mode for texture array playback.
+     * When true (default): Use streaming decompression with ring buffer (constant memory usage).
+     * When false: Load all frames at once.
+     */
+    @ReactProp(name = "stream", defaultBoolean = true)
+    @Override
+    public void setStream(AlphaVideoGpuView view, boolean stream) {
+        view.setStream(stream);
+    }
+    
+    @ReactProp(name = "verbose", defaultBoolean = false)
+    @Override
+    public void setVerbose(AlphaVideoGpuView view, boolean verbose) {
+        view.setVerbose(verbose);
+    }
+
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return PlayerEventForwarder.exportedEvents();
+    }
+
+    @Override
+    public void play(AlphaVideoGpuView view) {
+        view.play();
+    }
+
+    @Override
+    public void pause(AlphaVideoGpuView view) {
+        view.pause();
+    }
+
+    @Override
+    public void stop(AlphaVideoGpuView view) {
+        view.stop();
+    }
+
+    @Override
+    public void seekToFrame(AlphaVideoGpuView view, int frame) {
+        view.seekToFrame(frame);
+    }
+
+    @Override
+    public void seekToTime(AlphaVideoGpuView view, double seconds) {
+        view.seekToTime(seconds);
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull AlphaVideoGpuView view) {
+        super.onDropViewInstance(view);
+        view.destroy();
+    }
+}

package/react-native/android/src/main/java/dev/mediacache/alphavideo/gpu/reactnative/PlayerEventForwarder.java

@@ -0,0 +1,107 @@
+package dev.mediacache.alphavideo.gpu.reactnative;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+
+import dev.mediacache.alphavideo.gpu.AlphaVideoGpuView;
+
+import java.util.Map;
+
+/** Turns a player view's callbacks into React events on that view. */
+final class PlayerEventForwarder implements AlphaVideoGpuView.PlayerCallback {
+
+    static Map<String, Object> exportedEvents() {
+        return MapBuilder.<String, Object>builder()
+            .put("onLoad", MapBuilder.of("registrationName", "onLoad"))
+            .put("onFrameUpdate", MapBuilder.of("registrationName", "onFrameUpdate"))
+            .put("onStateChange", MapBuilder.of("registrationName", "onStateChange"))
+            .put("onFinished", MapBuilder.of("registrationName", "onFinished"))
+            .put("onError", MapBuilder.of("registrationName", "onError"))
+            .build();
+    }
+
+    private final View view;
+
+    PlayerEventForwarder(View view) {
+        this.view = view;
+    }
+
+    @Override
+    public void onLoad(int width, int height, int frameCount, double frameRate) {
+        WritableMap event = Arguments.createMap();
+        event.putInt("width", width);
+        event.putInt("height", height);
+        event.putInt("frameCount", frameCount);
+        event.putDouble("frameRate", frameRate);
+        event.putDouble("duration", frameCount > 0 && frameRate > 0 ? frameCount / frameRate : 0);
+        send("onLoad", event);
+    }
+
+    @Override
+    public void onFrameUpdate(int frame, int totalFrames) {
+        WritableMap event = Arguments.createMap();
+        event.putInt("frame", frame);
+        event.putInt("totalFrames", totalFrames);
+        send("onFrameUpdate", event);
+    }
+
+    @Override
+    public void onStateChange(String state) {
+        WritableMap event = Arguments.createMap();
+        event.putString("state", state);
+        send("onStateChange", event);
+    }
+
+    @Override
+    public void onFinished() {
+        send("onFinished", Arguments.createMap());
+    }
+
+    @Override
+    public void onError(String error, @Nullable String code) {
+        WritableMap event = Arguments.createMap();
+        event.putString("error", error);
+        if (code != null) event.putString("code", code);
+        send("onError", event);
+    }
+
+    private void send(String eventName, WritableMap params) {
+        ReactContext context = (ReactContext) view.getContext();
+        EventDispatcher dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.getId());
+        if (dispatcher == null) return;
+        dispatcher.dispatchEvent(new PlayerEvent(UIManagerHelper.getSurfaceId(view), view.getId(), eventName, params));
+    }
+
+    private static final class PlayerEvent extends Event<PlayerEvent> {
+        private final String eventName;
+        private final WritableMap eventData;
+
+        PlayerEvent(int surfaceId, int viewTag, String eventName, WritableMap eventData) {
+            super(surfaceId, viewTag);
+            this.eventName = eventName;
+            this.eventData = eventData;
+        }
+
+        @NonNull
+        @Override
+        public String getEventName() {
+            return eventName;
+        }
+
+        @Nullable
+        @Override
+        protected WritableMap getEventData() {
+            return eventData;
+        }
+    }
+}

package/react-native/android/src/newarch/java/dev/mediacache/alphavideo/gpu/reactnative/AlphaVideoGpuViewManagerSpec.java

@@ -0,0 +1,23 @@
+package dev.mediacache.alphavideo.gpu.reactnative;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.AlphaVideoGpuViewManagerDelegate;
+import com.facebook.react.viewmanagers.AlphaVideoGpuViewManagerInterface;
+
+/** New architecture: props and commands arrive through the delegate generated from the codegen spec. */
+public abstract class AlphaVideoGpuViewManagerSpec<T extends View> extends SimpleViewManager<T>
+        implements AlphaVideoGpuViewManagerInterface<T> {
+
+    private final ViewManagerDelegate<T> delegate = new AlphaVideoGpuViewManagerDelegate<>(this);
+
+    @Nullable
+    @Override
+    protected ViewManagerDelegate<T> getDelegate() {
+        return delegate;
+    }
+}

package/react-native/android/src/norangesource/java/dev/mediacache/alphavideo/gpu/AppDataSource.java

@@ -0,0 +1,15 @@
+package dev.mediacache.alphavideo.gpu;
+
+/**
+ * Stands in for android/src/rangesource's AppDataSource when the app hasn't installed
+ * react-native-range-source, so the package builds without range-source's classes. Never
+ * reached: {@link RangeSourceLink#available()} is false without the add-on.
+ */
+final class AppDataSource {
+
+    private AppDataSource() {}
+
+    static Fetcher create(String name) {
+        return null;
+    }
+}

package/react-native/android/src/oldarch/java/dev/mediacache/alphavideo/gpu/reactnative/AlphaVideoGpuViewManagerSpec.java

@@ -0,0 +1,56 @@
+package dev.mediacache.alphavideo.gpu.reactnative;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.SimpleViewManager;
+
+/**
+ * Old architecture: the same methods as the interface codegen generates for the new one, so the
+ * manager compiles against either. Props arrive through its {@code @ReactProp} setters.
+ */
+public abstract class AlphaVideoGpuViewManagerSpec<T extends View> extends SimpleViewManager<T> {
+
+    public abstract void setSource(T view, @Nullable ReadableMap value);
+    public abstract void setAutoPlay(T view, boolean value);
+    public abstract void setLoop(T view, boolean value);
+    public abstract void setPlaybackSpeed(T view, float value);
+    public abstract void setPaused(T view, boolean value);
+    public abstract void setCacheKey(T view, @Nullable String value);
+    public abstract void setStreamingPrefetchAhead(T view, int value);
+    public abstract void setMemoryStrategy(T view, @Nullable String value);
+    public abstract void setStream(T view, boolean value);
+    public abstract void setEnableFrameEvents(T view, boolean value);
+    public abstract void setVerbose(T view, boolean value);
+
+    public abstract void play(T view);
+    public abstract void pause(T view);
+    public abstract void stop(T view);
+    public abstract void seekToFrame(T view, int frame);
+    public abstract void seekToTime(T view, double seconds);
+
+    @Override
+    public void receiveCommand(@NonNull T view, String commandName, @Nullable ReadableArray args) {
+        switch (commandName) {
+            case "play":
+                play(view);
+                break;
+            case "pause":
+                pause(view);
+                break;
+            case "stop":
+                stop(view);
+                break;
+            case "seekToFrame":
+                if (args != null && args.size() > 0) seekToFrame(view, args.getInt(0));
+                break;
+            case "seekToTime":
+                if (args != null && args.size() > 0) seekToTime(view, args.getDouble(0));
+                break;
+        }
+    }
+}

package/react-native/ios/RNAlphaVideoGpuViewComponentView.mm

@@ -0,0 +1,176 @@
+//
+//  RNAlphaVideoGpuViewComponentView.mm
+//  Fabric component view for AlphaVideoGpuView (new architecture)
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTConversions.h>
+#import <React/RCTViewComponentView.h>
+
+#import <react/renderer/components/RNAlphaVideoGpuSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNAlphaVideoGpuSpec/EventEmitters.h>
+#import <react/renderer/components/RNAlphaVideoGpuSpec/Props.h>
+#import <react/renderer/components/RNAlphaVideoGpuSpec/RCTComponentViewHelpers.h>
+
+#import "AlphaVideoGPU.h"
+
+using namespace facebook::react;
+
+@interface RNAlphaVideoGpuViewComponentView : RCTViewComponentView <RCTAlphaVideoGpuViewViewProtocol>
+@end
+
+@implementation RNAlphaVideoGpuViewComponentView {
+  AlphaVideoGpuView *_player;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<AlphaVideoGpuViewComponentDescriptor>();
+}
+
+// A player holds its frames and GPU resources, so each mount gets a new one.
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const AlphaVideoGpuViewProps>();
+    _props = defaultProps;
+    [self createPlayer];
+  }
+  return self;
+}
+
+- (void)createPlayer
+{
+  _player = [[AlphaVideoGpuView alloc] initWithFrame:self.bounds];
+  [self forwardEvents];
+  self.contentView = _player;
+}
+
+// Older React Native versions ignore shouldBeRecycled and recycle every component view.
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  [_player cleanup];
+  [self createPlayer];
+}
+
+- (void)invalidate
+{
+  [_player cleanup];
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newProps = *std::static_pointer_cast<const AlphaVideoGpuViewProps>(props);
+
+  _player.autoPlay = newProps.autoPlay;
+  _player.loop = newProps.loop;
+  _player.playbackSpeed = newProps.playbackSpeed;
+  _player.playbackPaused = newProps.paused;
+  _player.enableFrameEvents = newProps.enableFrameEvents;
+  _player.stream = newProps.stream;
+  _player.streamingPrefetchAhead = newProps.streamingPrefetchAhead;
+  _player.memoryStrategy = RCTNSStringFromString(toString(newProps.memoryStrategy));
+  _player.verbose = newProps.verbose;
+  _player.storage = RCTNSStringFromString(toString(newProps.storage));
+  _player.maxStorageBytes = (int64_t)newProps.maxStorageBytes;
+
+  // Setting source starts the load, which reads every other prop, the cache key included.
+  NSString *cacheKey = RCTNSStringFromStringNilIfEmpty(newProps.cacheKey)
+      ?: RCTNSStringFromStringNilIfEmpty(newProps.source.cacheKey);
+  _player.cacheKey = cacheKey;
+  NSMutableDictionary<NSString *, NSString *> *headers = [NSMutableDictionary dictionary];
+  for (size_t i = 0; i + 1 < newProps.source.headers.size(); i += 2) {
+    headers[RCTNSStringFromString(newProps.source.headers[i])] = RCTNSStringFromString(newProps.source.headers[i + 1]);
+  }
+  _player.headers = headers;
+  _player.dataSource = RCTNSStringFromStringNilIfEmpty(newProps.source.dataSource);
+  _player.source = RCTNSStringFromStringNilIfEmpty(newProps.source.uri);
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (std::shared_ptr<const AlphaVideoGpuViewEventEmitter>)playerEventEmitter
+{
+  return std::static_pointer_cast<const AlphaVideoGpuViewEventEmitter>(_eventEmitter);
+}
+
+- (void)forwardEvents
+{
+  __weak RNAlphaVideoGpuViewComponentView *weakSelf = self;
+  _player.onLoad = ^(NSInteger width, NSInteger height, NSInteger frameCount, CGFloat frameRate) {
+    auto emitter = [weakSelf playerEventEmitter];
+    if (!emitter) return;
+    AlphaVideoGpuViewEventEmitter::OnLoad event;
+    event.width = (int)width;
+    event.height = (int)height;
+    event.frameCount = (int)frameCount;
+    event.frameRate = frameRate;
+    event.duration = frameCount > 0 && frameRate > 0 ? frameCount / frameRate : 0;
+    emitter->onLoad(event);
+  };
+  _player.onFrameUpdate = ^(NSInteger frame, NSInteger totalFrames) {
+    auto emitter = [weakSelf playerEventEmitter];
+    if (emitter) emitter->onFrameUpdate({.frame = (int)frame, .totalFrames = (int)totalFrames});
+  };
+  _player.onStateChange = ^(NSString *state) {
+    auto emitter = [weakSelf playerEventEmitter];
+    if (emitter) emitter->onStateChange({.state = RCTStringFromNSString(state)});
+  };
+  _player.onFinished = ^{
+    auto emitter = [weakSelf playerEventEmitter];
+    if (emitter) emitter->onFinished({});
+  };
+  _player.onError = ^(NSString *error, NSString *code) {
+    auto emitter = [weakSelf playerEventEmitter];
+    if (emitter) emitter->onError({.error = RCTStringFromNSString(error), .code = RCTStringFromNSString(code ?: @"")});
+  };
+}
+
+#pragma mark - Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTAlphaVideoGpuViewHandleCommand(self, commandName, args);
+}
+
+- (void)play
+{
+  [_player play];
+}
+
+- (void)pause
+{
+  [_player pause];
+}
+
+- (void)stop
+{
+  [_player stop];
+}
+
+- (void)seekToFrame:(NSInteger)frame
+{
+  [_player seekToFrame:frame];
+}
+
+- (void)seekToTime:(double)seconds
+{
+  [_player seekToTime:seconds];
+}
+
+@end
+
+// Older React Native versions look the class up by this name instead of codegenConfig.ios.componentProvider.
+extern "C" Class<RCTComponentViewProtocol> AlphaVideoGpuViewCls(void)
+{
+  return RNAlphaVideoGpuViewComponentView.class;
+}
+
+#endif