Dolby Atmos Speaker Tuning to EasyEffects Presets for Linux

Bring your laptop's Windows speaker tuning to Linux. This script converts the Dolby Atmos DAX3 tuning XML shipped inside Windows audio drivers into EasyEffects 8.x output presets — the same speaker correction, EQ, and dynamics processing your speakers get there, applied at zero added latency.

EasyEffects 8.x required. If your distro still ships EasyEffects 7 (Debian trixie, Ubuntu 24.04+, Fedora 43 and earlier), install the Flatpak — the EE 7 and EE 8 preset formats aren't compatible.

Don't want to run EasyEffects? The same tuning also runs as a self-contained PipeWire filter-chain — no GUI, no extra daemon. See PipeWire filter-chain under Advanced.

Contents: Quick start · Staying up to date · Supported devices · Install · Usage · Advanced · How it works · Running the tests · Further reading

Quick start

1. Install dependencies (see Install for your distro). TL;DR: Python 3 with NumPy and SciPy.

2. Run the script. If your Windows partition is mounted or a driver package is extracted in the current directory, no arguments are needed:

   python3 dolby_to_easyeffects.py --autoload
   

   Or point it at the Windows directory or a tuning XML explicitly:

   python3 dolby_to_easyeffects.py --windows /mnt/windows/Windows --autoload
   python3 dolby_to_easyeffects.py path/to/DEV_0287_SUBSYS_*.xml --autoload
   

The --autoload option wires EasyEffects to apply the Dolby correction on your internal speaker automatically. Skip it if you'd rather select a preset yourself (Presets → Dolby-Balanced / Dolby-Detailed / Dolby-Warm); see Autoload for details.

Staying up to date

Notable changes are tracked in CHANGELOG.md, and each version is published as a GitHub Release. To be notified when a new version ships, click Watch → Custom → Releases at the top of the GitHub page.

Entries tagged [AUDIBLE] change the sound of the generated preset — when you see one, pull the latest and re-run the script to regenerate and reload your preset to pick up the improvement (the run loads it into a running EasyEffects when it can, and says what to pick otherwise; filter-chain users re-run ee_to_pipewire.py too, since a conf carries the impulse as of its conversion). Other entries are tooling, packaging, docs, or new-device support that doesn't alter existing devices' output, so there's nothing to regenerate.

Each generated preset and .conf is stamped with the version that produced it (a _generator field in the preset JSON, a # version: line in the conf; --version prints it), so you can always tell what made a given file when reporting an issue.

Supported devices

The converter works on internal speakers whose Windows driver ships a Dolby DAX3 tuning (laptops, handhelds, etc.). Confirmed on:

If you test it on other hardware, please open a device report whether it works or not.

Install

The script needs Python 3, NumPy, and SciPy. PipeWire's pw-dump is also required — by --autoload here, and by the PipeWire scripts whenever they auto-detect your speaker sink (every run without --target-sink). It ships in the same package as the daemon on Debian, Ubuntu and Arch, but Fedora, openSUSE and Alpine split the command-line tools into their own package; the scripts name it for your distribution if it turns out to be missing. Rich and rich-argparse are optional — with them the script renders its output and --help with semantic colors; without them everything still works in plain monochrome. argcomplete is optional too, for shell tab-completion.

If your distro isn't listed or you'd rather not touch system packages, a venv works too:

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

requirements.txt also pulls in pytest and pytest-xdist so you can run the test suite (pytest tests/) from the same venv — pyproject.toml passes -n auto, so pytest won't start without xdist.

Usage

Command-line options

Tuning input — with neither an XML path nor --windows, the script auto-discovers: it probes mounted Windows partitions (/proc/mounts) and the current directory for a tuning source

• xml_file (positional, optional) — path to the Dolby DAX3 tuning XML (e.g. DEV_0287_SUBSYS_*.xml)
• --windows DIR — auto-discover the tuning XML from a mounted Windows directory (matches the audio codec subsystem ID from /proc/asound)
• --best-guess — if auto-detection finds no exact hardware match, fall back to the only internal-speaker tuning whose manufacturer is present (or list the candidates to pick one with the positional XML path); reach for it when a SoundWire device reports "No matching DAX3 tuning XML found"

Inspection

• --list — show available endpoints and profiles in the XML, then exit
• --speaker-info — report detected audio hardware and speaker layout, then exit
• --doctor (alias --diagnose) — run environment self-diagnostics (hardware, install location, EasyEffects version/compatibility, preset + impulse-file integrity, the selected preset, background service mode + autostart) and exit; the checks and what to do about them print last. If a generated preset seems inaudible, run this first and paste the output into an issue. See Troubleshooting below

Profile selection

• --endpoint TYPE — endpoint type (default: internal_speaker)
• --mode MODE — endpoint operating mode (default: normal). Convertible laptops (Yoga-class) ship distinct tunings per hinge pose — try --mode tablet, stand, tent, or lid_close if --list shows them for your device.
• --profile TYPE — profile type, e.g. dynamic, music, voice (default: first profile)
• --all-profiles — generate presets for all profiles in the selected endpoint/mode

Output

• --prefix NAME — change preset name prefix (default: Dolby → Dolby-Balanced, etc.)
• --output-dir DIR — EasyEffects preset directory (default: ~/.local/share/easyeffects/output/)
• --irs-dir DIR — impulse response directory (default: ~/.local/share/easyeffects/irs/)

Autoload

• --autoload [PRESET] — write EasyEffects autoload config for speaker outputs; defaults to the first Balanced preset generated
• --autoload-dir DIR — autoload config directory (default: ~/.local/share/easyeffects/autoload/output/)
• --autoload-sink NODE_NAME — bind autoload to an explicit PipeWire sink, bypassing speaker detection (repeatable). Use it if detection picks the wrong output or finds none (e.g. a device whose speaker isn't tagged audio-speakers). Find the name with pw-dump | grep node.name. See Autoload below.
• --no-autoload-bypass — with --autoload, don't write a Nothing bypass preset or enable EasyEffects' global Fallback Preset. See Autoload below.

Filter tweaks

• --disable NAME — drop a filter from the generated preset (repeatable). Valid names: volmax, mbc, regulator, coupled-bands, autogain, bass-enhancer, dialog, high-shelf, lo-pass. See Disabling and enabling filters below.
• --enable NAME — switch on an optional stage the preset leaves off (repeatable, mirroring --disable). Valid names: autogain, level-restore, virtual-bass. See Disabling and enabling filters below.
• --volmax-slot {input-gain,output-gain} — where the volmax-boost loudness gain is injected. Default input-gain runs it through the per-band regulator so loud bass doesn't distort (issue #23); output-gain is the older placement (opt-out for A/B, or to bring back bass and loudness an aggressive regulator takes away — issue #44). See Disabling and enabling filters.

General

• --verbose (alias -v) — print the full frequency tables (hidden by default); include a -v log when reporting a sound problem
• --dry-run — run without writing any files to disk (presets, IRs, autoload); useful for debugging script execution and output
• --no-reload — don't ask a running EasyEffects to load the preset when the run finishes; presets are still written (no effect under --dry-run, or when --output-dir/--irs-dir point outside EasyEffects' own folders)
• --skip-ee-check — skip the end-of-run EasyEffects environment check; for workflows that don't target an EasyEffects install (dolby_to_pipewire.py passes it automatically)
• --skip-closing — skip the end-of-run closing blocks (what was written and how to use it, plus the report-back block); for wrappers that install elsewhere and present their own
• --no-color — disable colored terminal output
• --version — print the version and exit

When --mode or --profile is specified (or --all-profiles is used), the preset names include them (e.g. Dolby-Music-Balanced, Dolby-Tablet-Voice-Warm).

Troubleshooting: a preset that sounds like nothing

If you generated a preset, loaded it in EasyEffects, and hear no difference versus bypass, check the EasyEffects setup around it before suspecting the preset — each of the following makes a correct preset inaudible. Run:

python3 dolby_to_easyeffects.py --doctor

It checks the common causes and prints a pasteable report:

• EasyEffects 7 — version 8 changed the preset format, so on EasyEffects 7 the speaker-correction filter loads nothing and the preset is effectively bypassed. This repo targets EasyEffects 8.x (see the note at the top — install the Flatpak if your distro still ships 7).
• Wrong install location — presets written to the Flatpak path while you run the native package (or vice-versa), so EasyEffects never sees them.
• A missing impulse file — the convolver references a .irs that isn't in the irs directory, so the speaker correction is silent.
• No Dolby preset selected, or EasyEffects' global bypass is on — the highlighted top-left toggle below. If your output is a headset, HDMI or Bluetooth, Nothing being selected is the expected bypass fallback rather than a fault, and --doctor says so — it reports which preset your speakers autoload instead.
• EasyEffects not running in the background — the preset only processes audio while EasyEffects is active, so it can vanish after you close the window or reboot. In EasyEffects → Preferences → Background Service (below), enable Enable service mode and Autostart on login. --doctor reports whether both are set.

A normal generation run also warns at the end if it detects an EasyEffects version that can't use the presets it just wrote. To check your version directly, see EasyEffects' About dialog:

Everything above is about the EasyEffects setup. On the PipeWire filter-chain route, run python3 dolby_to_pipewire.py --doctor instead — it checks that route's own failures (chains stacked on one sink, a conf that didn't load, a missing impulse file, a target sink that's gone).

Troubleshooting: correct but too quiet

If the preset sounds right but quieter than Windows, part of the gap is expected: Dolby's dynamic volume leveler ships bypassed here because without Dolby's content analysis it distorts on quiet→loud transitions (why). What to try, in order:

• Re-run the script with --enable autogain — the volume leveler ships bypassed by default and carries most of the loudness gap (~+9 dB measured on program material). The trade-off: without Dolby's content analysis it can audibly saturate when loud sound arrives over a quiet background (why it isn't the default); if you hear that, drop the flag again. For still more loudness raise the Autogain Target a few dB in the EasyEffects GUI, at increased saturation risk. If you instead enable Autogain by hand on a preset generated before this option existed, also raise its Silence threshold to about −50 dB, or sounds arriving after silence will crackle.
• If it is quieter than with the preset switched off entirely — not just quieter than Windows — re-run with --enable level-restore. The impulse response is normalised so its loudest band sits at 0 dB, and on a tuning whose peak exceeds its volmax-boost that leaves the whole preset below bypass; the flag hands that level back. Experimental: the restored level also drives the final limiter harder, and on the one device that has listened, loud speech picked up audible artifacts — if yours does too, add --disable volmax or drop the flag, and report either way on #50. The script's end-of-run menu offers this flag only on tunings where it would change the level; see Disabling and enabling filters.
• Allow volume above 100% in your desktop environment: GNOME — gsettings set org.gnome.desktop.sound allow-volume-above-100-percent true; KDE Plasma — volume applet settings → Raise maximum volume; any environment — wpctl set-volume @DEFAULT_AUDIO_SINK@ 1.25, or pavucontrol. Over-amplification is digital gain applied after the preset's limiter, so extreme values can clip.
• Check mixer levels — in alsamixer, Master/PCM/Speaker at 100%.
• On the PipeWire path, check which output is selected — if sound settings show the filter chain itself (Dolby-… (speaker filter)) instead of your speakers, its volume and your speakers' both apply; pick your speakers, since the chain is inserted into them automatically. python3 dolby_to_pipewire.py --doctor reports which is selected.
• On a device whose regulator is aggressive, --volmax-slot output-gain can bring back bass (and a little loudness) the per-band limiter takes away — confirmed by ear on one device (#44); see Disabling and enabling filters.
• Speakers thin and quiet even with EasyEffects off — run --speaker-info: a flagged amplifier-firmware error means your distro lacks this machine's speaker firmware, which no preset can fix (background; issue #27 links a worked, device-specific example of extracting it from the Windows driver).

Disabling and enabling filters

If the generated preset has audible artifacts on your hardware (saturation, pumping, harsh highs, uncomfortable stereo width), you can rebuild it without specific filters rather than hand-editing the chain inside EasyEffects. Repeat --disable NAME as many times as needed:

The mirror direction: some filters ship in the preset but inactive, and --enable NAME switches them on:

Convolver, PEQ, and the final brickwall limiter can't be toggled from the CLI — they're the FIR correction, speaker PEQ, and safety net.

To work out which stage you're hearing, switch effects off one at a time in the EasyEffects window instead of rebuilding: turning off Convolver isolates the speaker-correction curve from everything dynamic, and turning off the Multiband Compressor that carries the per-band limiter takes out the loudness boost riding it as well. Most tunings produce only one Multiband Compressor, which is that limiter; where Dolby's own multi-band compressor is also present you get two, and the limiter is the second of them. The run's own output names which stages it built.

Advanced

Autoload

--autoload configures EasyEffects to apply a preset automatically whenever the internal speaker output becomes active. Generate all presets and autoload one on the speaker:

python3 dolby_to_easyeffects.py --windows /mnt/windows/Windows \
    --all-profiles --autoload Dolby-Dynamic-Balanced

It writes a {node.name}:{route}.json autoload file to ~/.local/share/easyeffects/autoload/output/, detects the speaker sink via pw-dump, and also installs an empty Nothing bypass preset so non-speaker outputs (HDMI, Bluetooth, USB) don't keep processing the speaker tuning. Run it from a desktop session with PipeWire running. A running native EasyEffects (8.0.9+) gets the preset loaded into it right away; when the run can't reach it (Flatpak keeps the socket inside its sandbox) or leaves it alone (it says so: a non-speaker output, or the Nothing bypass preset already active), restarting EasyEffects lets the autoload pick it up — and restart it anyway for the fallback setting to take effect. For the autoload to take effect on every login, also enable Background Service + Autostart on login in EasyEffects' preferences (see Troubleshooting) so EasyEffects is actually running when the speaker becomes active. Pass --autoload-sink NODE_NAME to bind a sink yourself, or --no-autoload-bypass to skip the bypass.

PipeWire filter-chain instead of EasyEffects

The same tuning runs as a self-contained PipeWire filter-chain .conf — no GUI, lower CPU, set-and-forget, and it works whether or not EasyEffects is installed. dolby_to_pipewire.py produces it in one command; under the hood it drives the preset generator and the ee_to_pipewire.py converter (design notes and equivalence measurements: docs/ee-to-pipewire.md).

Quick start (PipeWire)

One command goes from tuning XML to an active sink: the EasyEffects preset is generated in a throwaway temporary directory (nothing is installed under ~/.local/share/easyeffects), converted to a conf with the matching .irs copied beside it, then PipeWire is restarted and the sink verified. Prerequisites are the generator's Python dependencies (NumPy/SciPy — see Install) plus the LSP/Calf LV2 plugins (see Plugin dependencies and validation below); the tuning XML is located the same way as the main Quick start (auto-discovery, --windows, or manual extraction).

python3 dolby_to_pipewire.py         # add --no-activate to restart PipeWire yourself

The default converts the Balanced voicing — Dolby's default voicing. --variant detailed and --variant warm pick the others, and --variant all --target-sink '' creates one sink per variant so you can A/B them from sound settings (smart-filter routing has to be off for that, or PipeWire runs the three in series instead of offering a choice). Expect a subtle difference: the three voicings sit at most about 1 dB apart (a broad tilt through the mids and treble), so an A/B that isn't gapless may not show it. The voicing curves are Dolby-global, and the device-specific correction applies under every one — details.

The conf lands in ~/.config/pipewire/pipewire.conf.d/ and attaches transparently to your internal-speaker sink — apps keep targeting the speaker, while HDMI / Bluetooth / USB outputs bypass it automatically. Stereo only. It covers the convolver, PEQ, dialog, multiband compressor, regulator and limiter, plus bass_enhancer / stereo_tools; an active volume leveler (autogain) is translated too, and only 4-channel upmix isn't (see Limitations).

• Already run EasyEffects? Quit it and stop it starting again (its Background Service and autostart, or remove its autoload) before activating, or both chains process the audio at once. Restarting PipeWire stops it for the session anyway, so whatever it was applying stops too.
• No sound, or it doesn't sound right? python3 dolby_to_pipewire.py --doctor reports what's installed, what PipeWire is doing with it, and what to do about each problem it finds.
• To remove the filter: delete ~/.config/pipewire/pipewire.conf.d/Dolby_Balanced.conf (and the .irs beside it), then restart pipewire.

# 1. Generate the preset JSON (no EasyEffects install required)
python3 dolby_to_easyeffects.py            # omit --autoload; that only wires EE

# 2. Convert it to a filter-chain conf (the matching .irs is copied beside it)
#    Step 1 prints where it wrote the preset — on a Flatpak EasyEffects that
#    is under ~/.var/app/com.github.wwmm.easyeffects/, not the path below.
python3 ee_to_pipewire.py ~/.local/share/easyeffects/output/Dolby-Balanced.json

# 3. Activate
systemctl --user restart pipewire pipewire-pulse

# 4. Confirm the sink is loaded
pw-cli ls Node | grep Dolby_Balanced

Which should I use?

The two paths sound the same (measured equivalent) — choose on everything else:

• Features → EasyEffects. A GUI to tweak and switch presets live. The volume-leveler / autogain (EE-native libebur128) is now translated on the PW side too, to LSP autogain_stereo (a K-weighted LUFS AGC) — so it's no longer an EE-only stage. It runs by default on SoundWire devices; on HDA the generator leaves autogain bypassed unless you pass --enable autogain, because its loudness boost can audibly saturate on quiet-background content (why).
• Lightness / headless / set-and-forget → the PW conf. No GUI, no extra daemon. On the development device (X1 Yoga, Dolby-Balanced, 48 kHz) the filter-chain costs ~11 % fewer CPU cycles and ~3.5× less RAM (~78 MB vs ~270 MB — the EasyEffects process is mostly Qt/GUI) than running EasyEffects. Both are light in absolute terms — the DSP is roughly a tenth of one CPU core (well under 1 % of a typical multi-core laptop) — so the memory and feature differences usually matter more than the CPU one.
• Latency → a wash. Both add zero latency over the PipeWire quantum (minimum-phase FIR), and both ran xrun-free at 1024/48 kHz.

Those CPU/RAM figures are device-specific; reproduce them on your own hardware with tools/measure_perf/ (frequency-invariant perf-cycle measurement, since laptop clocks don't hold still).

Extracting the XML

The easiest way is to use --windows to auto-discover the XML from a mounted Windows partition. The script reads your audio codec's device and subsystem IDs from /proc/asound and matches them against the XMLs in the DriverStore.

C:\Windows\System32\DriverStore\FileRepository\dax3_ext_*.inf_*\DEV_*_SUBSYS_*.xml

# 1. Extract only the Dolby tuning XMLs into ./driver-cache/
innoextract -I 'code$GetExtractPath$/Dolby/03_dax_ext' -d ./driver-cache ./n4ba126w.exe

# 2. Generate presets (autoprobe finds the extracted XMLs automatically)
python3 dolby_to_easyeffects.py --autoload

Auto-detection notes

Shell tab-completion

Optional with argcomplete installed (python3-argcomplete on Debian/Ubuntu/Fedora/openSUSE, python-argcomplete on Arch, py3-argcomplete on Alpine), all three scripts tab-complete their flags, the --disable / --enable / --variant value lists, file and directory paths, and your live PipeWire sink names for --autoload-sink and --target-sink.

Argcomplete is off until you register it. Add one line to your shell's rc file — ~/.bashrc, or ~/.zshrc after its compinit line:

eval "$(activate-global-python-argcomplete --dest=-)"

Run the scripts directly — ./dolby_to_easyeffects.py … — to get completion. In bash that hook also covers the python3 dolby_to_easyeffects.py … form used elsewhere in this README; in zsh it does not, because zsh's own python completion takes precedence over it.

To scope completion to these three scripts rather than every argcomplete-enabled program, run eval "$(register-python-argcomplete dolby_to_easyeffects.py)" once per script instead — that form covers ./dolby_to_easyeffects.py only, in both shells.

How it works

The script parses the DAX3 XML's two processing stages and emits a minimum-phase FIR impulse response plus a chain of EasyEffects plugins — every parameter traced back to an XML field, at zero added latency.

flowchart LR
  XML["DAX3 tuning XML<br/>(Windows driver)"] --> P["dolby_to_easyeffects.py<br/>parse CP + VLLDP"]
  P --> FIR[".irs FIR<br/>impulse response"]
  P --> PRM["plugin params<br/>EQ · MBC · regulator · limiter"]
  FIR --> EE["EasyEffects preset"]
  PRM --> EE
  EE --> SPK(["device speakers"])

The preset is up to eight plugins in order: Convolver (FIR speaker correction) → Bass Enhancer (SoundWire only) → Equalizer (speaker PEQ) → Dialog Enhancer → Autogain (bypassed by default) → Multiband Compressor → Regulator (per-band limiter) → Limiter (brickwall safety net).

For the full detail, see the docs:

• docs/reference.md — the current-state reference: every XML→parameter mapping, the plugin chain in detail, units, profile differences, which mappings are DAX-validated, and what's deliberately not implemented (and why).
• docs/design-notes.md — the research log: why the chain is ordered this way, the FIR cepstral construction, what was attempted and rejected, and the open threads worth picking up.
• docs/cross-device-findings.md — empirical analysis across ~2,800 DAX3 files: which DSP blocks are universal vs. device-specific. docs/corpus.md describes what that collection is made of.

Running the tests

A pytest suite under tests/ covers the converter without requiring any proprietary Dolby tuning data as input.

pytest tests/

The bulk of the suite (DSP math, output schema, a dedicated regression suite for every shipped-bug "trap", and --disable/argparse behavior) runs in a couple of seconds and needs no setup. It uses synthetic, hand-built inputs only — no real DAX3 XML is shipped or checked in.

The corpus tier under tests/corpus/ runs the full pipeline (parse → FIR → preset → IRS) against a corpus of real DAX3 XMLs. It auto-discovers them the same way the main script does — NTFS-family mountpoints whose DriverStore contains dax3_ext_*.inf_*, plus a bounded walk of the current working directory for any folder containing Dolby-shaped XMLs. To override, point it at a specific directory:

ATMOS_CORPUS_DIR=/path/to/dax3/xmls pytest tests/corpus/

If no corpus is reachable and ATMOS_CORPUS_DIR is unset, the corpus tier skips cleanly.

The heaviest tiers walk every endpoint/profile/curve combination and validate every discovered XML's generated PipeWire conf through lv2info; both are gated behind --run-slow (or ATMOS_RUN_SLOW=1). Every run fans across your cores via pytest-xdist (-n auto, set in pyproject.toml), which turns the heavy tiers from tens of minutes into a few. Pass -n 0 to force a serial run, which is what you want alongside -x, -s or --pdb.

The suite catches structural regressions (FIR not minimum-phase, convolver autogain accidentally re-enabled, MBC compression-mode flipped to upward, enums emitted as integers, etc.) but does not substitute for listening tests after any change to the output path.

Further reading

In-tree docs and tooling with more context:

• docs/reference.md — current-state reference: XML→parameter mappings, the plugin chain, units, profile differences, and what's not implemented
• docs/design-notes.md — research log: why the plugin chain is ordered the way it is, gain-staging rationale, why autogain is bypassed by default, and an empirical comparison of our generated FIR against DAX3's actual response on Windows
• docs/code-organisation.md — how the two entry points were split into lib/: the module shape it landed in, and the git discipline that keeps git blame -C tracing code back through an extraction
• docs/cross-device-findings.md — empirical analysis of ~2,800 DAX3 tuning files across Realtek, Senary, Qualcomm Aqstic, and SoundWire smart-amp codecs, including which DSP blocks are unmodeled
• docs/corpus.md — what those tuning files are: how one is counted, which OEM driver package each came from, what the collection is skewed towards, and how to compare your own against it
• docs/alternative-pipelines.md — design sketches for offloading parts of the pipeline to Intel SOF DSP or running under PipeWire filter-chain instead of EasyEffects
• docs/ee-to-pipewire.md — current architecture of the ee_to_pipewire.py companion converter: smart-filter routing, self-contained conf layout, plugin coverage, and equivalence guarantees
• tools/measure_dax/ — Windows-side capture + Linux-side analysis scripts for measuring DAX3's actual response via WASAPI loopback. Reproduces the empirical comparison in design-notes.md on any Lenovo/ThinkPad with DAX3 installed.
• tools/measure_ee/ — Linux-side counterpart: captures the live EasyEffects pipeline (with our generated preset applied) into the same loopback_*.{wav,json} schema, so tools/measure_dax/analyze.py and tools/measure_ee/compare_ee_vs_dax.py can overlay the EE-on-Linux response next to the DAX-on-Windows reference.
• tools/measure_pw/ — captures and validates the PipeWire filter-chain rendering of the same preset (ee_to_pipewire.py companion). A validate_conf.py deterministic schema check catches inverted bools / unknown ports / out-of-range values without any audio capture, and compare_ee_vs_pw.py / _time_domain.py overlay the PW captures against the EE-side captures from tools/measure_ee/.
• tools/measure_perf/ — measures what the two delivery paths cost (where measure_pw proves they sound the same): EasyEffects vs the PipeWire filter-chain, in frequency-invariant perf CPU cycles, memory, and xruns. Backs the README "Which should I use?" guidance.

References

• wwmm/easyeffects — preset format reference
• shuhaowu/linux-thinkpad-speaker-improvements — alternative approach using captured impulse responses via WASAPI loopback
• taprobane99/Lenovo-Yoga-Slim-7x-Dolby-Linux-Audio — downstream port of this script's output to a PipeWire filter-chain config with 4-speaker upmix on Snapdragon X (see docs/alternative-pipelines.md Option 3)
• sklynic/easyeffects-tuf-gaming-a15 — manual DAX3 EQ extraction for ASUS laptops
• mister2d/thinkpad-linux-audio — extended Dolby pipeline for ThinkPads, built on top of this tooling (#2)