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

package/react-native/src/index.tsx

@@ -0,0 +1,144 @@
+/**
+ * Package entry point.
+ *
+ * The player view itself lives in `AlphaVideoView.tsx`; this file holds the native-module
+ * utilities and re-exports the rest.
+ */
+
+import { Platform } from 'react-native';
+import NativeAlphaVideoModule from './NativeAlphaVideoModule';
+
+/**
+ * Decoder status information (Android only)
+ */
+export interface DecoderStatus {
+  /** Maximum VP9 decoder instances supported by the device */
+  maxVp9Instances: number;
+  /** Maximum AV1 decoder instances supported by the device */
+  maxAv1Instances: number;
+  /** Whether VP9 hardware decoder is available */
+  vp9HardwareAvailable: boolean;
+  /** Whether AV1 hardware decoder is available */
+  av1HardwareAvailable: boolean;
+  /** Currently active decoder instances */
+  activeDecoders: number;
+  /** Remaining available VP9 decoder slots */
+  availableVp9Slots: number;
+  /** Maximum dual-stream players possible */
+  maxDualStreamPlayers: number;
+  /** Whether we can create more dual-stream players */
+  canCreateMore: boolean;
+  /**
+   * The C++ core's software decoders, from the codecs built in (`"react-native-alpha-video":
+   * { "codecs": [...] }` in the app's package.json), e.g. `['libvpx v1.14.0', 'dav1d 1.5.1']`
+   */
+  softwareDecoders: string[];
+}
+
+/**
+ * Native module for AlphaVideo utilities (Android only)
+ */
+const AlphaVideoModule = Platform.OS === 'android' ? NativeAlphaVideoModule : null;
+
+/**
+ * Get detailed decoder information for all supported codecs (VP9, AV1).
+ * Returns a string with all decoder capabilities including max instances,
+ * hardware acceleration status, supported resolutions, etc.
+ * 
+ * @returns Promise<string> - Detailed decoder information
+ * @platform android
+ */
+export async function getDecoderInfo(): Promise<string> {
+  if (Platform.OS !== 'android') {
+    return 'Decoder info only available on Android';
+  }
+  if (!AlphaVideoModule) {
+    throw new Error('RNAlphaVideo native module not available');
+  }
+  return AlphaVideoModule.getDecoderInfo();
+}
+
+/**
+ * Get the maximum number of concurrent decoder instances for a codec.
+ * Dual-stream videos require 2 instances per player.
+ * 
+ * @param mimeType - MIME type (e.g. 'video/x-vnd.on2.vp9' or 'video/av01')
+ * @returns Promise<number> - Max instances (-1 if unable to determine)
+ * @platform android
+ */
+export async function getMaxDecoderInstances(mimeType: string): Promise<number> {
+  if (Platform.OS !== 'android') {
+    return -1;
+  }
+  if (!AlphaVideoModule) {
+    throw new Error('RNAlphaVideo native module not available');
+  }
+  return AlphaVideoModule.getMaxDecoderInstances(mimeType);
+}
+
+/**
+ * Get the current number of active VP9 decoder instances.
+ * 
+ * @returns Promise<number> - Active decoder count
+ * @platform android
+ */
+export async function getActiveDecoderCount(): Promise<number> {
+  if (Platform.OS !== 'android') {
+    return 0;
+  }
+  if (!AlphaVideoModule) {
+    throw new Error('RNAlphaVideo native module not available');
+  }
+  return AlphaVideoModule.getActiveDecoderCount();
+}
+
+/**
+ * Get comprehensive decoder status as a structured object.
+ * Useful for determining if more dual-stream players can be created.
+ * 
+ * @returns Promise<DecoderStatus> - Decoder status information
+ * @platform android
+ * 
+ * @example
+ * ```ts
+ * const status = await getDecoderStatus();
+ * console.log(`Can create ${status.maxDualStreamPlayers} dual-stream players`);
+ * console.log(`Currently using ${status.activeDualStreamPlayers}`);
+ * if (!status.canCreateMore) {
+ *   console.warn('At decoder limit!');
+ * }
+ * ```
+ */
+export async function getDecoderStatus(): Promise<DecoderStatus> {
+  if (Platform.OS !== 'android') {
+    return {
+      maxVp9Instances: -1,
+      maxAv1Instances: -1,
+      vp9HardwareAvailable: false,
+      av1HardwareAvailable: false,
+      activeDecoders: 0,
+      availableVp9Slots: -1,
+      maxDualStreamPlayers: -1,
+      canCreateMore: true,
+      softwareDecoders: [],
+    };
+  }
+  if (!AlphaVideoModule) {
+    throw new Error('RNAlphaVideo native module not available');
+  }
+  return AlphaVideoModule.getDecoderStatus();
+}
+
+export {
+  AlphaVideoView,
+  type AlphaVideoViewProps,
+  type AlphaVideoViewRef,
+  type AlphaVideoSource,
+  type AlphaVideoWebSource,
+  type ByteSource,
+  type AlphaVideoStorage,
+  type PlaybackMode,
+  type Decoder,
+  type WebDecoder,
+  type AlphaVideoLoadEvent,
+} from './AlphaVideoView';

package/react-native-alpha-video.podspec

@@ -0,0 +1,99 @@
+require 'json'
+require 'pathname'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+pod_dir = Pathname.new(__dir__).relative_path_from(Pathname.new(Pod::Config.instance.installation_root)).to_s
+
+# The codec modules to build in, from the app's package.json as android/build.gradle reads them:
+# "react-native-alpha-video": { "codecs": ["vpx"] }. Both without the setting.
+codec_targets = { 'vpx' => 'AlphaVideoVPX', 'av1' => 'AlphaVideoAV1' }
+app_package_json = File.join(Pod::Config.instance.installation_root, '..', 'package.json')
+codecs_setting = File.exist?(app_package_json) &&
+                 JSON.parse(File.read(app_package_json)).dig('react-native-alpha-video', 'codecs')
+codecs = codec_targets.keys
+if codecs_setting
+  unless codecs_setting.is_a?(Array) && (codecs_setting - codec_targets.keys).empty?
+    raise "react-native-alpha-video: \"codecs\" in #{app_package_json} must list some of #{codec_targets.keys}, not #{codecs_setting}"
+  end
+  codecs = codec_targets.keys & codecs_setting
+end
+# Once: CocoaPods evaluates a podspec several times per install
+unless $react_native_alpha_video_codecs_reported
+  $react_native_alpha_video_codecs_reported = true
+  if codecs.empty?
+    Pod::UI.warn 'react-native-alpha-video: no codecs, and iOS has no platform decoder for these files: every video reports NO_DECODER'
+  else
+    Pod::UI.puts "react-native-alpha-video: codecs #{codecs.join(', ')}"
+  end
+end
+
+Pod::Spec.new do |s|
+  s.name         = 'react-native-alpha-video'
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.homepage     = package['homepage']
+  s.license      = package['license']
+  s.authors      = package['author']
+
+  s.platforms    = { :ios => '13.0' }
+  s.source       = { :git => package['repository']['url'], :tag => "v#{s.version}" }
+
+  # The iOS library (ios/Sources/AlphaVideo, also the Swift package), the React Native view, and
+  # each codec module's plugin adapter and the class the core finds it by
+  s.source_files = [
+    'ios/Sources/AlphaVideo/**/*.{h,mm}',
+    'react-native/ios/**/*.{h,mm}',
+    'cpp/**/*.{h,cpp}',
+    'third_party/libwebm/webm_parser/**/*.{h,cc}',
+    'third_party/range-source/include/*.h'
+  ] + codecs.flat_map { |codec| ["codecs/#{codec}/*.{h,cpp}", "ios/Sources/#{codec_targets[codec]}/**/*.{h,mm}"] }
+  s.exclude_files = [
+    'cpp/*_jni.cpp'
+  ]
+  s.public_header_files = 'ios/Sources/AlphaVideo/include/AlphaVideo.h'
+  
+  # Prebuilt libvpx and dav1d, linked by the app (see user_target_xcconfig)
+  s.preserve_paths = [
+    'prebuilt/ios/**/*',
+    'prebuilt/ios-simulator/**/*',
+    'prebuilt/include/**/*'
+  ]
+  
+  header_paths = ['prebuilt/include', 'ios/Sources/AlphaVideo/include', 'cpp'] +
+                 codecs.map { |codec| "codecs/#{codec}" } +
+                 ['third_party/range-source/include', 'third_party/libwebm/webm_parser', 'third_party/libwebm/webm_parser/include']
+  s.pod_target_xcconfig = {
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+    'CLANG_CXX_LIBRARY' => 'libc++',
+    'HEADER_SEARCH_PATHS' => header_paths.map { |path| "\"$(PODS_TARGET_SRCROOT)/#{path}\"" }.join(' '),
+    'LIBRARY_SEARCH_PATHS[sdk=iphoneos*]' => '"$(PODS_TARGET_SRCROOT)/prebuilt/ios/lib"',
+    'LIBRARY_SEARCH_PATHS[sdk=iphonesimulator*]' => '"$(PODS_TARGET_SRCROOT)/prebuilt/ios-simulator/lib"'
+  }
+  
+  # Propagate linker flags to the user target (app). The prebuilt libs differ per SDK, so they
+  # can't be vendored; the app links them by path, relative to the Podfile's directory.
+  # dav1d is force-loaded: an app that also links another dav1d (libavif's pod) would otherwise
+  # bind the core's calls to whichever comes first on the link line, maybe one without 10-bit AV1.
+  user_target_xcconfig = {}
+  { 'iphoneos' => 'ios', 'iphonesimulator' => 'ios-simulator' }.each do |sdk, dir|
+    lib_dir = "$(PODS_ROOT)/../#{pod_dir}/prebuilt/#{dir}/lib"
+    flags = []
+    flags << "-force_load \"#{lib_dir}/libdav1d.a\"" if codecs.include?('av1')
+    flags << '-lvpx' if codecs.include?('vpx')
+    next if flags.empty?
+    user_target_xcconfig["LIBRARY_SEARCH_PATHS[sdk=#{sdk}*]"] = "$(inherited) \"#{lib_dir}\""
+    user_target_xcconfig["OTHER_LDFLAGS[sdk=#{sdk}*]"] = "$(inherited) #{flags.join(' ')}"
+  end
+  s.user_target_xcconfig = user_target_xcconfig
+  
+  s.frameworks = ['Metal', 'MetalKit']
+  s.libraries = ['c++']
+  
+  # React Native's helper: the Fabric and codegen dependencies, and RCT_NEW_ARCH_ENABLED on the
+  # new architecture. It reads pod_target_xcconfig, so it comes after it.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency 'React-Core'
+  end
+end

package/react-native.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {},
+      android: {
+        sourceDir: './react-native/android',
+        packageImportPath: 'import dev.mediacache.alphavideo.reactnative.AlphaVideoPackage;',
+        packageInstance: 'new AlphaVideoPackage()',
+      },
+    },
+  },
+};

package/scripts/build_codecs_android.sh

@@ -0,0 +1,246 @@
+#!/bin/bash
+#
+# build_codecs_android.sh
+# Downloads and builds the decoders for Android (arm64-v8a, armeabi-v7a, x86_64): libvpx for VP9
+# and dav1d for AV1 (8- and 10/12-bit), as static libraries in prebuilt/android/<abi>/lib.
+# Needs meson and ninja for dav1d (brew install meson ninja), and nasm for x86_64
+#
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+LIBVPX_VERSION="1.14.0"
+DAV1D_VERSION="1.5.1"
+BUILD_DIR="$SCRIPT_DIR/build/android"
+OUTPUT_DIR="$PROJECT_DIR/prebuilt/android"
+
+# Android settings
+ANDROID_API=24
+NDK_PATH="${ANDROID_NDK_HOME:-$ANDROID_HOME/ndk/27.1.12297006}"
+
+if [ ! -d "$NDK_PATH" ]; then
+    echo "❌ Android NDK not found at $NDK_PATH"
+    echo "   Set ANDROID_NDK_HOME or install NDK via Android Studio"
+    exit 1
+fi
+
+TOOLCHAIN="$NDK_PATH/toolchains/llvm/prebuilt/$(uname -s | tr '[:upper:]' '[:lower:]')-x86_64"
+# Tools are called by name and installs are staged with DESTDIR, because libvpx embeds its
+# configure line in the library; that way no local paths end up in it.
+export PATH="$TOOLCHAIN/bin:$PATH"
+INSTALL_PREFIX="/usr/local"
+
+echo "🔧 Building libvpx $LIBVPX_VERSION and dav1d $DAV1D_VERSION for Android"
+echo "   NDK: $NDK_PATH"
+echo "   Build dir: $BUILD_DIR"
+echo "   Output dir: $OUTPUT_DIR"
+
+mkdir -p "$BUILD_DIR"
+mkdir -p "$OUTPUT_DIR"
+
+# Download libvpx source  
+download_libvpx() {
+    if [ ! -d "$BUILD_DIR/libvpx-$LIBVPX_VERSION" ]; then
+        echo "📥 Downloading libvpx $LIBVPX_VERSION..."
+        cd "$BUILD_DIR"
+        curl -L "https://github.com/webmproject/libvpx/archive/refs/tags/v$LIBVPX_VERSION.tar.gz" -o libvpx.tar.gz
+        tar xf libvpx.tar.gz
+        rm libvpx.tar.gz
+    fi
+}
+
+# Download dav1d source
+download_dav1d() {
+    if [ ! -d "$BUILD_DIR/dav1d-$DAV1D_VERSION" ]; then
+        echo "📥 Downloading dav1d $DAV1D_VERSION..."
+        cd "$BUILD_DIR"
+        curl -L "https://github.com/videolan/dav1d/archive/refs/tags/$DAV1D_VERSION.tar.gz" -o dav1d.tar.gz
+        tar xf dav1d.tar.gz
+        rm dav1d.tar.gz
+    fi
+}
+
+# libvpx and dav1d install into one staging root per ABI
+deps_stage() {
+    echo "$BUILD_DIR/deps-$1"
+}
+
+# Build libvpx for Android
+build_libvpx_android() {
+    local ABI=$1
+    local ARCH=$2
+    local TARGET=$3
+    
+    echo "🔨 Building libvpx for $ABI..."
+    
+    cd "$BUILD_DIR/libvpx-$LIBVPX_VERSION"
+    
+    local STAGE="$(deps_stage "$ABI")"
+    
+    make clean 2>/dev/null || true
+    
+    export CC="${TARGET}${ANDROID_API}-clang"
+    export CXX="${TARGET}${ANDROID_API}-clang++"
+    export AR="llvm-ar"
+    export RANLIB="llvm-ranlib"
+    export STRIP="llvm-strip"
+    
+    if [ "$ABI" = "arm64-v8a" ] || [ "$ABI" = "armeabi-v7a" ]; then
+        export AS="${TARGET}${ANDROID_API}-clang"
+        export ASFLAGS="-c"
+    else
+        unset AS
+        unset ASFLAGS
+
+        if command -v nasm >/dev/null 2>&1; then
+            export NASM="$(command -v nasm)"
+        elif command -v yasm >/dev/null 2>&1; then
+            export YASM="$(command -v yasm)"
+        else
+            echo "⚠️  NASM/YASM not found on PATH; x86 builds may fail."
+        fi
+
+        if command -v readelf >/dev/null 2>&1; then
+            export READELF="$(command -v readelf)"
+        elif command -v greadelf >/dev/null 2>&1; then
+            export READELF="$(command -v greadelf)"
+        else
+            export READELF="llvm-readelf"
+        fi
+    fi
+    
+    local VPX_TARGET=""
+    case $ABI in
+        arm64-v8a)
+            VPX_TARGET="arm64-android-gcc"
+            ;;
+        armeabi-v7a)
+            VPX_TARGET="armv7-android-gcc"
+            ;;
+        x86_64)
+            VPX_TARGET="x86_64-android-gcc"
+            ;;
+    esac
+    
+    ./configure \
+        --prefix="$INSTALL_PREFIX" \
+        --target="$VPX_TARGET" \
+        --disable-examples \
+        --disable-tools \
+        --disable-docs \
+        --disable-unit-tests \
+        --enable-vp8-decoder \
+        --enable-vp9-decoder \
+        --disable-vp8-encoder \
+        --disable-vp9-encoder \
+        --enable-pic \
+        --enable-static \
+        --disable-shared \
+        --extra-cflags="-fPIC"
+    
+    make -j$(nproc 2>/dev/null || sysctl -n hw.ncpu)
+    make install DESTDIR="$STAGE"
+}
+
+# Build dav1d for Android: the AV1 decoder, 8-bit and 10/12-bit (16bpc)
+build_dav1d_android() {
+    local ABI=$1
+    local TARGET=$2
+    local CPU_FAMILY=$3
+    
+    echo "🔨 Building dav1d for $ABI..."
+    
+    local BUILD="$BUILD_DIR/dav1d-build-$ABI"
+    local CROSS_FILE="$BUILD_DIR/dav1d-$ABI.meson"
+    rm -rf "$BUILD"
+    
+    cat > "$CROSS_FILE" <<EOF
+[binaries]
+c = '${TARGET}${ANDROID_API}-clang'
+ar = 'llvm-ar'
+strip = 'llvm-strip'
+
+[properties]
+needs_exe_wrapper = true
+
+[host_machine]
+system = 'android'
+cpu_family = '$CPU_FAMILY'
+cpu = '$CPU_FAMILY'
+endian = 'little'
+EOF
+    
+    meson setup "$BUILD" "$BUILD_DIR/dav1d-$DAV1D_VERSION" \
+        --cross-file "$CROSS_FILE" \
+        --prefix="$INSTALL_PREFIX" \
+        --libdir=lib \
+        --buildtype=release \
+        --default-library=static \
+        -Db_pie=true \
+        -Dbitdepths=8,16 \
+        -Denable_tools=false \
+        -Denable_tests=false
+    ninja -C "$BUILD"
+    DESTDIR="$(deps_stage "$ABI")" meson install -C "$BUILD" --no-rebuild
+}
+
+# Copy outputs for each ABI
+package_output() {
+    local ABI=$1
+    
+    echo "📦 Packaging $ABI..."
+    
+    local OUT="$OUTPUT_DIR/$ABI"
+    local DEPS_DIR="$(deps_stage "$ABI")$INSTALL_PREFIX"
+    rm -rf "$OUT/lib"
+    mkdir -p "$OUT/lib"
+    
+    # Copy static archives (.a)
+    cp "$DEPS_DIR/lib/"*.a "$OUT/lib/"
+    
+    # Copy headers to common prebuilt/include (same for all platforms)
+    local COMMON_INCLUDE="$PROJECT_DIR/prebuilt/include"
+    mkdir -p "$COMMON_INCLUDE"
+    rm -rf "$COMMON_INCLUDE/vpx" "$COMMON_INCLUDE/dav1d"
+    cp -R "$DEPS_DIR/include/"* "$COMMON_INCLUDE/"
+}
+
+# Main build process
+main() {
+    echo "🚀 Starting Android libvpx + dav1d build..."
+    
+    for tool in meson ninja; do
+        if ! command -v "$tool" >/dev/null 2>&1; then
+            echo "❌ $tool not found on PATH; dav1d needs it (brew install meson ninja)"
+            exit 1
+        fi
+    done
+    
+    download_libvpx
+    download_dav1d
+    
+    # Build for arm64-v8a (most common)
+    rm -rf "$(deps_stage arm64-v8a)"
+    build_libvpx_android "arm64-v8a" "aarch64" "aarch64-linux-android"
+    build_dav1d_android "arm64-v8a" "aarch64-linux-android" "aarch64"
+    package_output "arm64-v8a"
+    
+    # Build for armeabi-v7a (older devices)
+    rm -rf "$(deps_stage armeabi-v7a)"
+    build_libvpx_android "armeabi-v7a" "arm" "armv7a-linux-androideabi"
+    build_dav1d_android "armeabi-v7a" "armv7a-linux-androideabi" "arm"
+    package_output "armeabi-v7a"
+    
+    # Build for x86_64 (emulator)
+    rm -rf "$(deps_stage x86_64)"
+    build_libvpx_android "x86_64" "x86_64" "x86_64-linux-android"
+    build_dav1d_android "x86_64" "x86_64-linux-android" "x86_64"
+    package_output "x86_64"
+    
+    echo "✅ Android libvpx + dav1d build complete!"
+    echo "   Output: $OUTPUT_DIR"
+    ls -la "$OUTPUT_DIR"
+}
+
+main "$@"

package/scripts/build_codecs_ios.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+#
+# build_codecs_ios.sh
+# Convenience script to build libvpx and dav1d for both iOS Device and Simulator
+#
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "🚀 Building libvpx + dav1d for iOS (Device + Simulator)"
+echo ""
+
+# Build for device first
+"$SCRIPT_DIR/build_codecs_ios_device.sh"
+
+echo ""
+echo "================================================"
+echo ""
+
+# Build for simulator
+"$SCRIPT_DIR/build_codecs_ios_simulator.sh"
+
+echo ""
+echo "================================================"
+echo "✅ All iOS builds complete!"
+echo ""
+echo "📁 Output directories:"
+echo "   Device:    $PROJECT_DIR/prebuilt/ios/"
+echo "   Simulator: $PROJECT_DIR/prebuilt/ios-simulator/"