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

package/scripts/build_codecs_ios_device.sh

@@ -0,0 +1,210 @@
+#!/bin/bash
+#
+# build_codecs_ios_device.sh
+# Builds the decoders for iOS Device (arm64 only): libvpx for VP9 and dav1d for AV1 (8- and
+# 10/12-bit), as static libraries in prebuilt/ios/lib
+# Needs meson and ninja for dav1d (brew install meson ninja)
+#
+
+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/ios-device"
+OUTPUT_DIR="$PROJECT_DIR/prebuilt/ios"
+
+# iOS deployment target
+IOS_MIN_VERSION="13.0"
+
+# libvpx embeds its configure line in the library, so installs are staged with DESTDIR; no
+# local paths end up in it.
+INSTALL_PREFIX="/usr/local"
+# libvpx and dav1d install into one staging root
+DEPS_STAGE="$BUILD_DIR/deps-arm64"
+
+echo "🔧 Building libvpx $LIBVPX_VERSION and dav1d $DAV1D_VERSION for iOS Device (arm64)"
+echo "   Build dir: $BUILD_DIR"
+echo "   Output dir: $OUTPUT_DIR"
+
+mkdir -p "$BUILD_DIR"
+mkdir -p "$OUTPUT_DIR/lib"
+mkdir -p "$OUTPUT_DIR/include"
+
+# 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
+}
+
+# Build libvpx for iOS Device
+build_libvpx_device() {
+    echo "🔨 Building libvpx for iOS Device (arm64)..."
+    
+    cd "$BUILD_DIR/libvpx-$LIBVPX_VERSION"
+    
+    local STAGE="$DEPS_STAGE"
+    
+    # Clean previous build
+    make clean 2>/dev/null || true
+    
+    local SDK_PATH=$(xcrun --sdk iphoneos --show-sdk-path)
+    local CC="$(xcrun --sdk iphoneos -f clang)"
+    local CXX="$(xcrun --sdk iphoneos -f clang++)"
+    
+    local CFLAGS="-arch arm64 -isysroot $SDK_PATH -mios-version-min=$IOS_MIN_VERSION"
+    local LDFLAGS="-arch arm64 -isysroot $SDK_PATH"
+    
+    # Export compiler environment for libvpx
+    export CC="$CC"
+    export CXX="$CXX"
+    export CFLAGS="$CFLAGS"
+    export CXXFLAGS="$CFLAGS"
+    export LDFLAGS="$LDFLAGS"
+    export CROSS="$SDK_PATH"
+
+    export AR="$(xcrun --sdk iphoneos --find ar)"
+    export RANLIB="$(xcrun --sdk iphoneos --find ranlib)"
+    export NM="$(xcrun --sdk iphoneos --find nm)"
+    
+    ./configure \
+        --prefix="$INSTALL_PREFIX" \
+        --target=arm64-darwin-gcc \
+        --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
+    
+    make -j$(sysctl -n hw.ncpu)
+    make install DESTDIR="$STAGE"
+    
+    echo "✅ libvpx device build complete: $STAGE"
+}
+
+# Build dav1d for iOS Device: the AV1 decoder, 8-bit and 10/12-bit (16bpc)
+build_dav1d_device() {
+    echo "🔨 Building dav1d for iOS Device (arm64)..."
+    
+    local BUILD="$BUILD_DIR/dav1d-build-arm64"
+    local CROSS_FILE="$BUILD_DIR/dav1d-arm64.meson"
+    rm -rf "$BUILD"
+    
+    local SDK_PATH=$(xcrun --sdk iphoneos --show-sdk-path)
+    local CC="$(xcrun --sdk iphoneos -f clang)"
+    
+    cat > "$CROSS_FILE" <<EOF
+[binaries]
+c = ['$CC', '-arch', 'arm64', '-isysroot', '$SDK_PATH']
+ar = '$(xcrun --sdk iphoneos --find ar)'
+strip = '$(xcrun --sdk iphoneos --find strip)'
+
+[built-in options]
+c_args = ['-mios-version-min=$IOS_MIN_VERSION']
+c_link_args = ['-mios-version-min=$IOS_MIN_VERSION']
+
+[properties]
+needs_exe_wrapper = true
+
+[host_machine]
+system = 'darwin'
+subsystem = 'ios'
+kernel = 'xnu'
+cpu_family = 'aarch64'
+cpu = 'aarch64'
+endian = 'little'
+EOF
+    
+    # The flags libvpx exported are for iOS; meson would apply them to the build machine's compiler.
+    env -u CC -u CXX -u CFLAGS -u CXXFLAGS -u LDFLAGS \
+    meson setup "$BUILD" "$BUILD_DIR/dav1d-$DAV1D_VERSION" \
+        --cross-file "$CROSS_FILE" \
+        --prefix="$INSTALL_PREFIX" \
+        --libdir=lib \
+        --buildtype=release \
+        --default-library=static \
+        -Dbitdepths=8,16 \
+        -Denable_tools=false \
+        -Denable_tests=false
+    ninja -C "$BUILD"
+    DESTDIR="$DEPS_STAGE" meson install -C "$BUILD" --no-rebuild
+    
+    echo "✅ dav1d device build complete: $DEPS_STAGE"
+}
+
+# Copy outputs to final directory
+copy_outputs() {
+    echo "📦 Copying libraries to output directory..."
+    
+    local DEPS_PREFIX="$DEPS_STAGE$INSTALL_PREFIX"
+    local COMMON_INCLUDE="$PROJECT_DIR/prebuilt/include"
+    
+    # Clear output lib dir
+    rm -rf "$OUTPUT_DIR/lib"
+    mkdir -p "$OUTPUT_DIR/lib"
+    
+    # Copy libvpx and dav1d static libraries
+    cp "$DEPS_PREFIX/lib/"*.a "$OUTPUT_DIR/lib/"
+    
+    # Copy headers to common prebuilt/include (shared by all platforms)
+    rm -rf "$COMMON_INCLUDE"
+    mkdir -p "$COMMON_INCLUDE"
+    cp -R "$DEPS_PREFIX/include/"* "$COMMON_INCLUDE/"
+    
+    echo "📋 Libraries built:"
+    ls -la "$OUTPUT_DIR/lib/"
+}
+
+# Main build process
+main() {
+    echo "🚀 Starting iOS Device libvpx + dav1d build..."
+    echo ""
+    
+    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
+    
+    rm -rf "$DEPS_STAGE"
+    build_libvpx_device
+    build_dav1d_device
+    
+    copy_outputs
+    
+    echo ""
+    echo "✅ iOS Device libvpx + dav1d build complete!"
+    echo "   Output: $OUTPUT_DIR"
+    echo ""
+    echo "📝 Libraries built for: arm64 (iOS Device)"
+    echo "   Use prebuilt/ios-simulator/ for simulator builds"
+}
+
+main "$@"

package/scripts/build_codecs_ios_simulator.sh

@@ -0,0 +1,256 @@
+#!/bin/bash
+#
+# build_codecs_ios_simulator.sh
+# Builds the decoders for iOS Simulator (universal: arm64 + x86_64): libvpx for VP9 and dav1d for
+# AV1 (8- and 10/12-bit), as static libraries in prebuilt/ios-simulator/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/ios-simulator"
+OUTPUT_DIR="$PROJECT_DIR/prebuilt/ios-simulator"
+
+# iOS deployment target
+IOS_MIN_VERSION="13.0"
+
+# Architectures to build for simulator
+ARCHS=("arm64" "x86_64")
+
+# libvpx embeds its configure line in the library, so installs are staged with DESTDIR; no
+# local paths end up in it.
+INSTALL_PREFIX="/usr/local"
+
+# libvpx and dav1d install into one staging root per architecture
+deps_stage() {
+    echo "$BUILD_DIR/deps-$1-sim"
+}
+
+echo "🔧 Building libvpx $LIBVPX_VERSION and dav1d $DAV1D_VERSION for iOS Simulator (arm64 + x86_64)"
+echo "   Build dir: $BUILD_DIR"
+echo "   Output dir: $OUTPUT_DIR"
+
+mkdir -p "$BUILD_DIR"
+mkdir -p "$OUTPUT_DIR/lib"
+mkdir -p "$OUTPUT_DIR/include"
+
+# 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
+}
+
+# Build libvpx for a specific architecture
+build_libvpx_arch() {
+    local ARCH=$1
+    echo "🔨 Building libvpx for iOS Simulator ($ARCH)..."
+    
+    cd "$BUILD_DIR/libvpx-$LIBVPX_VERSION"
+    
+    local STAGE="$(deps_stage "$ARCH")"
+    
+    # Clean previous build
+    make clean 2>/dev/null || true
+    
+    local SDK_PATH=$(xcrun --sdk iphonesimulator --show-sdk-path)
+    local CC="$(xcrun --sdk iphonesimulator -f clang)"
+    local CXX="$(xcrun --sdk iphonesimulator -f clang++)"
+    
+    local CFLAGS="-arch $ARCH -isysroot $SDK_PATH -mios-simulator-version-min=$IOS_MIN_VERSION -target $ARCH-apple-ios$IOS_MIN_VERSION-simulator"
+    local LDFLAGS="-arch $ARCH -isysroot $SDK_PATH -target $ARCH-apple-ios$IOS_MIN_VERSION-simulator"
+    
+    # Export compiler environment for libvpx
+    export CC="$CC"
+    export CXX="$CXX"
+    export CFLAGS="$CFLAGS"
+    export CXXFLAGS="$CFLAGS"
+    export LDFLAGS="$LDFLAGS"
+    export AR="$(xcrun --sdk iphonesimulator --find ar)"
+    export RANLIB="$(xcrun --sdk iphonesimulator --find ranlib)"
+    export NM="$(xcrun --sdk iphonesimulator --find nm)"
+    
+    # Use generic-gnu target for libvpx cross-compile to simulator
+    ./configure \
+        --prefix="$INSTALL_PREFIX" \
+        --target=generic-gnu \
+        --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="$CFLAGS" \
+        --extra-cxxflags="$CFLAGS"
+    
+    make -j$(sysctl -n hw.ncpu)
+    make install DESTDIR="$STAGE"
+    
+    echo "✅ libvpx $ARCH simulator build complete: $STAGE"
+}
+
+# Build dav1d for a specific architecture: the AV1 decoder, 8-bit and 10/12-bit
+# (16bpc)
+build_dav1d_arch() {
+    local ARCH=$1
+    echo "🔨 Building dav1d for iOS Simulator ($ARCH)..."
+    
+    local BUILD="$BUILD_DIR/dav1d-build-$ARCH-sim"
+    local CROSS_FILE="$BUILD_DIR/dav1d-$ARCH-sim.meson"
+    rm -rf "$BUILD"
+    
+    local SDK_PATH=$(xcrun --sdk iphonesimulator --show-sdk-path)
+    local CC="$(xcrun --sdk iphonesimulator -f clang)"
+    local CPU_FAMILY="$ARCH"
+    [ "$ARCH" = "arm64" ] && CPU_FAMILY="aarch64"
+    
+    cat > "$CROSS_FILE" <<EOF
+[binaries]
+c = ['$CC', '-arch', '$ARCH', '-isysroot', '$SDK_PATH']
+ar = '$(xcrun --sdk iphonesimulator --find ar)'
+strip = '$(xcrun --sdk iphonesimulator --find strip)'
+
+[built-in options]
+c_args = ['-target', '$ARCH-apple-ios$IOS_MIN_VERSION-simulator']
+c_link_args = ['-target', '$ARCH-apple-ios$IOS_MIN_VERSION-simulator']
+
+[properties]
+needs_exe_wrapper = true
+
+[host_machine]
+system = 'darwin'
+subsystem = 'ios-simulator'
+kernel = 'xnu'
+cpu_family = '$CPU_FAMILY'
+cpu = '$CPU_FAMILY'
+endian = 'little'
+EOF
+    
+    # The flags libvpx exported are for the simulator; meson would apply them to the build
+    # machine's compiler.
+    env -u CC -u CXX -u CFLAGS -u CXXFLAGS -u LDFLAGS \
+    meson setup "$BUILD" "$BUILD_DIR/dav1d-$DAV1D_VERSION" \
+        --cross-file "$CROSS_FILE" \
+        --prefix="$INSTALL_PREFIX" \
+        --libdir=lib \
+        --buildtype=release \
+        --default-library=static \
+        -Dbitdepths=8,16 \
+        -Denable_tools=false \
+        -Denable_tests=false
+    ninja -C "$BUILD"
+    DESTDIR="$(deps_stage "$ARCH")" meson install -C "$BUILD" --no-rebuild
+    
+    echo "✅ dav1d $ARCH simulator build complete"
+}
+
+# Create universal (fat) libraries using lipo
+create_universal_libs() {
+    echo "🔗 Creating universal (fat) libraries..."
+    
+    # Clear output lib dir
+    rm -rf "$OUTPUT_DIR/lib"
+    mkdir -p "$OUTPUT_DIR/lib"
+    
+    # Get list of libraries from first arch
+    local FIRST_ARCH="${ARCHS[0]}"
+    local DEPS_LIBS=$(ls "$(deps_stage "$FIRST_ARCH")$INSTALL_PREFIX/lib/"*.a 2>/dev/null | xargs -n1 basename)
+    
+    # Create fat libvpx and dav1d libraries
+    for lib in $DEPS_LIBS; do
+        local inputs=""
+        for arch in "${ARCHS[@]}"; do
+            inputs="$inputs $(deps_stage "$arch")$INSTALL_PREFIX/lib/$lib"
+        done
+        echo "   Creating universal $lib..."
+        lipo -create $inputs -output "$OUTPUT_DIR/lib/$lib"
+    done
+    
+    # Copy headers (same for all archs)
+    rm -rf "$OUTPUT_DIR/include"
+    mkdir -p "$OUTPUT_DIR/include"
+    cp -R "$(deps_stage "$FIRST_ARCH")$INSTALL_PREFIX/include/"* "$OUTPUT_DIR/include/"
+    
+    echo "📋 Universal libraries built:"
+    for lib in "$OUTPUT_DIR/lib/"*.a; do
+        echo "   $(basename $lib): $(lipo -archs $lib)"
+    done
+}
+
+# Sync headers to canonical prebuilt/include for Xcode compatibility
+sync_common_includes() {
+    local COMMON_INCLUDE_DIR="$PROJECT_DIR/prebuilt/include"
+    echo "🔄 Syncing headers to canonical include dir: $COMMON_INCLUDE_DIR"
+    mkdir -p "$COMMON_INCLUDE_DIR"
+    if command -v rsync >/dev/null 2>&1; then
+        rsync -a "$OUTPUT_DIR/include/" "$COMMON_INCLUDE_DIR/"
+    else
+        cp -R "$OUTPUT_DIR/include/." "$COMMON_INCLUDE_DIR/"
+    fi
+}
+
+# Main build process
+main() {
+    echo "🚀 Starting iOS Simulator libvpx + dav1d build (universal)..."
+    echo ""
+    
+    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 each architecture
+    for arch in "${ARCHS[@]}"; do
+        echo ""
+        echo "================================================"
+        echo "Building for $arch..."
+        echo "================================================"
+        rm -rf "$(deps_stage "$arch")"
+        build_libvpx_arch "$arch"
+        build_dav1d_arch "$arch"
+    done
+    
+    # Create universal libraries
+    echo ""
+    echo "================================================"
+    create_universal_libs
+    sync_common_includes
+    
+    echo ""
+    echo "✅ iOS Simulator libvpx + dav1d build complete!"
+    echo "   Output: $OUTPUT_DIR"
+    echo ""
+    echo "📝 Universal libraries built for: ${ARCHS[*]}"
+    echo "   Supports both Apple Silicon and Intel Macs"
+}
+
+main "$@"

package/scripts/build_wasm.sh

@@ -0,0 +1,230 @@
+#!/bin/bash
+#
+# build_wasm.sh
+# The WebAssembly modules of alpha-video-web (web/), each with its .wasm inlined so the npm
+# package has no files to host:
+#   web/src/wasm/demuxer.mjs      the core's demuxer (cpp/AlphaDemuxer, on libwebm's parser), reading
+#                                 through JavaScript so files stream in by range, and the shared
+#                                 colour conversion (cpp/YuvToRgb), for the WebCodecs and software
+#                                 engines
+#   web/src/wasm/software-vpx.mjs FFmpeg's VP8 and VP9 decoders, single-threaded, run in a Web
+#                                 Worker per stream by the software engine; loaded only for VP8
+#                                 and VP9 streams
+#   web/src/wasm/software-av1.mjs dav1d through the av1 codec module's plugin (codecs/av1), as on
+#                                 Android and iOS; no FFmpeg. Loaded only for AV1 streams
+#   web/src/wasm/software-*-mt.mjs the same with threads (FFmpeg's frame threads, dav1d's own),
+#                                 for cross-origin isolated pages, where SharedArrayBuffer exists
+#
+# Needs Emscripten, meson and ninja (brew install emscripten meson ninja).
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+FFMPEG_VERSION="6.1"
+DAV1D_VERSION="1.5.1"
+
+BUILD_DIR="$SCRIPT_DIR/build/wasm"
+OUT_DIR="$PROJECT_DIR/web/src/wasm"
+JOBS="$(sysctl -n hw.ncpu 2>/dev/null || nproc)"
+
+for tool in emcc em++ emconfigure emmake meson ninja pkg-config; do
+    if ! command -v "$tool" >/dev/null; then
+        echo "❌ $tool not found on PATH (brew install emscripten meson ninja pkg-config)"
+        exit 1
+    fi
+done
+
+mkdir -p "$BUILD_DIR"
+
+download() {
+    local name=$1 url=$2 android_copy=$3
+    if [ -d "$BUILD_DIR/$name" ]; then return; fi
+    # The Android build downloads the same releases; reuse them when they're there
+    if [ -d "$SCRIPT_DIR/build/android/$android_copy" ]; then
+        cp -R "$SCRIPT_DIR/build/android/$android_copy" "$BUILD_DIR/$name"
+        return
+    fi
+    echo "📥 Downloading $name..."
+    mkdir -p "$BUILD_DIR/$name"
+    curl -L "$url" | tar xz --strip-components=1 -C "$BUILD_DIR/$name" 2>/dev/null \
+        || curl -L "$url" | tar xJ --strip-components=1 -C "$BUILD_DIR/$name"
+}
+
+# build_dav1d <variant> [-pthread]: into stage-<variant>
+build_dav1d() {
+    local variant=$1 pthread=${2:-}
+    local stage="$BUILD_DIR/stage-$variant"
+    if [ -f "$stage/lib/libdav1d.a" ]; then return; fi
+    echo "🔨 Building dav1d $DAV1D_VERSION for WebAssembly ($variant)..."
+    local cross="$BUILD_DIR/$variant-emscripten.meson"
+    local flags="'-Oz', '-flto'${pthread:+, '$pthread'}"
+    cat > "$cross" <<EOF
+[binaries]
+c = 'emcc'
+ar = 'emar'
+ranlib = 'emranlib'
+
+[built-in options]
+c_args = [$flags]
+c_link_args = [$flags]
+
+[properties]
+needs_exe_wrapper = true
+
+[host_machine]
+system = 'emscripten'
+cpu_family = 'wasm32'
+cpu = 'wasm32'
+endian = 'little'
+EOF
+    rm -rf "$BUILD_DIR/$variant-build"
+    # Meson's threads dependency always adds -pthread, which needs SharedArrayBuffer at run time;
+    # the cross file adds it for the threaded variant only. Single-threaded, the plugin is given
+    # one thread, so dav1d starts none.
+    sed -i '' "s/^    thread_dependency = dependency('threads')$/    thread_dependency = host_machine.system() == 'emscripten' ? declare_dependency() : dependency('threads')/" \
+        "$BUILD_DIR/dav1d-$DAV1D_VERSION/meson.build"
+    meson setup "$BUILD_DIR/$variant-build" "$BUILD_DIR/dav1d-$DAV1D_VERSION" \
+        --cross-file "$cross" \
+        --prefix="$stage" \
+        --libdir=lib \
+        --buildtype=release \
+        --default-library=static \
+        -Denable_asm=false \
+        -Dbitdepths=8,16 \
+        -Dlogging=false \
+        -Denable_tools=false \
+        -Denable_tests=false
+    ninja -C "$BUILD_DIR/$variant-build"
+    meson install -C "$BUILD_DIR/$variant-build" --no-rebuild
+}
+
+# build_ffmpeg <variant> <configure flags...>: out of tree in ffmpeg-<variant>, installed to stage-<variant>
+build_ffmpeg() {
+    local variant=$1
+    shift
+    local stage="$BUILD_DIR/stage-$variant"
+    if [ -f "$stage/lib/libavcodec.a" ]; then return; fi
+    echo "🔨 Building FFmpeg $FFMPEG_VERSION for WebAssembly ($variant)..."
+    local build="$BUILD_DIR/ffmpeg-$variant"
+    rm -rf "$build"
+    mkdir -p "$build"
+    cd "$build"
+    # Without threads unless a variant enables them (later flags win), so pages need no
+    # cross-origin isolation
+    emconfigure "$BUILD_DIR/ffmpeg-$FFMPEG_VERSION/configure" \
+        --prefix="$stage" \
+        --target-os=none \
+        --arch=x86_32 \
+        --enable-cross-compile \
+        --cc=emcc \
+        --cxx=em++ \
+        --ar=emar \
+        --ranlib=emranlib \
+        --nm="$(command -v llvm-nm || echo emnm)" \
+        --pkg-config=pkg-config \
+        --extra-cflags="-Oz -flto" \
+        --extra-ldflags="-flto" \
+        --disable-asm \
+        --disable-inline-asm \
+        --disable-x86asm \
+        --disable-stripping \
+        --disable-programs \
+        --disable-doc \
+        --disable-debug \
+        --disable-network \
+        --disable-gpl \
+        --disable-everything \
+        --disable-autodetect \
+        --disable-iconv \
+        --disable-pthreads \
+        --disable-w32threads \
+        --disable-os2threads \
+        --disable-avdevice \
+        --disable-avfilter \
+        --disable-swresample \
+        --disable-swscale \
+        --enable-demuxer=matroska,webm \
+        --enable-static \
+        --disable-shared \
+        "$@"
+    emmake make -j"$JOBS"
+    emmake make install
+    cd "$PROJECT_DIR"
+}
+
+# link_module <output> <sources, libraries and flags...>
+link_module() {
+    local output=$1
+    shift
+    echo "🔨 Linking $output..."
+    mkdir -p "$OUT_DIR"
+    # web,worker only: the node environment adds import("node:module"), which webpack can't
+    # resolve for the browser. Base64, not the raw-byte string, so bundlers pass it through intact.
+    em++ -std=c++17 -Oz -flto \
+        "$@" \
+        -sMODULARIZE=1 -sEXPORT_ES6=1 -sEXPORT_NAME=createModule \
+        -sSINGLE_FILE=1 -sSINGLE_FILE_BINARY_ENCODE=0 -sENVIRONMENT=web,worker \
+        -sDYNAMIC_EXECUTION=0 \
+        -sALLOW_MEMORY_GROWTH=1 -sFILESYSTEM=0 \
+        -sEXPORTED_FUNCTIONS=_malloc,_free \
+        -sEXPORTED_RUNTIME_METHODS=HEAPU8,HEAP32,HEAPF32,HEAPF64,wasmMemory \
+        -o "$OUT_DIR/$output"
+    echo "✅ $(du -h "$OUT_DIR/$output" | cut -f1) $OUT_DIR/$output"
+}
+
+download "ffmpeg-$FFMPEG_VERSION" "https://ffmpeg.org/releases/ffmpeg-$FFMPEG_VERSION.tar.xz" "ffmpeg-$FFMPEG_VERSION"
+download "dav1d-$DAV1D_VERSION" "https://github.com/videolan/dav1d/archive/refs/tags/$DAV1D_VERSION.tar.gz" "dav1d-$DAV1D_VERSION"
+# An in-tree configure (the Android build's copy) blocks out-of-tree builds
+if [ -f "$BUILD_DIR/ffmpeg-$FFMPEG_VERSION/config.h" ] || [ -f "$BUILD_DIR/ffmpeg-$FFMPEG_VERSION/ffbuild/config.mak" ]; then
+    (cd "$BUILD_DIR/ffmpeg-$FFMPEG_VERSION" && make distclean >/dev/null 2>&1 || true)
+    rm -f "$BUILD_DIR/ffmpeg-$FFMPEG_VERSION/config.h"
+fi
+
+build_dav1d dav1d
+build_dav1d dav1d-mt -pthread
+build_ffmpeg software-vpx --disable-avformat --enable-decoder=vp8,vp9
+build_ffmpeg software-vpx-mt --disable-avformat --enable-decoder=vp8,vp9 \
+    --enable-pthreads --extra-cflags=-pthread --extra-ldflags=-pthread
+
+WEBM_PARSER="$PROJECT_DIR/third_party/libwebm/webm_parser"
+link_module demuxer.mjs \
+    -I"$PROJECT_DIR/cpp" -I"$WEBM_PARSER" -I"$WEBM_PARSER/include" \
+    "$PROJECT_DIR/web/wasm/demuxer_bindings.cpp" "$PROJECT_DIR/cpp/AlphaDemuxer.cpp" \
+    "$PROJECT_DIR/cpp/Av1SequenceHeader.cpp" "$PROJECT_DIR/cpp/YuvToRgb.cpp" "$WEBM_PARSER"/src/*.cc \
+    -sMALLOC=emmalloc -sINITIAL_MEMORY=16777216
+
+# vpx_module <output> <FFmpeg variant> <flags...>
+vpx_module() {
+    local output=$1 stage="$BUILD_DIR/stage-$2"
+    shift 2
+    link_module "$output" \
+        -I"$stage/include" "$PROJECT_DIR/web/wasm/decoder_bindings.cpp" \
+        "$stage/lib/libavcodec.a" "$stage/lib/libavutil.a" \
+        -sINITIAL_MEMORY=33554432 "$@"
+}
+
+# av1_module <output> <dav1d variant> <flags...>
+av1_module() {
+    local output=$1 stage="$BUILD_DIR/stage-$2"
+    shift 2
+    link_module "$output" \
+        -I"$PROJECT_DIR/cpp" -I"$PROJECT_DIR/codecs/av1" -I"$stage/include" \
+        "$PROJECT_DIR/web/wasm/plugin_bindings.cpp" "$PROJECT_DIR/codecs/av1/Dav1dDecoderPlugin.cpp" \
+        "$stage/lib/libdav1d.a" \
+        -sINITIAL_MEMORY=33554432 "$@"
+}
+
+# The pool is created when the module starts, sized by its pthreadPoolSize option: a thread
+# started later would wait for a Worker to load while its creator blocks. Running out is an
+# error rather than a hang. Its Workers load mainScriptUrlOrBlob, the decode Worker's own blob:
+# URL, as there is no module file next to the code.
+# Shared memory can't move, so browsers reserve its maximum up front; WebKit runs out of address
+# space after a few at the default 2 GB.
+THREADED=(-pthread -sPTHREAD_POOL_SIZE=Module.pthreadPoolSize -sPTHREAD_POOL_SIZE_STRICT=2
+    -sINCOMING_MODULE_JS_API=mainScriptUrlOrBlob -sMAXIMUM_MEMORY=1073741824)
+vpx_module software-vpx.mjs software-vpx -sMALLOC=emmalloc
+vpx_module software-vpx-mt.mjs software-vpx-mt "${THREADED[@]}"
+av1_module software-av1.mjs dav1d -sMALLOC=emmalloc
+av1_module software-av1-mt.mjs dav1d-mt "${THREADED[@]}"