`ffmpeg -encoders` lists every compiled-in encoder — a full Windows
build advertises h264_nvenc/qsv/amf even when the machine has none of
that hardware — so probe_hw_encoder picked NVENC on the GPU-less Windows
runner and the proxy transcode failed ('Cannot load libcuda.so.1',
caught by engine_proxy_generate_and_delete now that the Windows package
ships an ffmpeg CLI). Probe a one-frame null encode per candidate and
fall through to the next, finally to libx264.
Reproduced locally with a full ffmpeg build: h264_nvenc exits 255
without the driver, libx264 succeeds.
cargo does not track the static archives ffmpeg-sys-next bundled into its
rlib, so a target/ cache restored from an older run keeps linking the
previous FFmpeg even after .cache/ffmpeg was rebuilt. The Build FFmpeg
step now flags a rebuild and a small step drops just that package before
the build; cache hits and the Windows prebuilt path are untouched.
- x264/x265 are patent-encumbered and not in Fedora's own repositories:
install the RPM Fusion free release package first (over HTTPS from the
official mirror) so dnf can resolve them;
- Fedora 43 renamed the bindings: libdav1d-devel (not dav1d-devel) and
openjpeg-devel (not openjpeg2-devel);
- degrade like the apt branch when something is unavailable:
--skip-unavailable instead of failing the whole transaction.
Verified end-to-end in a fedora:43 container: the full list installs
(260 packages; x264 0.165 and x265 4.1 come from RPM Fusion). Arch's
package names were re-checked against the Arch package index (all
present).
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.
The Windows CI/CD archive (BtbN) is a shared build whose seven MSVC
import libraries have canonical names and whose .pc files carry no
external Libs.private, so pkg-config resolution is unnecessary there.
When neither pkg-config nor pkgconf exists, the script now emits the
fixed link line instead of panicking — but only on Windows: everywhere
else a static FFmpeg still needs the transitive list from its .pc files,
and MSYS2 local builds keep using pkg-config.
The FFmpeg 9 note in oak-codec's manifest is refreshed as well.
- touch $PREFIX/.build-complete after a successful install: the CI cache
rejects a restored tree without it (a failed run's partial save) and
rebuilds instead;
- the old comment claimed every ffmpeg-next/FFmpeg pairing is broken
upstream. Verified locally instead: ffmpeg-next 9.0.0 compiles against
both release/8.1 and release/9.0 (cargo check of a scratch crate and of
oak-codec against the 9.0 build), so the pinned version is a project
choice, not a compatibility workaround.
CI/CD now runs this script on Linux/macOS (no more vcpkg), so:
- use sudo only when not root (the CI containers run as root without a
sudo binary);
- install clang/libclang (FFmpeg's --enable-cuda-llvm and bindgen need
them) and cmake/python3 (the vendored OCIO build), plus the VAAPI dev
packages (libva/libdrm) so hardware decode survives the move off vcpkg;
- fetch nv-codec-headers from FFmpeg's official GitHub mirror instead of
code.videolan.org (git there is behind an anti-bot challenge);
- stay idempotent (clean the header checkout first) and tolerate a
package a distro does not carry (e.g. Ubuntu's multiverse-only
libopenh264-dev): install the rest individually and let FFmpeg's
configure probes drop what is missing.
Verified in a debian:12 container (root): first run installs everything,
second run exits 0.
A cold vcpkg FFmpeg build costs ~40 minutes per Windows run and the
Windows dependency chain is the hardest to keep healthy; BtbN's builds
come from public GitHub Actions on the release/8.1 branch (BtbN is an
FFmpeg developer; ffmpeg.org links these builds as the official Windows
option). The archive ships include/, MSVC import libs (.lib), pkg-config
files and the runtime DLLs, and is fetched straight from his release
page with the checksums.sha256 published in the same release — nothing
is mirrored here, so provenance stays upstream.
The Windows jobs download/verify/extract it to .cache/ffmpeg (the
checksum comes from that release's own checksums.sha256), point
FFMPEG_DIR/PKG_CONFIG_PATH at it (pkgconf still comes from vcpkg) and
the installer bundles its DLLs. The manifest gates ffmpeg to !windows
and drops librsvg (the icon now ships as the committed PNG).
vcpkg's x264 port downloads from code.videolan.org, whose GitLab serves
the archive behind an anti-bot challenge: CI runners hit curl 7/35
(connection/SSL) or 404 at random, so whether a vcpkg install succeeded
was a coin flip. This overlay port is a verbatim copy of the builtin
port at baseline 771b0a2e with vcpkg_from_gitlab swapped for
vcpkg_from_github against mirror/x264 (byte-identical archive, same
SHA512); both workflows now pass --overlay-ports tooling/vcpkg-ports.
Verified locally in debian:12: the port downloaded from
github.com/mirror/x264 and built libx264.a. No other port in the tree
uses code.videolan.org (dav1d/x265 already fetch from GitHub).
vcpkg builds every port twice (release + debug) in manifest mode and the
VCPKG_BUILD_TYPE environment variable is ignored there; pin the build
type in overlay triplets instead (tooling/vcpkg-triplets/release, one per
supported triplet). The release configuration is what both workflows
consume: FFMPEG_DIR drives the release layout (lib/pkgconfig) and the C
ABI is identical for the debug binary CI tests. Verified locally in
debian:12: a release-only overlay builds zlib/libpng/openssl/pkgconf/
libsndfile with zero debug trees.
Debug-only is not an option: ports like zlib patch files in the release
layout and fail when only the debug configuration is built.
Verified locally in debian:12 and fedora:43 containers before pushing:
- deb: dpkg-deb rejected the control file because `paste -sd', '` uses
the delimiter list cyclically (comma, space, comma, ...) — join with a
plain comma instead;
- rpm: rpm 4.20+ (Fedora 43) computes %{buildroot} itself and ignores a
caller-supplied buildroot define, so stage the payload and let the
spec's %install copy it via %{_oak_stage}; add a changelog entry (the
%source_date_epoch_from_changelog warning) and drop it from the
changelog-less build.
Fedora 41 is EOL, so its mirrors moved to the slow archive: the first
dnf transaction took ~7 minutes in the last CD run. Use the current
fedora:43 image (all dependency names verified against F41 and F43) and
skip weak dependencies / download in parallel in both dnf calls.
Fedora packages core perl modules separately: openssl's Configure died on
"Can't locate FindBin.pm" after IPC::Cmd was fixed, and the build also
uses File::Basename/File::Compare/Copy/Path and File::Temp, plus
Time::Piece for the in-tree utilities. All of them exist for F41 and F43.
CI and CD now run the same seven environments in a single matrix:
Debian 12, Fedora 41, Arch and openKylin x64+arm64 in their distro
containers plus the macOS (12x) and Windows (32x) hosts, with identical
dependency lists and runner sizes, so a package a CD build needs cannot
be missing in CI. CD keeps building every package from scratch (no
vcpkg/cargo caches).
Fixes every failure the last CD run exposed:
- deb packaging: dpkg-shlibdeps needs a Debian source tree (give it a
synthetic debian/control) and Debian 12/openKylin carry an older libva
than FFmpeg 8 needs (vaMapBuffer2), so vcpkg's libva/libdrm ship next
to the app with an $ORIGIN RUNPATH;
- AppImage: register the vcpkg libs with ldconfig so linuxdeploy finds
libva-drm.so.2;
- Fedora: install perl-IPC-Cmd (vcpkg's openssl port requires it);
- macOS: cargo-packager produces "Oak Video Editor.app"; resolve the
bundle instead of assuming "Oak.app";
- Windows: the vendored OCIO is compiled /MD, so drop +crt-static (the
LNK2038 RuntimeLibrary mismatch) and bundle the MSVC runtime DLLs
app-locally;
- containers: pin HOME for rustup and give WarpCache its token on the
cache steps only (job-level env cannot reference the env context).
A restored vcpkg_installed or target tree masked packaging problems
before (stale ports, a missing librsvg tool) and release artifacts must
not depend on restored state, so remove every cache step from the CD
jobs: vcpkg builds its ports from source and cargo compiles cold on each
release run.
vcpkg's vaapi feature builds libva, which needs libdrm headers: the CI
Linux job installs libdrm-dev and the CD debian container did not
(fedora/arch already carry libdrm-devel/libdrm), so its vcpkg install
failed with "You will need to install libdrm dependencies".
Windows has no rsvg-convert either: vcpkg's librsvg port is built with
-Drsvg-convert=disabled, so the icon step now copies the committed
512x512 render (assets/app-icon.png); the Linux icon step falls back to
it too when librsvg2-bin is missing.
The Fedora dnf list had a trailing space after a line-continuation
backslash, which became a blank argument dnf rejects with "No match for
argument:". The AppImage job cloned vcpkg with --depth 1, but the
manifest pins a builtin-baseline and port trees a shallow clone cannot
check out ("failed to unpack tree object"); use a full clone like the
other packaging jobs.
The Linux package matrix now carries arch/triplet/runner per entry and
gains two openKylin entries (x64 on a 16x runner, arm64 on a 32x runner),
each building inside the openkylin container so dpkg-shlibdeps resolves
against openKylin's own repo names. Deb packages are labeled by build
distro: the general debian:12 package becomes
oak-editor_<version>+debian_<arch>.deb, openKylin's
oak-editor_<version>+openkylin_<arch>.deb; build-deb.sh takes the variant
and stamps dpkg --print-architecture (the file name hardcoded amd64
before).
Also: pin HOME for rustup in the openKylin container, create the icon
directory before rendering (and degrade to the scalable icon when
rsvg-convert is missing), add the Windows Defender step to the Windows
packaging job, and take the bumped runner sizes (AppImage/Linux 16x,
macOS 12x, Windows 32x).
A job container does not inherit the runner environment, so every cache
step logged "Authentication token is invalid" and the vcpkg cache was
never restored or saved. Pass WARPBUILD_RUNNER_VERIFICATION_TOKEN into
the container explicitly (WarpBuilds/cache README: "Running inside a
container") and install wget there, which the action uses to download
cache segments.
macOS ships true in /usr/bin (there is no /bin/true), so the immediate
exit worker spawn failed with ENOENT and
start_failure_restart_budget_and_accessors never reached a restart.
Resolve the binary from the usual locations, falling back to PATH.
macOS caps shm_open names at PSHMNAMLEN (31 bytes including the leading
slash) and answers ENAMETOOLONG beyond that, while Linux allows 255. The
dispatcher tests name segments oak-procpool-ut-<pid>-<label>, so every
procpool test failed on macOS as soon as the earlier crash stopped
masking them. Fold longer keys into a deterministic FNV-1a short name in
one place; owner, worker and unlink all derive the name through it, so
they keep meeting on the same segment.
The first WarpCache-cold run failed because x264's source tarball on
code.videolan.org refused connections (curl error 7) and vcpkg refuses
to retry that class of error. Retry the install up to three times on
every platform; vcpkg resumes from its archive/download caches.
Only gl_available/acquire obeyed the OAK_GPU_TESTS gate, so suite tests
that fabricate a GL context and texture names still reached CGL through
delete_gl_texture (and the other unguarded entry points), whose real GL
calls segfault without a current context. Turn every public wrapper
(texture/FBO/viewport/clear/readback/version/is_current) into a no-op or
error while gated, matching the Linux/Windows stubs.
OFX binaries run their own global init on the first
OfxGetNumberOfPlugins query, and that init is not thread-safe: two
threads racing to load the CImg fixture corrupted its static map
(SIGSEGV/SIGABRT, and a hang when the loader deadlocked). Tests create
their own PluginCache instances, so per-cache locks cannot serialize it;
add a process-wide LOAD_LOCK around dlopen + collect_plugins. Loading is
a startup-time operation, so the lock is free in production and makes
concurrent scans safe.
Windows CI exposed two assertions that assumed POSIX paths:
frame_filename was checked with ends_with("/450") (separator is '\\'
there) and the OAK_WORKER_BIN override used /bin/sh, which never exists
on Windows so the sibling probe legitimately won. Compare the last path
component and point the override at the test executable instead.
The GPU path composites frames bottom (last) to top (first); the CPU
fallback iterated top-first, so on machines without a working adapter
every multi-layer frame had its layering order inverted (the
composite_tracks test caught it as 0.8125 vs the documented 0.625).
Factor the CPU half into composite_tracks_cpu, iterate it in reverse
and pin the math in the test by calling the CPU path directly (the old
assertion silently exercised the GPU path whenever another test had
installed a shared context).
The multicam node-graph switch regression fails on Windows CI (the second
render still serves the first source: the selector does not reach the
evaluation) and multicam is not v0.5 scope. Mark the test ignored with
that reason so Windows CI can go green, and drop the temporary
media/graph probes added while diagnosing it (their findings live in the
git history) so un-ignoring it later starts from the original test.
- The macOS Test step gets the same in-script watchdog as Linux/openKylin:
after 900 s it prints `sample` stacks of every test process (the hung
test's native stack lands in the log) and kills the suite, instead of
leaving the job to sit until the step timeout with no evidence.
- The multicam graph test additionally prints the `current_in` read-back
after the switch, so the next Windows run distinguishes a lost selector
write from a row/element resolution problem.
The GitHub Actions cache quota is full (the vcpkg trees plus the cargo
target dirs overflow the 10 GiB repo budget). The Linux job and both
openKylin matrix jobs now use WarpBuild's drop-in cache actions
(WarpBuilds/cache restore+save, WarpBuilds/rust-cache); all of them run
on WarpBuild runners, where the service is available. macOS and Windows
keep actions/cache for now.
- The macOS SIGSEGV moved from the gl_bridge unit tests (already gated)
to other real-GL users in the same binary (suites::gl_render,
render_driver): make the gate systemic in the test build on macOS.
gl_available() reports unavailable and acquire() fails unless
OAK_GPU_TESTS is set, so every unit test takes its documented CPU
fallback; release builds are untouched.
- Dump Apple's crash reports on macOS failure: a SIGSEGV in a test binary
prints nothing, and the .ips report carries the native stack.
- The Windows-only multicam graph test failure now prints both decoded
media probes and both rendered source pixels: that separates a broken
test-media encode from a broken graph switch in one run.
- Actions moved to their latest majors: checkout v4->v7, cache v4->v6
(restore/save too), upload-artifact v4->v7, download-artifact v4->v8,
action-gh-release v2->v3. rust-cache and rust-toolchain already track
their latest majors.
- vcpkg caches now save under a per-run key and restore through
`restore-keys` (newest entry for the exact manifest first, then the
newest entry for that OS): saving can no longer fail because the key
already exists ("update if present, create if not"), and a manifest
change reuses vcpkg's content-addressed archives instead of rebuilding
every port.
- Every Test step gets an explicit 40-minute bound. macOS had no watchdog
at all (the Linux/openKylin scripts carry their own) and the current run
has been sitting in Test with no progress; a hung suite now fails the
step instead of running to the job timeout.
- Windows: the first test executable died with STATUS_DLL_NOT_FOUND
(0xc0000135) because vcpkg's x64-windows DLLs (ffmpeg and its codecs)
were not on PATH; add vcpkg_installed/x64-windows/bin in the configure
step.
- openKylin: failure_paths_report_cleanly asserts that a read-only library
write fails, but the container runs as root, which bypasses the file
permission bits (CAP_DAC_OVERRIDE) and the write succeeds; skip that
sub-check when euid is 0 (read from /proc/self/status on Linux) and note
it in the log.
- Disable Windows Defender real-time/script/archive scanning (and exclude
the workspace, cargo, rustup and vcpkg trees) at the start of the
Windows job: the ephemeral runner spends a large share of a cold build
having every object file scanned.
- Raise the openKylin container /dev/shm from 2 GiB to 8 GiB: the suite's
parallel worker pools plus the 512 MiB shared-memory spike used to run
dry, surfacing as an intermittent SIGSEGV in the oak-render tests.
- Add a gdb backtrace step on failure for the big suites (the openKylin
image installs gdb) so a native crash lands in the log next time.
Four independent CI failures the first real cross-platform run surfaced:
- macOS SIGSEGV: the real-GL unit tests in gl_bridge ran wherever CGL is
available, including the headless CI runner. Gate them with the same
OAK_GPU_TESTS switch the integration GL tests already use (skip on CI,
opt in on a real Mac).
- Windows build: examples compile under `cargo test`, and bench_playback
used libc::getrusage unconditionally. Keep the Unix CPU accounting
behind #[cfg(unix)] and report zero CPU seconds elsewhere.
- openKylin arm64: engine_without_a_project_hits_the_guard_paths assumed
the library backend was unconfigured while a parallel config test
transiently set Storage/Backend=sqlite. Take the shared config lock and
pin the key off for the test's duration.
- openKylin x64: the prefetch smoke test asserted an exact decode count,
but the hand-off LRU holds only DECODE_LRU_CAP (2) frames, so a request
can miss the prefetched copy under scheduling pressure and re-run the
producer (the eval cache still serves the pixels). Bound the count
instead of pinning it; the deterministic sibling test pins read-ahead
usage.
Dropping a new clip whose in-point landed in empty track space (the
stored-range model allows holes between blocks; the C++ layout is
contiguous) left the overlapped clip untouched AND inserted the new clip
before it in track order, so it slid UNDER the clip it covered. Starting
on a clip already overwrote correctly, so the behavior depended on where
the in-point happened to fall.
TrackRippleRemoveAreaCommand::prepare now handles the hole case (no
block spans the range start): nothing is trimmed on the left, the
insertion anchor is the last block ending at/before the range, and the
shared trailing scan removes/head-trims the blocks the range covers.
Regression tests: domain_test (command level) and graphops (the app's
place_footage_clip path).
The openKylin container image ships no fonts at all, so the font-backend
combo test found zero families and failed both retries; install
fonts-dejavu-core in the job (the Ubuntu runner image already has them).
Also includes the runner-size bumps (windows 32x, macos 12x) and the
vcpkg/cargo cache save conditions (`if: always()`).
The macOS job finally reached the build (after the vcpkg manifest fix) and
hit a macOS-only compile error in the VideoToolbox import: `*ptr as
*const T` parses as `(*ptr) as *const T`, so `sw_format` was read off a
pointer instead of the AVHWFramesContext. Bind the frames pointer first.
Also fix the warnings the cross-check surfaced: the redundant
MTLPixelFormat import, and doc comments on an extern block and a
thread_local! (rustdoc does not document those).
Verified locally with a host-cc wrapper:
`cargo check -p oak-core -p oak-codec -p oak-node -p oak-render
-p oak-task -p oak-plugin --target aarch64-apple-darwin` is clean.
(oak-app itself needs a real Apple toolchain for ring.)
The other app test modules nest the process-wide locks language then
config; taking them the other way round could deadlock two tests running
in parallel.
On every startup (unless Preferences > General turns the new "Check for
updates" toggle off) the app GETs
https://www.oakvideoeditor.org/api/v1/update/latest, parses the
documented latest-release JSON and, when the remote version is newer
than the running build, prompts with a dialog whose primary button opens
https://www.oakvideoeditor.org/downloads. The blocking fetch runs on the
gpui background executor with a 5 s bound; transport and parse failures
are silent, and a release found while another modal is up (the project
manager on a fresh start) is deferred until the modal layer frees.
The transport sits behind an `UpdateTransport` seam so tests script the
response without touching the network; version comparison strips the
`v` prefix and pre-release suffixes and orders the components
numerically (an unparsable remote falls back to string inequality).
Help > Report a Bug... opens
https://www.oakvideoeditor.org/bug-report.
The eight shipped i18n packs carry the new menu/preferences/update keys.
The openKylin image runs as root while Actions sets HOME=/github/home;
dtolnay/rust-toolchain fails with "$HOME differs from euid-obtained home
directory" and the job never reaches the build. Pin HOME/CARGO_HOME/
RUSTUP_HOME to root's for the whole job.
vcpkg resolves the ffmpeg dependency before anything builds and rejects
the manifest because the pinned 8.1.2#3 port has no `png` feature
("ffmpeg@8.1.2#3 does not have required feature png needed by oak"),
so every desktop job died in "Install dependencies (vcpkg manifest)"
and never reached the build or test steps.
PNG decoding in FFmpeg needs zlib (png_decoder_deps=zlib); libpng is
only the encoder backend and this port never enables it. Request
`zlib` instead.
Also point the stale comments/docs at the actual pin: the override is
8.1.2#3 (matching the ffmpeg-next 8.x binding after the 9.0.0 binding
was found broken upstream), not 9.0.1#1.
PanelHandle snapshots DockPanel::title at registration and the tab strip
renders that cache, so switching the UI language at runtime (the menu's
language items or the preferences combo) left every docked tab in the
previous language: the English UI with Chinese tabs from the report.
Add dock panel title/content refresh to gpui (oak-gpui 45871acf1a):
DockArea::refresh_panel_titles re-reads every held title through a
type-erased provider captured from the concrete panel entity, marks each
panel view dirty so its localized content re-renders, and repaints the
chrome. Call it from both shell language-switch paths; the preferences
dialog repaints itself too.
The app test pins the refresh end to end: after LanguageChanged the
project tab's cached title follows the new language.
The two BlockCore length setters swapped their anchors relative to the
C++ semantics they document, so the ported edit commands produced wrong
geometry on the live UI paths: roll edits kept the seam still, slides
left negative in-points, and trims wrote the timeline in-point into
media_in (playing the wrong media content).
Adopt three stored-range primitives in block.rs:
- set_length_and_media_out: in fixed, out moves, media untouched
(resize, trim-out, gaps growing rightward).
- set_length_and_media_in: in fixed, out moves, media_in += old-new
(resize-with-media-in, splice right half, ripple trim-in).
- set_length_keeping_out (new): out fixed, in moves, media_in +=
old-new (trim-in body and out-neighbour, slide out-neighbour,
ripple trim-in of the trailing block).
Point every command at the primitive matching its intent (undopointer,
undogeneral, undoripple, undosplit, graphops, cli, nodeops) and fix the
two real defects the swap hid:
- TrackReplaceBlockWithGapCommand grew a following gap rightward,
swallowing whatever followed it: the "dragging one clip moves
unrelated clips" regression. The gap now grows leftward over the
removed block's span; regression test in domain_test.
- The ripple/splice trims now advance media_in instead of rewriting it,
and BlockSplitCommand writes both halves' ranges and media
explicitly (the second half continues from the split point).
Rewrite the KNOWN-SWAP expectations to the correct geometry (roll moves
the seam, slide has no negative in-point, insert-gaps grows rightward,
resize-with-media-in yields media_in = 20) and add the missing media
assertions. TrackSlideCommand documents that the caller positions the
sliding blocks (the stored model has no track layout).
The OCIO grading primaries expose contrast/offset/exposure as Vec4 inputs
(master + RGB); build_control had no Vec4 arm, so the inspector rendered an
empty read-only row instead of controls. Add a four-spin arm bounded by the
per-component min/max and stepped by the node's base.
Float inputs that only declare base (pivot 0.18, clampBlack/White) fell
through to the wide +/-10000 default and a single drag could hurl the value
thousands of units away; anchor the slider on value +/-100*base instead,
matching the C++ RationalSlider step semantics.
Mock/real engine boundaries, shell modals and menus, timeline/
inspector/node-editor/project-explorer panels, dialogs, and the
editor controls, including the review remediation assertions.
Render evaluation fallbacks, the process pool (dispatch, cancel,
restart, teardown), half-float display packing, and the worker's
shared-memory job paths; includes the M5 footage import acceptance
tests and the software-decode byte-exactness guard.
Mike-Solar