#!/usr/bin/env bash
# build_ffmpeg.sh — Build a slim LGPL-only FFmpeg 7.x XCFramework for tvOS.
#
# Produces:
#   build/xcframeworks/FFmpeg.xcframework   (device arm64 + simulator arm64)
#       with the dSYM of each slice (dSYMs/FFmpeg.framework.dSYM, FFmpeg and dav1d
#       with line tables) and a PrivacyInfo.xcprivacy in each framework.
#       Scripts/release.sh uploads the device dSYM to the symbols service.
#
# Requirements:
#   - macOS host with Xcode 15+ and Command Line Tools installed
#   - Homebrew: brew install nasm pkg-config
#   - No Rust toolchain needed for this script (libdovi is separate)
#
# LGPL compliance notes:
#   --disable-gpl --disable-nonfree ensures a pure LGPL-2.1+ build.
#   We dynamic-link the result as an XCFramework (not a static .a baked into
#   the app binary) so users can relink against a modified FFmpeg per LGPL §4.
#   Publish your exact source + build script and provide object files on request.
#
# Usage:
#   bash Scripts/build_ffmpeg.sh            # build everything
#   FFMPEG_VERSION=7.1 bash Scripts/build_ffmpeg.sh

set -euo pipefail

FFMPEG_VERSION="${FFMPEG_VERSION:-7.1}"
FFMPEG_SRC="ffmpeg-${FFMPEG_VERSION}"
FFMPEG_TARBALL="${FFMPEG_SRC}.tar.bz2"
FFMPEG_URL="https://ffmpeg.org/releases/${FFMPEG_TARBALL}"

# dav1d (BSD-2): the AV1 decoder for files the Apple TV has no AV1 hardware for.
DAV1D_VERSION="${DAV1D_VERSION:-1.5.1}"
DAV1D_SRC="dav1d-${DAV1D_VERSION}"
DAV1D_URL="https://downloads.videolan.org/pub/videolan/dav1d/${DAV1D_VERSION}/${DAV1D_SRC}.tar.xz"
DAV1D_SHA256="401813f1f89fa8fd4295805aa5284d9aed9bc7fc1fdbe554af4292f64cbabe21"

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$(dirname "$SCRIPT_DIR")"

# FFmpeg's build system does not tolerate spaces in paths (config.sh splits on
# them when writing linker flags). Use a space-free directory under $TMPDIR for
# all intermediate build artefacts; only the finished XCFramework is copied back
# into the project tree.
BUILD_DIR="${TMPDIR:-/tmp}"
BUILD_DIR="${BUILD_DIR%/}/HDP_FFmpeg_Build"
# Final destination inside the project (may contain spaces — only the copy
# command runs with this path, never the FFmpeg Makefile).
XCFW_DEST="${ROOT_DIR}/build/xcframeworks"

TVOS_DEPLOYMENT_TARGET="18.0"
SIM_DEPLOYMENT_TARGET="18.0"

# ── Toolchain ────────────────────────────────────────────────────────────────
XCODE_PATH="$(xcode-select -p)"
TVOS_SDK="${XCODE_PATH}/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk"
SIM_SDK="${XCODE_PATH}/Platforms/AppleTVSimulator.platform/Developer/SDKs/AppleTVSimulator.sdk"

check_tools() {
    for tool in nasm pkg-config meson ninja; do
        if ! command -v "$tool" &>/dev/null; then
            echo "❌  Missing: $tool  →  brew install $tool"
            exit 1
        fi
    done
    if [ ! -d "$TVOS_SDK" ]; then
        echo "❌  tvOS SDK not found at $TVOS_SDK — install the tvOS platform in Xcode."
        exit 1
    fi
}

# ── Source ───────────────────────────────────────────────────────────────────
fetch_source() {
    mkdir -p "${BUILD_DIR}/src"
    cd "${BUILD_DIR}/src"
    if [ ! -d "${FFMPEG_SRC}" ]; then
        echo "▶  Downloading FFmpeg ${FFMPEG_VERSION}…"
        curl -LO "${FFMPEG_URL}"
        tar xf "${FFMPEG_TARBALL}"
        rm "${FFMPEG_TARBALL}"
    fi
    if [ ! -d "${DAV1D_SRC}" ]; then
        echo "▶  Downloading dav1d ${DAV1D_VERSION}…"
        curl -LO "${DAV1D_URL}"
        echo "${DAV1D_SHA256}  ${DAV1D_SRC}.tar.xz" | shasum -a 256 -c -
        tar xf "${DAV1D_SRC}.tar.xz"
        rm "${DAV1D_SRC}.tar.xz"
    fi
}

# ── dav1d, static, into the slice's install prefix ───────────────────────────
# FFmpeg's configure finds it there through pkg-config, and merge_dylibs
# force-loads its archive into FFmpeg.framework with FFmpeg's own.
build_dav1d() {
    local SLICE="$1" SYSROOT="$2" TRIPLE="$3"
    local PREFIX="${BUILD_DIR}/${SLICE}/install"
    local CROSS="${BUILD_DIR}/${SLICE}/dav1d-cross.txt"
    mkdir -p "${BUILD_DIR}/${SLICE}"
    cat > "${CROSS}" <<CROSS
[binaries]
c = ['$(xcrun -find clang)', '-arch', 'arm64', '-target', '${TRIPLE}', '-isysroot', '${SYSROOT}']
ar = '$(xcrun -find ar)'
strip = '$(xcrun -find strip)'

[host_machine]
system = 'darwin'
subsystem = 'tvos'
cpu_family = 'aarch64'
cpu = 'arm64'
endian = 'little'
CROSS
    echo "▶  Building dav1d for ${SLICE} (${TRIPLE})…"
    rm -rf "${BUILD_DIR}/${SLICE}/dav1d-build"
    meson setup "${BUILD_DIR}/${SLICE}/dav1d-build" "${BUILD_DIR}/src/${DAV1D_SRC}" \
        --cross-file "${CROSS}" --prefix "${PREFIX}" --libdir lib \
        --buildtype release -Ddebug=true --default-library static \
        -Denable_tools=false -Denable_tests=false -Denable_examples=false
    ninja -C "${BUILD_DIR}/${SLICE}/dav1d-build" install
}

# ── Configure flags shared across both targets ────────────────────────────────
# Demuxers, audio/subtitle decoders, and video decoders only for codecs the
# Apple TV has no hardware decoder for (they are decoded here and encoded to
# HEVC by VideoToolbox).  No H.264/HEVC decoder: those play as they are, and
# with a decoder find_stream_info would decode frames of every file.  No
# network (we feed bytes via AVIOBridge).
COMMON_FLAGS=(
    --disable-everything
    --disable-programs
    --disable-doc
    --disable-avdevice
    --enable-avfilter              # only the deinterlacer, below
    --disable-postproc
    --disable-network
    --disable-gpl
    --disable-nonfree
    --enable-pic
    --enable-cross-compile
    --target-os=darwin
    --arch=arm64

    # Containers we need to demux
    --enable-demuxer=matroska      # MKV / WebM
    --enable-demuxer=mov           # MP4 / MOV / M4V
    --enable-demuxer=mpegts        # TS
    --enable-demuxer=mpegps        # PS / VOB
    --enable-demuxer=avi
    --enable-demuxer=flv
    --enable-demuxer=ogg
    --enable-demuxer=asf
    --enable-demuxer=rm
    --enable-demuxer=concat        # virtual concat for segmented files
    # Raw elementary-stream probes: MPEG-PS (VOB/MPG) identifies an H.264 /
    # HEVC video stream only by probing its payload with these demuxers.
    --enable-demuxer=h264
    --enable-demuxer=hevc
    --enable-demuxer=mpegvideo
    --enable-demuxer=ivf           # raw AV1 / VP9 / VP8
    --enable-demuxer=obu           # raw AV1

    # Video the Apple TV can't decode in hardware: decoded here, encoded to
    # HEVC by VideoToolbox (Core/Engine/Transcode).
    --enable-libdav1d
    --enable-decoder=libdav1d      # AV1
    --enable-decoder=vp9
    --enable-decoder=vp8
    --enable-decoder=mpeg1video
    --enable-decoder=mpeg2video
    --enable-decoder=mpeg4         # MPEG-4 Part 2 (Xvid, DivX 4+)
    --enable-decoder=msmpeg4v1
    --enable-decoder=msmpeg4v2
    --enable-decoder=msmpeg4v3     # DivX 3
    --enable-decoder=h263
    --enable-decoder=flv           # Sorenson H.263
    --enable-decoder=vc1
    --enable-decoder=wmv1
    --enable-decoder=wmv2
    --enable-decoder=wmv3
    --enable-decoder=vp3
    --enable-decoder=theora
    --enable-decoder=mjpeg
    --enable-decoder=prores
    --enable-parser=av1
    --enable-parser=vp9
    --enable-parser=vp8
    --enable-parser=mpegvideo
    --enable-parser=mpeg4video
    --enable-parser=h263
    --enable-parser=vc1
    --enable-parser=mjpeg
    --enable-bsf=vp9_superframe_split   # the VP9 decoder needs it

    # Audio decoders
    --enable-decoder=ac3           # Dolby Digital
    --enable-decoder=eac3          # Dolby Digital Plus (E-AC-3 + JOC/Atmos)
    --enable-decoder=truehd        # TrueHD / MLP (see §8 license note)
    --enable-decoder=mlp
    --enable-decoder=dca           # DTS (see §8 license note — defer for App Store)
    --enable-decoder=aac
    --enable-decoder=aac_latm
    --enable-decoder=mp3
    --enable-decoder=mp2           # MPEG-1 Layer II: DVB recordings, VOB/MPG
    --enable-decoder=mp2float
    --enable-decoder=mp1
    --enable-decoder=flac
    --enable-decoder=opus
    --enable-decoder=vorbis
    --enable-decoder=alac
    --enable-decoder=pcm_s16le
    --enable-decoder=pcm_s16be
    --enable-decoder=pcm_s24le
    --enable-decoder=pcm_s24be
    --enable-decoder=pcm_s32le
    --enable-decoder=pcm_bluray    # lpcm in remux MKVs
    --enable-decoder=pcm_dvd       # lpcm in VOB
    --enable-decoder=pcm_u8        # old AVI
    --enable-decoder=pcm_f32le
    --enable-decoder=pcm_alaw
    --enable-decoder=pcm_mulaw
    --enable-decoder=adpcm_ms      # old AVI
    --enable-decoder=adpcm_ima_wav
    --enable-decoder=wmav1         # ASF / WMV audio
    --enable-decoder=wmav2
    --enable-decoder=wmapro

    # Subtitle decoders
    --enable-decoder=pgssub        # PGS (Blu-ray) — ubiquitous in remux MKVs
    --enable-decoder=dvdsub        # VOBSUB
    --enable-decoder=dvbsub
    --enable-decoder=ass
    --enable-decoder=ssa
    --enable-decoder=srt
    --enable-decoder=subrip
    --enable-decoder=webvtt
    --enable-decoder=mov_text
    --enable-decoder=microdvd
    --enable-decoder=text

    # Parsers for audio + HEVC bitstream (NAL boundary detection, DTS detect)
    --enable-parser=hevc           # HEVC NAL splitter — needed for RPU work
    --enable-parser=h264
    --enable-parser=ac3
    --enable-parser=eac3
    --enable-parser=dca
    --enable-parser=aac
    --enable-parser=aac_latm
    --enable-parser=flac
    --enable-parser=opus
    --enable-parser=vorbis
    --enable-parser=mpegaudio
    --enable-parser=mlp

    # Muxers — Path B remuxes demuxed packets into fragmented MP4 via movenc
    # (DEMUX_ENGINE_PLAN.md §6.2 / Revision 2).  Without these, the
    # avformat_alloc_output_context2(..., "mp4") call returns NULL and the whole
    # Path B muxer fails to initialise.  movenc is LGPL-clean.
    --enable-muxer=mov             # shared movenc core
    --enable-muxer=mp4             # fragmented MP4 output (dvcC / dec3 / dac3)

    # Bitstream filters.
    #   hevc_mp4toannexb / h264_mp4toannexb — Path A's VTDecompressionSession
    #     needs Annex-B; Path B keeps the native length-prefixed (MP4) framing.
    #   extract_extradata — pull in-band VPS/SPS/PPS into codecpar->extradata.
    --enable-bsf=hevc_mp4toannexb
    --enable-bsf=h264_mp4toannexb
    --enable-bsf=extract_extradata

    # Encoders — TrueHD / DTS have no Apple TV passthrough path, so Path B
    # decodes them to PCM and re-encodes to E-AC-3 (Revision 2 audio decision),
    # which movenc then muxes with a dec3 box like native Dolby Digital Plus.
    # Both encoders are FFmpeg-native and LGPL-clean (no GPL/libfdk dependency).
    --enable-encoder=ac3
    --enable-encoder=eac3

    # Protocols — only file + custom (AVIOBridge). No network stacks from FFmpeg.
    --enable-protocol=file
    --enable-protocol=pipe
    --enable-protocol=custom       # avio_alloc_context (our AVIOBridge)

    # swresample for audio decode → PCM conversion
    --enable-swresample

    # Disable bitcode (dead since Xcode 14)
    --disable-bzlib                # avoid dependency; unused

    # Interlaced sources (DVD, broadcast MPEG-2 and VC-1) are deinterlaced
    # before they are encoded: bwdif, one frame out per frame in.
    --enable-filter=buffer
    --enable-filter=buffersink
    --enable-filter=bwdif
)

# ── Build for one slice ───────────────────────────────────────────────────────
build_slice() {
    local SLICE="$1"      # "device" or "simulator"
    local SDK="$2"
    local SYSROOT="$3"
    local DEPLOYMENT_TARGET="$4"
    # $5 onward reserved; --enable-simulator was invalid and is now removed

    local SLICE_DIR="${BUILD_DIR}/${SLICE}"
    mkdir -p "${SLICE_DIR}"

    local CC="$(xcrun -sdk "${SDK}" -find clang)"
    local AR="$(xcrun -sdk "${SDK}" -find ar)"

    # For the simulator slice we must use the explicit target triple so the
    # linker produces a appletvsimulator (not appletvos) Mach-O.  FFmpeg has
    # no --enable-simulator flag; the distinction is made entirely via CFLAGS.
    if [[ "${SDK}" == "appletvsimulator" ]]; then
        local TARGET_TRIPLE="arm64-apple-tvos${DEPLOYMENT_TARGET}-simulator"
    else
        local TARGET_TRIPLE="arm64-apple-tvos${DEPLOYMENT_TARGET}"
    fi

    local CFLAGS="-arch arm64 -target ${TARGET_TRIPLE} -isysroot ${SYSROOT}"
    local LDFLAGS="-arch arm64 -target ${TARGET_TRIPLE} -isysroot ${SYSROOT}"

    rm -rf "${SLICE_DIR}/install"
    build_dav1d "${SLICE}" "${SYSROOT}" "${TARGET_TRIPLE}"
    # Only the slice's own libraries (dav1d), never the host's.
    export PKG_CONFIG_LIBDIR="${SLICE_DIR}/install/lib/pkgconfig"
    export PKG_CONFIG_PATH="${PKG_CONFIG_LIBDIR}"

    echo "▶  Configuring FFmpeg for ${SLICE} (${TARGET_TRIPLE})…"
    cd "${BUILD_DIR}/src/${FFMPEG_SRC}"
    ./configure \
        "${COMMON_FLAGS[@]}" \
        --pkg-config-flags="--static" \
        --prefix="${SLICE_DIR}/install" \
        --cc="${CC}" \
        --ar="${AR}" \
        --sysroot="${SYSROOT}" \
        --extra-cflags="${CFLAGS}" \
        --extra-ldflags="${LDFLAGS}" \
        --enable-static \
        --disable-shared \
        2>&1 | tail -20

    local JOBS
    JOBS="$(sysctl -n hw.logicalcpu 2>/dev/null || getconf _NPROCESSORS_ONLN 2>/dev/null || echo 8)"
    echo "▶  Building FFmpeg for ${SLICE} (${JOBS} jobs)…"
    make clean
    make -j"${JOBS}"
    make install
}

# ── Assemble XCFramework ──────────────────────────────────────────────────────
assemble_xcframework() {
    echo "▶  Assembling FFmpeg.xcframework…"
    rm -rf "${XCFW_DEST}/FFmpeg.xcframework"
    mkdir -p "${XCFW_DEST}"

    # We ship a single merged dylib per slice. In a real build you'd merge the
    # individual per-library dylibs (libavformat, libavcodec, libswresample,
    # libswscale, libavutil) into one fat dylib using `libtool -dynamic` or
    # leave them as separate frameworks. For clarity we build them as a
    # framework bundle per library and group in one XCFramework.

    # Merge all .dylibs for device slice
    merge_dylibs "device" "appletvos"
    # Merge all .dylibs for simulator slice
    merge_dylibs "simulator" "appletvsimulator"

    # xcodebuild also chokes on spaces in the -output path, so assemble in the
    # space-free BUILD_DIR first, then copy to the project tree.
    local XCFW_TMP="${BUILD_DIR}/FFmpeg.xcframework"
    rm -rf "${XCFW_TMP}"

    xcodebuild -create-xcframework \
        -framework "${BUILD_DIR}/device/FFmpeg.framework" \
        -debug-symbols "${BUILD_DIR}/device/FFmpeg.framework.dSYM" \
        -framework "${BUILD_DIR}/simulator/FFmpeg.framework" \
        -debug-symbols "${BUILD_DIR}/simulator/FFmpeg.framework.dSYM" \
        -output "${XCFW_TMP}"

    # Copy the finished XCFramework into the project (spaces in path are fine here).
    mkdir -p "${XCFW_DEST}"
    rm -rf "${XCFW_DEST}/FFmpeg.xcframework"
    cp -R "${XCFW_TMP}" "${XCFW_DEST}/FFmpeg.xcframework"

    echo "✅  FFmpeg.xcframework → ${XCFW_DEST}/FFmpeg.xcframework"
}

# dSYM of one slice, next to the framework: ${BUILD_DIR}/<slice>/FFmpeg.framework.dSYM.
# Must run right after the link: the dylib's debug map points at the .a files in
# ${INSTALL}/lib (FFmpeg and dav1d), and dsymutil refuses a member whose timestamp
# changed since. Crash reports name images by UUID, so the dSYM must carry the
# binary's UUID, or the symbols service has nothing to match.
make_dsym() {
    local SLICE="$1"
    local FW_DIR="$2"
    local DSYM="${BUILD_DIR}/${SLICE}/FFmpeg.framework.dSYM"
    rm -rf "${DSYM}"
    xcrun dsymutil "${FW_DIR}/FFmpeg" -o "${DSYM}" 2> "${BUILD_DIR}/${SLICE}/dsymutil.log"
    local U_BIN U_SYM
    U_BIN="$(dwarfdump --uuid "${FW_DIR}/FFmpeg" | awk '{print $2}')"
    U_SYM="$(dwarfdump --uuid "${DSYM}" | awk '{print $2}')"
    if [ -z "${U_BIN}" ] || [ "${U_BIN}" != "${U_SYM}" ]; then
        echo "❌  ${SLICE}: dSYM UUID (${U_SYM}) does not match the binary (${U_BIN})"
        exit 1
    fi
    if [ "$(du -sk "${DSYM}" | cut -f1)" -lt 1024 ]; then
        echo "❌  ${SLICE}: dSYM is nearly empty; no debug info reached the dylib"
        exit 1
    fi
    echo "▶  ${SLICE} dSYM: ${U_SYM}"
}

merge_dylibs() {
    local SLICE="$1"
    local PLATFORM="$2"
    local INSTALL="${BUILD_DIR}/${SLICE}/install"
    local FW_DIR="${BUILD_DIR}/${SLICE}/FFmpeg.framework"
    local HEADERS_DIR="${FW_DIR}/Headers"

    rm -rf "${FW_DIR}"
    mkdir -p "${HEADERS_DIR}"
    mkdir -p "${FW_DIR}/Modules"

    # Build is static (.a). To get ONE self-contained dynamic framework binary we
    # -force_load every FFmpeg archive (so all their object files / symbols are
    # pulled into the dylib) and link FFmpeg's own external deps + the Apple
    # frameworks it references. NOTE: plain `clang -dynamiclib a.dylib b.dylib`
    # does NOT copy symbols — it yields an empty stub — which was the bug here.
    local FORCE_LOAD=()
    for a in "${INSTALL}/lib/"*.a; do
        [ -f "$a" ] && FORCE_LOAD+=("-Wl,-force_load,${a}")
    done
    if [ ${#FORCE_LOAD[@]} -eq 0 ]; then
        echo "❌  No static archives found in ${INSTALL}/lib — did 'make install' run?"
        exit 1
    fi

    # External libs FFmpeg's configure determined it needs (zlib, iconv, m, …).
    local EXTRALIBS
    EXTRALIBS="$(grep -h '^EXTRALIBS=' "${BUILD_DIR}/src/${FFMPEG_SRC}/ffbuild/config.mak" 2>/dev/null | head -1 | sed 's/^EXTRALIBS=//')"

    # Determine the clang for this platform so the correct SDK/target is used.
    local CLANG
    CLANG="$(xcrun -sdk "${PLATFORM}" -find clang)"

    # Reuse the same target triple that build_slice used.
    if [[ "${PLATFORM}" == "appletvsimulator" ]]; then
        local TRIPLE="arm64-apple-tvos${TVOS_DEPLOYMENT_TARGET}-simulator"
        local SYSROOT="${SIM_SDK}"
    else
        local TRIPLE="arm64-apple-tvos${TVOS_DEPLOYMENT_TARGET}"
        local SYSROOT="${TVOS_SDK}"
    fi

    "${CLANG}" -dynamiclib \
        -target "${TRIPLE}" \
        -isysroot "${SYSROOT}" \
        -install_name '@rpath/FFmpeg.framework/FFmpeg' \
        "${FORCE_LOAD[@]}" \
        ${EXTRALIBS} \
        -lz -liconv \
        -framework CoreFoundation -framework CoreMedia -framework CoreVideo \
        -framework AudioToolbox -framework VideoToolbox \
        -o "${FW_DIR}/FFmpeg"

    make_dsym "${SLICE}" "${FW_DIR}"

    # Privacy manifest: an SDK's own bundle has to declare the required-reason
    # APIs it calls (fstat/lstat, clock_gettime). Not the app's manifest.
    cp "${SCRIPT_DIR}/FFmpeg.PrivacyInfo.xcprivacy" "${FW_DIR}/PrivacyInfo.xcprivacy"
    plutil -lint "${FW_DIR}/PrivacyInfo.xcprivacy" >/dev/null

    # Copy public headers
    for lib in libavformat libavcodec libavfilter libavutil libswresample libswscale; do
        [ -d "${INSTALL}/include/${lib}" ] && \
            cp -R "${INSTALL}/include/${lib}" "${HEADERS_DIR}/"
    done

    # Supported-platform string for the Info.plist (used by installd).
    local SUPPORTED_PLATFORM
    if [[ "${PLATFORM}" == "appletvsimulator" ]]; then
        SUPPORTED_PLATFORM="AppleTVSimulator"
    else
        SUPPORTED_PLATFORM="AppleTVOS"
    fi

    # Write the Info.plist. CFBundleExecutable is REQUIRED — without it installd
    # rejects the embedded framework ("missing or invalid CFBundleExecutable").
    cat > "${FW_DIR}/Info.plist" <<PLIST
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"><dict>
  <key>CFBundleDevelopmentRegion</key><string>en</string>
  <key>CFBundleExecutable</key><string>FFmpeg</string>
  <key>CFBundleIdentifier</key><string>org.ffmpeg.FFmpeg</string>
  <key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
  <key>CFBundleName</key><string>FFmpeg</string>
  <key>CFBundlePackageType</key><string>FMWK</string>
  <key>CFBundleShortVersionString</key><string>${FFMPEG_VERSION}</string>
  <key>CFBundleVersion</key><string>${FFMPEG_VERSION}</string>
  <key>CFBundleSupportedPlatforms</key><array><string>${SUPPORTED_PLATFORM}</string></array>
  <key>MinimumOSVersion</key><string>${TVOS_DEPLOYMENT_TARGET}</string>
</dict></plist>
PLIST

    # Module map for Clang module import. The framework has no single flat
    # umbrella header — its public API lives in nested directories
    # (Headers/libavutil/…, Headers/libavformat/…, etc.) — so we use a
    # DIRECTORY umbrella, which exposes every header under Headers/.
    # (Do NOT reference FFmpegBridge.h here: that header belongs to the separate
    #  FFmpegBridge Swift-interop module and is not copied into this framework.)
    cat > "${FW_DIR}/Modules/module.modulemap" <<MODMAP
framework module FFmpeg {
    umbrella "Headers"

    // Exclude hardware-accel headers that pull in non-Apple SDKs
    // (Windows D3D, Linux VDPAU/VAAPI, Intel QSV, CUDA, OpenCL, Vulkan).
    // They are irrelevant on tvOS (we use VideoToolbox) and would otherwise
    // break the directory-umbrella module build (e.g. d3d11va.h -> <d3d11.h>).
    exclude header "libavcodec/d3d11va.h"
    exclude header "libavcodec/dxva2.h"
    exclude header "libavcodec/qsv.h"
    exclude header "libavcodec/vdpau.h"
    exclude header "libavutil/hwcontext_cuda.h"
    exclude header "libavutil/hwcontext_d3d11va.h"
    exclude header "libavutil/hwcontext_d3d12va.h"
    exclude header "libavutil/hwcontext_dxva2.h"
    exclude header "libavutil/hwcontext_opencl.h"
    exclude header "libavutil/hwcontext_qsv.h"
    exclude header "libavutil/hwcontext_vaapi.h"
    exclude header "libavutil/hwcontext_vdpau.h"
    exclude header "libavutil/hwcontext_vulkan.h"

    export *
    module * { export * }
}
MODMAP
}

# ── Main ─────────────────────────────────────────────────────────────────────
main() {
    echo "▶  Build dir (space-free): ${BUILD_DIR}"
    echo "▶  Output dest: ${XCFW_DEST}"
    check_tools
    fetch_source

    build_slice "device" "appletvos" "${TVOS_SDK}" "${TVOS_DEPLOYMENT_TARGET}"
    build_slice "simulator" "appletvsimulator" "${SIM_SDK}" "${SIM_DEPLOYMENT_TARGET}"

    assemble_xcframework
    echo ""
    echo "FFmpeg dSYM (device): $(dwarfdump --uuid "${BUILD_DIR}/device/FFmpeg.framework.dSYM" | awk '{print $2}')"
    echo "  git add -f build/xcframeworks/FFmpeg.xcframework   (build/ is git-ignored)"
    echo ""
    echo "Next: add build/xcframeworks/FFmpeg.xcframework to your Xcode project"
    echo "and set it as an Embed & Sign dependency of the Astrape target."
    echo ""
    echo "LGPL compliance checklist:"
    echo "  ✓ --disable-gpl --disable-nonfree (pure LGPL build)"
    echo "  ✓ Shipped as dynamic framework (relinking possible)"
    echo "  ✓ Publish this script + exact FFmpeg source on request"
    echo "  ✓ Provide object files on request"
    echo "  ✓ Include LGPL text in-app (Settings → Acknowledgements)"
}

main "$@"