oak-team/oak-editor
3
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ci/cd: drop vcpkg; distro packages + the project FFmpeg everywhere

Browse Source 
Linux/macOS now follow the local-build path in CI and CD:
tooling/install-deps.sh installs the distro codec packages and
tooling/ffmpeg/build-ffmpeg.sh builds the pinned static FFmpeg into
.cache/ffmpeg, with FFMPEG_DIR/PKG_CONFIG_PATH pointing there. CI caches
the built tree keyed on the script, distro and arch (the
.build-complete marker rejects partial saves); CD rebuilds it from
scratch per its no-cache policy. Windows keeps BtbN's prebuilt shared
archive, downloaded from the release page and verified against its
checksums.sha256 — no pkg-config is needed there any more.

vcpkg.json, the release-only overlay triplets and the x264 mirror
overlay are deleted; docs/build.md describes the new flow.
This commit is contained in:
Mike-Solar
2026-09-24 18:50:00 +08:00
parent 725a1d4da0
commit 563a3625ca
17 changed files with 102 additions and 633 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/cd.yml
+34 -87
View File
@@ -12,9 +12,9 @@ permissions:
# One matrix, seven platforms, the same environments CI tests in (see
# .github/workflows/ci.yml): Debian 12 / Fedora 43 / Arch / openKylin x64
# and arm64 containers plus the macOS and Windows hosts. Every package is
# built from scratch — no vcpkg/cargo caches: a restored vcpkg_installed
# or target tree has masked packaging problems before (stale ports,
# missing tools), and a release must not depend on restored state.
# built from scratch — no FFmpeg/cargo caches: a restored tree has
# masked packaging problems before (stale ports, missing tools), and a
# release must not depend on restored state.
jobs:
package:
name: Package (${{ matrix.name }})
@@ -23,7 +23,7 @@ jobs:
# "options":...}); the empty string means "run on the host"
# (actions/runner#265 allows an empty container value).
container: ${{ matrix.container != '' && fromJSON(matrix.container) || '' }}
# Cold vcpkg install + release build + packaging.
# Cold FFmpeg build + release build + packaging.
timeout-minutes: 150
strategy:
fail-fast: false
@@ -88,7 +88,7 @@ jobs:
steps:
# The container images are bare (Fedora/Arch even lack git);
# checkout and vcpkg need git/curl. First step of the job, so the
# checkout needs git/curl. First step of the job, so the
# package lists are still fresh.
- name: Bootstrap container (git, curl, wget)
if: matrix.container != ''
@@ -107,7 +107,7 @@ jobs:
# their own repo and build as path dependencies of oakapp.
submodules: true
# Defender's real-time scanning slows the MSVC/vcpkg build down
# Defender's real-time scanning slows the MSVC build down
# badly; disable it for the job and keep exclusions as the fallback
# when policy blocks the change.
- name: Disable Windows Defender scanning
@@ -125,8 +125,7 @@ jobs:
foreach ($path in @(
$env:GITHUB_WORKSPACE,
"$env:USERPROFILE\.cargo",
"$env:USERPROFILE\.rustup",
"$env:LOCALAPPDATA\vcpkg"
"$env:USERPROFILE\.rustup"
)) {
Add-MpPreference -ExclusionPath $path -ErrorAction SilentlyContinue
}
@@ -157,7 +156,7 @@ jobs:
uses: dtolnay/rust-toolchain@stable
with:
# The Windows build is MSVC-ABI (the runner carries VS 2026):
# vcpkg's FFmpeg and the vendored OCIO build both want it.
# The prebuilt FFmpeg and the vendored OCIO build both want it.
toolchain: ${{ matrix.platform == 'windows' && 'stable-x86_64-pc-windows-msvc' || 'stable' }}
# ------------------------------------------------------------------
@@ -234,10 +233,10 @@ jobs:
if: matrix.platform == 'macos'
run: |
# Homebrew's pkgconf installs a `pkg-config` symlink, which is
# the name crates/oak-ffmpeg-link/build.rs invokes; nasm is what
# vcpkg's ffmpeg port requires to build (FFmpeg libraries come
# from the vcpkg manifest). librsvg stays for rsvg-convert (app
# icon) and is bundled into the .app by the dylib script.
# the name crates/oak-ffmpeg-link/build.rs invokes; nasm is what the
# project FFmpeg build (tooling/ffmpeg/build-ffmpeg.sh) requires.
# librsvg stays for rsvg-convert (app icon) and is bundled into
# the .app by the dylib script.
brew install cmake pkg-config nasm librsvg autoconf automake libtool autoconf-archive
# Windows uses BtbN's prebuilt FFmpeg (GPL, shared): the archive
@@ -247,8 +246,8 @@ jobs:
# links these builds). Downloaded from his release page and
# verified against the checksums.sha256 published in the same
# release; nothing is mirrored here, so provenance stays upstream.
# The alternative — a cold vcpkg FFmpeg build — costs ~40 minutes
# per run on this platform.
# The alternative — a source build — costs ~40 minutes per run on
# this platform.
- name: Install prebuilt FFmpeg (Windows)
if: matrix.platform == 'windows'
shell: pwsh
@@ -272,56 +271,22 @@ jobs:
Move-Item $inner.FullName "$root\ffmpeg"
# ------------------------------------------------------------------
# vcpkg (manifest mode) — built from scratch, no caches
# FFmpeg — built from source with the distro's codec packages
# (Linux/macOS) or the prebuilt archive (Windows), no caches
# ------------------------------------------------------------------
# Bootstrap a fresh clone rather than leaning on whatever vcpkg the
# image carries: `builtin-baseline`/`overrides` are only honored by
# a recent vcpkg-tool, and every platform must behave alike.
- name: Bootstrap vcpkg
# The Linux/macOS jobs follow the local-build path
# (tooling/install-deps.sh + tooling/ffmpeg/build-ffmpeg.sh); the
# release policy is a from-scratch build, so nothing is restored
# from a cache here.
- name: Install FFmpeg dependencies
if: matrix.platform != 'windows'
shell: bash
run: |
git clone https://github.com/microsoft/vcpkg.git .cache/vcpkg
.cache/vcpkg/bootstrap-vcpkg.sh -disableMetrics
echo "$PWD/.cache/vcpkg" >> "$GITHUB_PATH"
echo "VCPKG_ROOT=$PWD/.cache/vcpkg" >> "$GITHUB_ENV"
run: tooling/install-deps.sh
- name: Bootstrap vcpkg (Windows)
if: matrix.platform == 'windows'
shell: pwsh
run: |
git clone https://github.com/microsoft/vcpkg.git "$env:GITHUB_WORKSPACE\.cache\vcpkg"
& "$env:GITHUB_WORKSPACE\.cache\vcpkg\bootstrap-vcpkg.bat" -disableMetrics
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
"$env:GITHUB_WORKSPACE\.cache\vcpkg" >> $env:GITHUB_PATH
"VCPKG_ROOT=$env:GITHUB_WORKSPACE\.cache\vcpkg" >> $env:GITHUB_ENV
- name: Install dependencies (vcpkg manifest)
- name: Build FFmpeg
if: matrix.platform != 'windows'
shell: bash
run: |
# Source tarballs come from third-party hosts (x264 lives on
# code.videolan.org); a transient connection failure aborts the
# whole install — vcpkg refuses to retry that class of curl
# error — so retry here.
for attempt in 1 2 3; do
vcpkg install --triplet ${{ matrix.triplet }} --overlay-triplets tooling/vcpkg-triplets/release --overlay-ports tooling/vcpkg-ports && exit 0
echo "vcpkg install failed (attempt $attempt); retrying"
sleep 15
done
exit 1
- name: Install dependencies (vcpkg manifest, Windows)
if: matrix.platform == 'windows'
shell: pwsh
run: |
for ($i = 1; $i -le 3; $i++) {
vcpkg install --triplet ${{ matrix.triplet }} --overlay-triplets tooling/vcpkg-triplets/release --overlay-ports tooling/vcpkg-ports
if ($LASTEXITCODE -eq 0) { exit 0 }
Write-Host "vcpkg install failed (attempt $i); retrying"
Start-Sleep -Seconds 15
}
exit 1
run: tooling/ffmpeg/build-ffmpeg.sh
# ------------------------------------------------------------------
# Build environment
@@ -340,17 +305,9 @@ jobs:
echo "CXX=clang++"
} >> "$GITHUB_ENV"
bash tooling/ocio-env.sh >> "$GITHUB_ENV"
prefix="$PWD/vcpkg_installed/${{ matrix.triplet }}"
echo "FFMPEG_DIR=$prefix" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$prefix/lib/pkgconfig" >> "$GITHUB_ENV"
echo "$prefix/tools/pkgconf" >> "$GITHUB_PATH"
echo "LD_LIBRARY_PATH=$prefix/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" >> "$GITHUB_ENV"
# The Debian-family packaging tools resolve the ELF needs through
# ldd (dpkg-shlibdeps, linuxdeploy): register the vcpkg libs with
# the dynamic linker so `libva-drm.so.2` is found when a package
# is assembled.
echo "$prefix/lib" > /etc/ld.so.conf.d/oak-vcpkg.conf
ldconfig
ffmpeg="$PWD/.cache/ffmpeg"
echo "FFMPEG_DIR=$ffmpeg" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$ffmpeg/lib/pkgconfig" >> "$GITHUB_ENV"
- name: Configure build environment (macOS)
if: matrix.platform == 'macos'
@@ -359,31 +316,25 @@ jobs:
# Vendored static OCIO (same as every non-Windows platform via
# tooling/ocio-env.sh); no OCIO_INSTALL_DIR override.
bash tooling/ocio-env.sh >> "$GITHUB_ENV"
prefix="$PWD/vcpkg_installed/${{ matrix.triplet }}"
echo "FFMPEG_DIR=$prefix" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$prefix/lib/pkgconfig" >> "$GITHUB_ENV"
echo "$prefix/tools/pkgconf" >> "$GITHUB_PATH"
ffmpeg="$PWD/.cache/ffmpeg"
echo "FFMPEG_DIR=$ffmpeg" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$ffmpeg/lib/pkgconfig" >> "$GITHUB_ENV"
- name: Configure build environment (Windows)
if: matrix.platform == 'windows'
shell: pwsh
run: |
# FFmpeg comes from the prebuilt archive extracted above (the
# manifest no longer installs it on Windows); vcpkg only
# provides pkgconf for oak-ffmpeg-link's build script.
$prefix = "$env:GITHUB_WORKSPACE\vcpkg_installed\${{ matrix.triplet }}"
# FFmpeg comes from the prebuilt archive extracted above.
$ffmpeg = "$env:GITHUB_WORKSPACE\.cache\ffmpeg"
"FFMPEG_DIR=$ffmpeg" >> $env:GITHUB_ENV
"PKG_CONFIG_PATH=$ffmpeg\lib\pkgconfig" >> $env:GITHUB_ENV
"$ffmpeg\bin" >> $env:GITHUB_PATH
"$prefix\tools\pkgconf" >> $env:GITHUB_PATH
# Bundled OCIO: ocio-sys' vendored sources build with the MSVC
# toolchain (what they need — the MSYS2 package was the
# workaround, not the preference), so no OCIO_INSTALL_DIR and
# no OCIO_RS_NO_MSVC_INCLUDES anywhere.
"OCIO_RS_ENABLE_REAL=1" >> $env:GITHUB_ENV
"OCIO_RS_LINK=static" >> $env:GITHUB_ENV
vcpkg list
- name: Install cargo-packager
if: matrix.distro == 'debian' || matrix.platform != 'linux'
@@ -424,8 +375,7 @@ jobs:
case "${{ matrix.distro }}" in
debian)
# The general Debian-family package, labeled "+debian".
VCPKG_LIB="$PWD/vcpkg_installed/${{ matrix.triplet }}/lib" \
tooling/package/build-deb.sh "$VERSION" debian
tooling/package/build-deb.sh "$VERSION" debian
# appimagetool self-extracts instead of mounting (containers
# have no FUSE).
APPIMAGE_EXTRACT_AND_RUN=1 cargo packager --release --formats appimage
@@ -438,11 +388,8 @@ jobs:
;;
openkylin)
# The openKylin build, labeled "+openkylin"; dpkg-shlibdeps
# resolves the runtime deps against openKylin's own repos
# and the vcpkg libva/libdrm ship next to the app (openKylin's
# system libva predates FFmpeg's vaMapBuffer2).
VCPKG_LIB="$PWD/vcpkg_installed/${{ matrix.triplet }}/lib" \
tooling/package/build-deb.sh "$VERSION" openkylin
# resolves the runtime deps against openKylin's own repos.
tooling/package/build-deb.sh "$VERSION" openkylin
;;
esac
.github/workflows/ci.yml
+56 -121
View File
@@ -29,7 +29,7 @@ jobs:
# (actions/runner#265 allows an empty container value).
container: ${{ matrix.container != '' && fromJSON(matrix.container) || '' }}
# The Test step's watchdog caps a hung suite at 30 min; leave a cold
# vcpkg install + full compile room beyond that.
# FFmpeg build + full compile room beyond that.
timeout-minutes: 90
strategy:
fail-fast: false
@@ -87,7 +87,7 @@ jobs:
steps:
# The container images are bare (Fedora/Arch even lack git);
# checkout and vcpkg need git/curl, and WarpCache needs wget inside
# checkout needs git/curl, and WarpCache needs wget inside
# a container (its README requires it). First step of the job, so
# the package lists are still fresh.
- name: Bootstrap container (git, curl, wget)
@@ -108,7 +108,7 @@ jobs:
submodules: true
# Taste the disk before the toolchains land: Defender scans every
# file the vcpkg/cargo builds touch (tens of thousands of small
# file the cargo/FFmpeg builds touch (tens of thousands of small
# writes), which dominates a cold Windows build. The runner is an
# ephemeral VM, so the scanner is turned off for the job
# (exclusions are kept as a fallback for images where real-time
@@ -128,8 +128,7 @@ jobs:
foreach ($path in @(
$env:GITHUB_WORKSPACE,
"$env:USERPROFILE\.cargo",
"$env:USERPROFILE\.rustup",
"$env:LOCALAPPDATA\vcpkg"
"$env:USERPROFILE\.rustup"
)) {
Add-MpPreference -ExclusionPath $path -ErrorAction SilentlyContinue
}
@@ -160,7 +159,7 @@ jobs:
uses: dtolnay/rust-toolchain@stable
with:
# The Windows build is MSVC-ABI (the runner carries VS 2026):
# vcpkg's FFmpeg and the vendored OCIO build both want it.
# The prebuilt FFmpeg and the vendored OCIO build both want it.
toolchain: ${{ matrix.platform == 'windows' && 'stable-x86_64-pc-windows-msvc' || 'stable' }}
# ------------------------------------------------------------------
@@ -237,9 +236,9 @@ jobs:
if: matrix.platform == 'macos'
run: |
# Homebrew's pkgconf installs a `pkg-config` symlink, which is
# the name crates/oak-ffmpeg-link/build.rs invokes; nasm is what
# vcpkg's ffmpeg port requires to build (FFmpeg libraries come
# from the vcpkg manifest). librsvg is CD's icon renderer.
# the name crates/oak-ffmpeg-link/build.rs invokes; nasm is what the
# project FFmpeg build (tooling/ffmpeg/build-ffmpeg.sh) requires.
# librsvg is CD's icon renderer.
brew install cmake pkg-config nasm librsvg autoconf automake libtool autoconf-archive
# Windows uses BtbN's prebuilt FFmpeg (GPL, shared): the archive
@@ -249,8 +248,8 @@ jobs:
# links these builds). Downloaded from his release page and
# verified against the checksums.sha256 published in the same
# release; nothing is mirrored here, so provenance stays upstream.
# The alternative — a cold vcpkg FFmpeg build — costs ~40 minutes
# per run on this platform.
# The alternative — a source build — costs ~40 minutes per run on
# this platform.
- name: Install prebuilt FFmpeg (Windows)
if: matrix.platform == 'windows'
shell: pwsh
@@ -274,39 +273,25 @@ jobs:
Move-Item $inner.FullName "$root\ffmpeg"
# ------------------------------------------------------------------
# vcpkg (manifest mode) + caches
# FFmpeg + caches
# ------------------------------------------------------------------
# Bootstrap a fresh clone rather than leaning on whatever vcpkg the
# image carries: `builtin-baseline`/`overrides` are only honored by
# a recent vcpkg-tool, and every platform must behave alike.
- name: Bootstrap vcpkg
# The Linux/macOS jobs build the project FFmpeg from source with the
# distro's codec packages — the same path local builds use
# (tooling/install-deps.sh + tooling/ffmpeg/build-ffmpeg.sh; the
# latter also drives the vendored static OCIO). Windows uses the
# prebuilt archive downloaded above.
- name: Install FFmpeg dependencies
if: matrix.platform != 'windows'
shell: bash
run: |
git clone https://github.com/microsoft/vcpkg.git .cache/vcpkg
.cache/vcpkg/bootstrap-vcpkg.sh -disableMetrics
echo "$PWD/.cache/vcpkg" >> "$GITHUB_PATH"
echo "VCPKG_ROOT=$PWD/.cache/vcpkg" >> "$GITHUB_ENV"
run: tooling/install-deps.sh
- name: Bootstrap vcpkg (Windows)
if: matrix.platform == 'windows'
shell: pwsh
run: |
git clone https://github.com/microsoft/vcpkg.git "$env:GITHUB_WORKSPACE\.cache\vcpkg"
& "$env:GITHUB_WORKSPACE\.cache\vcpkg\bootstrap-vcpkg.bat" -disableMetrics
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
"$env:GITHUB_WORKSPACE\.cache\vcpkg" >> $env:GITHUB_PATH
"VCPKG_ROOT=$env:GITHUB_WORKSPACE\.cache\vcpkg" >> $env:GITHUB_ENV
# The archives dir is vcpkg's binary cache: a manifest bump then
# rebuilds only what changed. Every run saves under a fresh key (so
# an existing cache is updated, never a save failure) and restores
# the newest matching entry through `restore-keys`. WarpBuild's
# cache service backs the Linux jobs (the GitHub Actions cache
# quota is full); macOS/Windows keep actions/cache.
- name: Restore vcpkg artifacts (WarpCache)
# The built FFmpeg is cached as a whole (keyed on the script, distro
# and arch): a cache hit skips the ~10 minute build. The
# `.build-complete` marker distinguishes a finished build from a
# partial cache save; without it the tree is rebuilt.
- name: Restore FFmpeg (WarpCache)
if: matrix.platform == 'linux'
id: vcpkg-cache
id: ffmpeg-cache
uses: WarpBuilds/cache/restore@v2
# A job container does not inherit the runner environment;
# WarpCache authenticates with this token (README: "Running
@@ -314,80 +299,49 @@ jobs:
env:
WARPBUILD_RUNNER_VERIFICATION_TOKEN: ${{ env.WARPBUILD_RUNNER_VERIFICATION_TOKEN }}
with:
path: |
vcpkg_installed
~/.cache/vcpkg/archives
key: vcpkg-${{ matrix.distro }}-${{ matrix.triplet }}-${{ hashFiles('vcpkg.json') }}-${{ github.run_id }}-${{ github.run_attempt }}
path: .cache/ffmpeg
key: ffmpeg-${{ matrix.distro }}-${{ matrix.arch }}-${{ hashFiles('tooling/ffmpeg/build-ffmpeg.sh') }}-${{ github.run_id }}-${{ github.run_attempt }}
restore-keys: |
vcpkg-${{ matrix.distro }}-${{ matrix.triplet }}-${{ hashFiles('vcpkg.json') }}-
vcpkg-${{ matrix.distro }}-${{ matrix.triplet }}-
ffmpeg-${{ matrix.distro }}-${{ matrix.arch }}-${{ hashFiles('tooling/ffmpeg/build-ffmpeg.sh') }}-
ffmpeg-${{ matrix.distro }}-${{ matrix.arch }}-
- name: Restore vcpkg artifacts (GitHub)
if: matrix.platform != 'linux'
id: vcpkg-cache-github
- name: Restore FFmpeg (GitHub)
if: matrix.platform == 'macos'
id: ffmpeg-cache-github
uses: actions/cache/restore@v6
with:
path: |
vcpkg_installed
~/.cache/vcpkg/archives
~/AppData/Local/vcpkg/archives
key: vcpkg-${{ runner.os }}-${{ matrix.triplet }}-${{ hashFiles('vcpkg.json') }}-${{ github.run_id }}-${{ github.run_attempt }}
path: .cache/ffmpeg
key: ffmpeg-${{ runner.os }}-${{ matrix.arch }}-${{ hashFiles('tooling/ffmpeg/build-ffmpeg.sh') }}-${{ github.run_id }}-${{ github.run_attempt }}
restore-keys: |
vcpkg-${{ runner.os }}-${{ matrix.triplet }}-${{ hashFiles('vcpkg.json') }}-
vcpkg-${{ runner.os }}-${{ matrix.triplet }}-
ffmpeg-${{ runner.os }}-${{ matrix.arch }}-${{ hashFiles('tooling/ffmpeg/build-ffmpeg.sh') }}-
ffmpeg-${{ runner.os }}-${{ matrix.arch }}-
- name: Install dependencies (vcpkg manifest)
- name: Build FFmpeg
if: matrix.platform != 'windows'
shell: bash
run: |
# Source tarballs come from third-party hosts (x264 lives on
# code.videolan.org); a transient connection failure aborts the
# whole install — vcpkg refuses to retry that class of curl
# error — so retry here. vcpkg resumes from its archive and
# download caches, so a repeat attempt is cheap.
for attempt in 1 2 3; do
vcpkg install --triplet ${{ matrix.triplet }} --overlay-triplets tooling/vcpkg-triplets/release --overlay-ports tooling/vcpkg-ports && exit 0
echo "vcpkg install failed (attempt $attempt); retrying"
sleep 15
done
exit 1
if [ -f .cache/ffmpeg/.build-complete ]; then
echo "FFmpeg restored from cache; skipping the build"
else
rm -rf .cache/ffmpeg
tooling/ffmpeg/build-ffmpeg.sh
fi
- name: Install dependencies (vcpkg manifest, Windows)
if: matrix.platform == 'windows'
shell: pwsh
run: |
for ($i = 1; $i -le 3; $i++) {
vcpkg install --triplet ${{ matrix.triplet }} --overlay-triplets tooling/vcpkg-triplets/release --overlay-ports tooling/vcpkg-ports
if ($LASTEXITCODE -eq 0) { exit 0 }
Write-Host "vcpkg install failed (attempt $i); retrying"
Start-Sleep -Seconds 15
}
exit 1
# Explicit restore/save pair: the old `save-always: true` on the
# combined step does not actually save on a failed job (the action
# deprecation warning), so a run that failed after the install left
# no binary cache and the next run rebuilt FFmpeg from source.
- name: Save vcpkg artifacts (WarpCache)
- name: Save FFmpeg (WarpCache)
if: always() && matrix.platform == 'linux'
uses: WarpBuilds/cache/save@v2
env:
WARPBUILD_RUNNER_VERIFICATION_TOKEN: ${{ env.WARPBUILD_RUNNER_VERIFICATION_TOKEN }}
with:
path: |
vcpkg_installed
~/.cache/vcpkg/archives
key: ${{ steps.vcpkg-cache.outputs.cache-primary-key }}
path: .cache/ffmpeg
key: ${{ steps.ffmpeg-cache.outputs.cache-primary-key }}
- name: Save vcpkg artifacts (GitHub)
if: always() && matrix.platform != 'linux'
- name: Save FFmpeg (GitHub)
if: always() && matrix.platform == 'macos'
uses: actions/cache/save@v6
with:
path: |
vcpkg_installed
~/.cache/vcpkg/archives
~/AppData/Local/vcpkg/archives
key: ${{ steps.vcpkg-cache-github.outputs.cache-primary-key }}
path: .cache/ffmpeg
key: ${{ steps.ffmpeg-cache-github.outputs.cache-primary-key }}
# ------------------------------------------------------------------
# Build environment
@@ -406,20 +360,9 @@ jobs:
echo "CXX=clang++"
} >> "$GITHUB_ENV"
bash tooling/ocio-env.sh >> "$GITHUB_ENV"
prefix="$PWD/vcpkg_installed/${{ matrix.triplet }}"
echo "FFMPEG_DIR=$prefix" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$prefix/lib/pkgconfig" >> "$GITHUB_ENV"
echo "$prefix/tools/pkgconf" >> "$GITHUB_PATH"
# vcpkg's libva/libva-drm are shared libraries that FFmpeg links
# dynamically; without this path the loader picks a system libva
# that may predate symbols FFmpeg uses (undefined vaMapBuffer2).
echo "LD_LIBRARY_PATH=$prefix/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" >> "$GITHUB_ENV"
# The packaging tools resolve the ELF needs through ldd as well
# (dpkg-shlibdeps, linuxdeploy): register the vcpkg libs with the
# dynamic linker so `libva-drm.so.2` is found when a package is
# assembled.
echo "$prefix/lib" > /etc/ld.so.conf.d/oak-vcpkg.conf
ldconfig
ffmpeg="$PWD/.cache/ffmpeg"
echo "FFMPEG_DIR=$ffmpeg" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$ffmpeg/lib/pkgconfig" >> "$GITHUB_ENV"
- name: Configure build environment (macOS)
if: matrix.platform == 'macos'
@@ -428,19 +371,15 @@ jobs:
# Vendored static OCIO (same as every non-Windows platform via
# tooling/ocio-env.sh); no OCIO_INSTALL_DIR override.
bash tooling/ocio-env.sh >> "$GITHUB_ENV"
prefix="$PWD/vcpkg_installed/${{ matrix.triplet }}"
echo "FFMPEG_DIR=$prefix" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$prefix/lib/pkgconfig" >> "$GITHUB_ENV"
echo "$prefix/tools/pkgconf" >> "$GITHUB_PATH"
ffmpeg="$PWD/.cache/ffmpeg"
echo "FFMPEG_DIR=$ffmpeg" >> "$GITHUB_ENV"
echo "PKG_CONFIG_PATH=$ffmpeg/lib/pkgconfig" >> "$GITHUB_ENV"
- name: Configure build environment (Windows)
if: matrix.platform == 'windows'
shell: pwsh
run: |
# FFmpeg comes from the prebuilt archive extracted above (the
# manifest no longer installs it on Windows); vcpkg only
# provides pkgconf for oak-ffmpeg-link's build script.
$prefix = "$env:GITHUB_WORKSPACE\vcpkg_installed\${{ matrix.triplet }}"
# FFmpeg comes from the prebuilt archive extracted above.
$ffmpeg = "$env:GITHUB_WORKSPACE\.cache\ffmpeg"
"FFMPEG_DIR=$ffmpeg" >> $env:GITHUB_ENV
"PKG_CONFIG_PATH=$ffmpeg\lib\pkgconfig" >> $env:GITHUB_ENV
@@ -448,16 +387,12 @@ jobs:
# runner reports STATUS_DLL_NOT_FOUND when the first test
# executable starts.
"$ffmpeg\bin" >> $env:GITHUB_PATH
"$prefix\tools\pkgconf" >> $env:GITHUB_PATH
# Bundled OCIO: ocio-sys' vendored sources build with the MSVC
# toolchain (what they need — the MSYS2 package was the
# workaround, not the preference), so no OCIO_INSTALL_DIR and
# no OCIO_RS_NO_MSVC_INCLUDES anywhere.
"OCIO_RS_ENABLE_REAL=1" >> $env:GITHUB_ENV
"OCIO_RS_LINK=static" >> $env:GITHUB_ENV
# Record the resolved versions in the build log (the manifest
# pins them via overrides + builtin-baseline).
vcpkg list
# ------------------------------------------------------------------
# Cargo caches: whole target/ dir plus ~/.cargo, shared per
docs/build.md
+12 -14
View File
@@ -36,15 +36,14 @@ macOS, Linux, and Windows. For the Chinese version see
config entry is the only machine-agnostic way). The `oak-ffmpeg-link`
build script panics without it; run `build-ffmpeg.sh` once before the
first `cargo build`.
- **CI/CD uses the vcpkg manifest instead of `build-ffmpeg.sh`.** Every
desktop job runs `vcpkg install --triplet <x64-windows | x64-linux |
arm64-osx | arm64-linux>` against the repo-root `vcpkg.json`, which
pins FFmpeg to **8.1.2#3** (`overrides`) and every other port through
`builtin-baseline`; the tree lands in `vcpkg_installed/<triplet>` and
jobs point `FFMPEG_DIR`/`PKG_CONFIG_PATH` at it. The C/C++ libraries
outside that set (OCIO is vendored, the rest come from the system
package manager) are unchanged. The local-build path above remains
valid and is what the docs below describe.
- **CI/CD follows the same path.** The Linux/macOS jobs run
`tooling/install-deps.sh` and `tooling/ffmpeg/build-ffmpeg.sh`, so the
release binaries and local builds share one FFmpeg configuration (the
built tree is cached in CI and rebuilt from scratch in CD). The
Windows jobs download a prebuilt FFmpeg — BtbN's shared GPL build, the
one ffmpeg.org links as the official Windows option — from its release
page, verify it against the published `checksums.sha256` and point
`FFMPEG_DIR` at it (no MSYS2 or vcpkg toolchain in CI).
## Quick start (macOS / Linux)
@@ -96,11 +95,10 @@ cargo test --workspace # Linux: see "headless tests" below
## Windows (MSYS2 UCRT64)
> **CI/CD note**: the GitHub Windows CI/CD no longer uses this path — it
> builds MSVC-ABI on `warp-windows-2025-vs2026-x64-16x` with vcpkg
> manifest mode (`vcpkg.json` at the repo root: FFmpeg 8.1.2 with every
> free codec + hwaccel, pkgconf, librsvg, all pinned by
> `overrides`/`builtin-baseline`) and the vendored static OCIO. The
> MSYS2 flow below remains the documented local-build alternative.
> builds MSVC-ABI on `warp-windows-2025-vs2026-x64-32x` with BtbN's
> prebuilt shared FFmpeg (downloaded from the release page and verified
> against its sha256) and the vendored static OCIO. The MSYS2 flow below
> remains the documented local-build alternative.
The Windows build targets **x86_64-pc-windows-gnu** with MSYS2's own
Rust; the MSVC toolchain is not supported (the build scripts emit
tooling/vcpkg-ports/README.md
-23
View File
@@ -1,23 +0,0 @@
# vcpkg overlay ports
Passed to `vcpkg install` with `--overlay-ports tooling/vcpkg-ports`
(both workflows, see `.github/workflows/ci.yml` and
`.github/workflows/cd.yml`).
## x264
vcpkg's builtin x264 port downloads its source from `code.videolan.org`,
whose GitLab sits behind an anti-bot challenge: CI runners intermittently
failed the download (`curl` error 7 / HTTP 404), which made every vcpkg
install a coin flip. This overlay is a verbatim copy of the port at
baseline `771b0a2e7c473c3a6bee56553be4d5bb32bb653c` with
`vcpkg_from_gitlab` swapped for `vcpkg_from_github` against the
`mirror/x264` GitHub mirror. The mirror archive is byte-identical to
GitLab's (same SHA512), so only the fetch URL changes.
No other port in the dependency tree uses code.videolan.org (dav1d and
x265 already fetch from GitHub).
Refresh the copy (portfile, patches, `vcpkg.json`) whenever the
manifest's `builtin-baseline` moves so it keeps matching the resolved
version.
tooling/vcpkg-ports/x264/allow-clang-cl.patch
-15
View File
@@ -1,15 +0,0 @@
diff --git a/configure b/configure
index 6f95e2314..e677e36f4 100644
--- a/configure
+++ b/configure
@@ -606,9 +606,9 @@ if [[ $host_os = mingw* || $host_os = msys* || $host_os = cygwin* ]]; then
if cc_check '' -Qdiag-error:10006,10157 ; then
CHECK_CFLAGS="$CHECK_CFLAGS -Qdiag-error:10006,10157"
fi
- elif [[ "$cc_base" = cl || "$cc_base" = cl[\ .]* ]]; then
+ elif [[ "$cc_base" = cl || "$cc_base" = cl[\ .]* || "$cc_base" = clang-cl || "$cc_base" = clang-cl[\ .]* ]]; then
# Standard Microsoft Visual Studio
compiler=CL
compiler_style=MS
CFLAGS="$CFLAGS -nologo -GS- -DHAVE_STRING_H -I\$(SRCPATH)/extras"
cpp_check '' '' '_MSC_VER > 1800 || (_MSC_VER == 1800 && _MSC_FULL_VER >= 180030324)' || die "Microsoft Visual Studio support requires Visual Studio 2013 Update 2 or newer"
tooling/vcpkg-ports/x264/configure.patch
-29
View File
@@ -1,29 +0,0 @@
diff --git a/configure b/configure
index 5116bb97..e4ff41cc 100755
--- a/configure
+++ b/configure
@@ -1,4 +1,7 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+export CFLAGS="${CPPFLAGS} ${CFLAGS}"
+test "${AS:-:}" = ":" && unset AS
if test x"$1" = x"-h" -o x"$1" = x"--help" ; then
cat <<EOF
@@ -865,6 +868,7 @@ case $host_cpu in
AS="${AS-${SRCPATH}/tools/gas-preprocessor.pl -arch aarch64 -as-type armasm -- armasm64 -nologo}"
else
AS="${AS-${CC}}"
+ test "${AS}" = "${CC}" && ASFLAGS="${CPPFLAGS} ${ASFLAGS}"
fi
;;
arm*)
@@ -883,6 +887,7 @@ case $host_cpu in
AS="${AS-${SRCPATH}/tools/gas-preprocessor.pl -arch arm -as-type clang -force-thumb -- ${CC} -mimplicit-it=always}"
else
AS="${AS-${CC}}"
+ test "${AS}" = "${CC}" && ASFLAGS="${CPPFLAGS} ${ASFLAGS}"
fi
;;
s390|s390x)
tooling/vcpkg-ports/x264/parallel-install.patch
-14
View File
@@ -1,14 +0,0 @@
diff --git a/configure b/configure
index 6f95e23..30924ba 100755
--- a/configure
+++ b/configure
@@ -1565,7 +1565,8 @@ fi
if [ "$cli" = "yes" ]; then
echo 'default: cli' >> config.mak
- echo 'install: install-cli' >> config.mak
+ echo 'install:' >> config.mak
+ echo ' $(MAKE) install-cli' >> config.mak
fi
if [ "$shared" = "yes" ]; then
tooling/vcpkg-ports/x264/portfile.cmake
-140
View File
@@ -1,140 +0,0 @@
# Oak overlay of vcpkg's x264 port (baseline 771b0a2e7c473c3a6bee56553be4d5bb32bb653c).
# The only change: the source comes from the GitHub mirror `mirror/x264`
# instead of code.videolan.org, whose GitLab serves the archive behind an
# anti-bot challenge — CI runners intermittently could not download it
# (curl 7 / 404), which made every vcpkg install a coin flip. The mirror
# archive is byte-identical (same SHA512), so only the fetch URL changes.
# The other port files are verbatim copies; refresh them when vcpkg's
# builtin baseline moves.
# The latest ref in branch stable
set(ref b35605ace3ddf7c1a5d67a2eb553f034aef41d55)
# Note on x264 versioning:
# The pc file exports "0.<ABI>.<N>" where N is the number of commits.
# The binary releases on https://artifacts.videolan.org/x264/ are named x264-r<N>-<COMMIT>.
# With a git clone, this can be determined by running `versions.sh`.
# With vcpkg_from_gitlab, we modify `versions.sh` accordingly.
# For --editable mode, use configured patch instead of vcpkg_replace_string.
string(REGEX MATCH "^......." short_ref "${ref}")
string(REGEX MATCH "[0-9]+\$" revision "${VERSION}")
configure_file("${CURRENT_PORT_DIR}/version.diff.in" "${CURRENT_BUILDTREES_DIR}/src/version-${VERSION}.diff" @ONLY)
vcpkg_from_github(
OUT_SOURCE_PATH SOURCE_PATH
REPO mirror/x264
REF "${ref}"
SHA512 bfac118da55da2fcc4587b17a3184d9ed70d6e03188bc0497f5922df22b5685fa49fa4325f9c5196c76d03e6e3f56d5906475c540d0df7e1739dc4182816eebe
HEAD_REF master
PATCHES
"${CURRENT_BUILDTREES_DIR}/src/version-${VERSION}.diff"
uwp-cflags.patch
parallel-install.patch
allow-clang-cl.patch
configure.patch
)
function(add_cross_prefix)
if(configure_env MATCHES "CC=([^\/]*-)gcc$")
vcpkg_list(APPEND arg_OPTIONS "--cross-prefix=${CMAKE_MATCH_1}")
endif()
set(arg_OPTIONS "${arg_OPTIONS}" PARENT_SCOPE)
endfunction()
set(nasm_archs x86 x64)
set(gaspp_archs arm arm64)
if(NOT "asm" IN_LIST FEATURES)
vcpkg_list(APPEND OPTIONS --disable-asm)
elseif(NOT "$ENV{AS}" STREQUAL "")
# Accept setting from triplet
elseif(VCPKG_TARGET_ARCHITECTURE IN_LIST nasm_archs)
vcpkg_find_acquire_program(NASM)
vcpkg_insert_program_into_path("${NASM}")
set(ENV{AS} "${NASM}")
elseif(VCPKG_TARGET_ARCHITECTURE IN_LIST gaspp_archs AND VCPKG_TARGET_IS_WINDOWS AND VCPKG_HOST_IS_WINDOWS)
vcpkg_find_acquire_program(GASPREPROCESSOR)
list(FILTER GASPREPROCESSOR INCLUDE REGEX gas-preprocessor)
file(INSTALL "${GASPREPROCESSOR}" DESTINATION "${SOURCE_PATH}/tools" RENAME "gas-preprocessor.pl")
endif()
vcpkg_list(SET OPTIONS_RELEASE)
if("tool" IN_LIST FEATURES)
vcpkg_list(APPEND OPTIONS_RELEASE --enable-cli)
else()
vcpkg_list(APPEND OPTIONS_RELEASE --disable-cli)
endif()
if("chroma-format-all" IN_LIST FEATURES)
vcpkg_list(APPEND OPTIONS --chroma-format=all)
endif()
if(NOT "gpl" IN_LIST FEATURES)
vcpkg_list(APPEND OPTIONS --disable-gpl)
endif()
if(VCPKG_TARGET_IS_UWP)
list(APPEND OPTIONS --extra-cflags=-D_WIN32_WINNT=0x0A00)
endif()
vcpkg_make_configure(
SOURCE_PATH "${SOURCE_PATH}"
DISABLE_CPPFLAGS # Build is not using CPP/CPPFLAGS
DISABLE_MSVC_WRAPPERS
LANGUAGES ASM C CXX # Requires NASM to compile
DISABLE_MSVC_TRANSFORMATIONS # disable warnings about unknown -Xcompiler/-Xlinker flags
PRE_CONFIGURE_CMAKE_COMMANDS
add_cross_prefix
OPTIONS
${OPTIONS}
--enable-pic
--disable-lavf
--disable-swscale
--disable-avs
--disable-ffms
--disable-gpac
--disable-lsmash
--disable-bashcompletion
OPTIONS_RELEASE
${OPTIONS_RELEASE}
--enable-strip
"--bindir=\\\${prefix}/bin"
OPTIONS_DEBUG
--enable-debug
--disable-cli
"--bindir=\\\${prefix}/bin"
)
vcpkg_make_install()
if("tool" IN_LIST FEATURES)
vcpkg_copy_tools(TOOL_NAMES x264 AUTO_CLEAN)
endif()
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include")
if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/lib/pkgconfig/x264.pc" "-lx264" "-llibx264")
if(NOT VCPKG_BUILD_TYPE)
vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/x264.pc" "-lx264" "-llibx264")
endif()
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
file(RENAME "${CURRENT_PACKAGES_DIR}/lib/libx264.dll.lib" "${CURRENT_PACKAGES_DIR}/lib/libx264.lib")
if (NOT VCPKG_BUILD_TYPE)
file(RENAME "${CURRENT_PACKAGES_DIR}/debug/lib/libx264.dll.lib" "${CURRENT_PACKAGES_DIR}/debug/lib/libx264.lib")
endif()
vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/include/x264.h" "#ifdef X264_API_IMPORTS" "#if 1")
elseif(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/include/x264.h" "defined(U_STATIC_IMPLEMENTATION)" "1" IGNORE_UNCHANGED)
file(REMOVE_RECURSE
"${CURRENT_PACKAGES_DIR}/bin"
"${CURRENT_PACKAGES_DIR}/debug/bin"
)
endif()
vcpkg_fixup_pkgconfig()
vcpkg_copy_pdbs()
vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/COPYING")
tooling/vcpkg-ports/x264/uwp-cflags.patch
-12
View File
@@ -1,12 +0,0 @@
diff --git a/configure b/configure
index f7b14d9..2c92b2a 100644
--- a/configure
+++ b/configure
@@ -821,7 +821,6 @@ if [ $SYS = WINDOWS ]; then
if cpp_check "winapifamily.h" "" "!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)" ; then
[ $compiler = CL ] || die "WinRT requires MSVC"
define HAVE_WINRT
- CFLAGS="$CFLAGS -MD"
LDFLAGS="$LDFLAGS -appcontainer"
if ! cpp_check "" "" "defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0603" ; then
die "_WIN32_WINNT must be defined to at least 0x0603 (Windows 8.1) for WinRT"
tooling/vcpkg-ports/x264/vcpkg.json
-40
View File
@@ -1,40 +0,0 @@
{
"name": "x264",
"version": "0.165.3222",
"description": "x264 is a free software library and application for encoding video streams into the H.264/MPEG-4 AVC compression format",
"homepage": "https://www.videolan.org/developers/x264.html",
"license": "GPL-2.0-or-later",
"supports": "!xbox",
"dependencies": [
{
"name": "vcpkg-make",
"host": true
}
],
"default-features": [
{
"name": "asm",
"platform": "!(arm32 & windows)"
},
{
"name": "gpl",
"platform": "!(arm32 & windows)"
}
],
"features": {
"asm": {
"description": "Enable platform-specific assembly optimizations",
"supports": "!(arm32 & windows)"
},
"chroma-format-all": {
"description": "Output all chroma formats"
},
"gpl": {
"description": "Allow use of GPL code, the resulting libs and binaries will be under GPL"
},
"tool": {
"description": "Build the command line tool",
"supports": "!uwp"
}
}
}
tooling/vcpkg-ports/x264/version.diff.in
-15
View File
@@ -1,15 +0,0 @@
diff --git a/version.sh b/version.sh
index 178fc952..06728796 100755
--- a/version.sh
+++ b/version.sh
@@ -3,8 +3,8 @@
cd "$(dirname "$0")" >/dev/null && [ -f x264.h ] || exit 1
api="$(grep '#define X264_BUILD' < x264.h | sed 's/^.* \([1-9][0-9]*\).*$/\1/')"
-ver="x"
-version=""
+ver="@revision@ @short_ref@"
+version=" r${ver} vcpkg"
if [ -d .git ] && command -v git >/dev/null 2>&1 ; then
localver="$(($(git rev-list HEAD | wc -l)))"
tooling/vcpkg-triplets/README.md
-23
View File
@@ -1,23 +0,0 @@
# vcpkg overlay triplets
Small overlays over vcpkg's builtin triplets, passed to `vcpkg install`
with `--overlay-triplets <dir>` (both workflows, see
`.github/workflows/ci.yml` and `.github/workflows/cd.yml`).
`release/` pins every supported triplet to the release configuration
(`set(VCPKG_BUILD_TYPE release)`): vcpkg otherwise builds every port
twice — release and debug — which doubles the FFmpeg/port build time in
CI and CD. Our build scripts only ever consume the release layout
(`FFMPEG_DIR=<prefix>` with `<prefix>/lib/pkgconfig`, plus the linker
paths those `.pc` files carry), so the debug half was pure waste; the C
libraries' ABI is identical for the debug cargo binary CI tests.
Notes:
- The non-build-type settings mirror vcpkg's builtin triplets
(`scripts/triplets/`) so the overlay stays a drop-in replacement; a
vcpkg upgrade that changes a builtin triplet should be mirrored here.
- `VCPKG_BUILD_TYPE` must be set in the triplet: the environment
variable of the same name is ignored in manifest mode.
- Do not try `debug` here: several ports (e.g. zlib) patch files in the
release layout and fail when only the debug configuration is built.
tooling/vcpkg-triplets/release/arm64-linux.cmake
-12
View File
@@ -1,12 +0,0 @@
# Oak's build-type overlay triplet for arm64-linux (see the note in
# ../README.md): the settings mirror vcpkg's builtin arm64-linux.cmake and
# only the build type is pinned. Pass this directory with
# `--overlay-triplets tooling/vcpkg-triplets/release`.
set(VCPKG_TARGET_ARCHITECTURE arm64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)
set(VCPKG_CMAKE_SYSTEM_NAME Linux)
# Build only the release configuration (see x64-linux.cmake).
set(VCPKG_BUILD_TYPE release)
tooling/vcpkg-triplets/release/arm64-osx.cmake
-13
View File
@@ -1,13 +0,0 @@
# Oak's build-type overlay triplet for arm64-osx (see the note in
# ../README.md): the settings mirror vcpkg's builtin arm64-osx.cmake and
# only the build type is pinned. Pass this directory with
# `--overlay-triplets tooling/vcpkg-triplets/release`.
set(VCPKG_TARGET_ARCHITECTURE arm64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)
set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
set(VCPKG_OSX_ARCHITECTURES arm64)
# Build only the release configuration (see x64-linux.cmake).
set(VCPKG_BUILD_TYPE release)
tooling/vcpkg-triplets/release/x64-linux.cmake
-14
View File
@@ -1,14 +0,0 @@
# Oak's build-type overlay triplet for x64-linux (see the note in
# ../README.md): the settings mirror vcpkg's builtin x64-linux.cmake and
# only the build type is pinned. Pass this directory with
# `--overlay-triplets tooling/vcpkg-triplets/release`.
set(VCPKG_TARGET_ARCHITECTURE x64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE static)
set(VCPKG_CMAKE_SYSTEM_NAME Linux)
# Build only the release configuration. vcpkg otherwise builds every port
# twice (release + debug) and our build scripts/vcpkg caches only ever use
# the release layout (FFMPEG_DIR's lib/pkgconfig).
set(VCPKG_BUILD_TYPE release)
tooling/vcpkg-triplets/release/x64-windows.cmake
-11
View File
@@ -1,11 +0,0 @@
# Oak's build-type overlay triplet for x64-windows (see the note in
# ../README.md): the settings mirror vcpkg's builtin x64-windows.cmake and
# only the build type is pinned. Pass this directory with
# `--overlay-triplets tooling/vcpkg-triplets/release`.
set(VCPKG_TARGET_ARCHITECTURE x64)
set(VCPKG_CRT_LINKAGE dynamic)
set(VCPKG_LIBRARY_LINKAGE dynamic)
set(VCPKG_PROVIDED_FORTRAN ON)
# Build only the release configuration (see x64-linux.cmake).
set(VCPKG_BUILD_TYPE release)
vcpkg.json
-50
View File
@@ -1,50 +0,0 @@
{
"name": "oak",
"version": "0.5.0",
"$comment": "FFmpeg for the Linux/macOS CI/CD builds with the project's feature set (every free codec + hwaccel, mirroring tooling/ffmpeg/build-ffmpeg.sh's configure switches); Windows uses the vendored BtbN prebuilt instead (GPL shared, MSVC import libs) because a cold vcpkg FFmpeg build there took ~40 minutes — see the ffmpeg-prebuilt-win64-n8.1 release. pkgconf is needed everywhere (oak-ffmpeg-link's build script). Local builds may keep using tooling/install-deps.sh + tooling/ffmpeg/build-ffmpeg.sh. ffmpeg is pinned to 8.1.2#3 via overrides (matching the ffmpeg-next 8.x binding); builtin-baseline pins the rest of the port tree.",
"builtin-baseline": "771b0a2e7c473c3a6bee56553be4d5bb32bb653c",
"dependencies": [
{
"name": "ffmpeg",
"platform": "!windows",
"features": [
"gpl",
"version3",
"x264",
"x265",
"dav1d",
"vpx",
"openh264",
"openjpeg",
"zlib",
"theora",
"webp",
"mp3lame",
"opus",
"vorbis",
"speex",
"snappy",
"ass",
"freetype",
"fribidi",
"fontconfig",
"openssl",
{
"name": "nvcodec",
"platform": "linux | (windows & !arm64)"
},
{
"name": "vaapi",
"platform": "linux"
}
]
},
"pkgconf"
],
"overrides": [
{
"name": "ffmpeg",
"version": "8.1.2#3"
}
]
}