Home / Guides / Capture an Impulse Response (Windows)
Capture an Impulse Response of a System DSP on Windows
You can extract a faithful impulse response (IR) of any Windows-side system DSP chain — DTS:X Ultra, Nahimic, Dolby Atmos for Headphones, EQ APO, OEM speaker correction — by playing a known sine sweep through it, capturing the processed output bit-identical via WASAPI process loopback, and deconvolving. The resulting IR is a mathematical fingerprint of the DSP that can be replayed on any platform (Linux, macOS, mobile, a DAW with a convolver plugin) to reproduce the original processing exactly. This guide walks the full workflow with AudioRoute as the capture tool.
You can capture an impulse response (IR) of any Windows system DSP — DTS:X Ultra, Nahimic, Atmos, EQ APO — by playing a known log sine sweep through it, capturing the processed output bit-identical with AudioRoute's WASAPI process loopback, and deconvolving the capture against the source. The resulting IR is a portable fingerprint of the DSP that you can replay on any platform with a convolver plugin.
- Set the output device's Default Format to a known rate (96 kHz / 32-bit float is a good default) and turn Audio Enhancements off.
- Generate a 10-second log sine sweep WAV at that same rate, with 200 ms of silence padding at each end.
- In AudioRoute, set Rec Rate to Auto and Bit Depth to 32-bit float, hit Record, and play the sweep through your DSP.
- Deconvolve the captured sweep against the source sweep (a short NumPy + SciPy script) to extract the IR.
- Load the IR into any zero-latency convolver plugin to replay the DSP on any platform.
- Why this works (the short version)
- What you need
- Step 1 — Set the device's Default Format
- Step 2 — Generate a log sine sweep
- Step 3 — Capture the processed output with AudioRoute
- Step 4 — Deconvolve to extract the IR
- Step 5 — Apply the IR with a convolver
- Verifying your capture was clean
- The OS anti-click onset trap (don't skip this)
- Other common gotchas
- Use cases this is good for
- FAQ
Why this works (the short version)
Convolution + deconvolution gives you a clean way to characterise any linear time-invariant system from the outside. Play a known excitation signal in, record what comes out, divide the output by the input in the frequency domain, and what you get is the system's impulse response — everything the system did to the signal, captured as a single time-domain function.
For this to produce a clean IR, the capture path between the system's output and your file must add nothing. No resampling, no filtering, no gain offset, no dithering. If the capture path is lossy in any way, the lossiness gets baked into the IR and the next time you convolve, you're reproducing DSP + capture artifacts rather than DSP alone.
Windows' WASAPI process loopback API gives you exactly this property at matched rates. The audio engine mixes everything to its native format (almost always 32-bit float at the device's configured rate); loopback reads those mixed frames directly. If your loopback client requests the same format, the API's internal converter is a no-op — the captured samples equal the engine's mix samples bit-for-bit. We verified this with a null-test harness shipping with AudioRoute 0.1.15: max |c − s| = 0 across 48 kHz / 96 kHz and multiple source types.
That's the guarantee your IR workflow depends on. The rest of this guide is the practical recipe.
What you need
- Windows 10 (build 1903 or later) or Windows 11 — required for WASAPI process loopback.
- AudioRoute 0.1.15+ — free 14-day trial. Standalone tray app, no DAW required for this workflow.
- Whatever DSP chain you want to capture, active and processing audio on your default output device. For DTS:X Ultra / Nahimic / Atmos, that's the OEM app running in its normal "on" state. For EQ APO, the config loaded.
- A way to generate a log sine sweep WAV at the device's native rate. Several options — Audacity (Generate → Tone with Logarithmic sweep), REW, or a 20-line Python script (provided below).
- A Python install with NumPy + SciPy for the deconvolution step (~10 lines of code).
- A convolver plugin or app wherever you want to replay the IR: Reaper's free ReaVerb, the free Acourate demo, JamesDSP for Linux, Pulsar Mu for DAWs — any zero-latency convolver works.
Headphones note. If the DSP you're capturing is headphone-specific (Atmos for Headphones, Sonic, certain DTS profiles), the IR is tuned to those specific headphones via head-related transfer function modelling. The captured IR will only reproduce that experience on the same headphone hardware. For speaker DSPs (DTS:X Ultra speaker mode, OEM speaker correction), the IR is tuned to the device's speakers. Be precise about which output mode is active when you capture.
Step 1 — Set the device's Default Format
Open Settings → System → Sound → your output device → Properties → Advanced → Default Format (the exact path varies a little between Windows builds; on older builds it's Sound Control Panel → right-click device → Properties → Advanced).
Pick a rate appropriate for what your DSP is doing. 96 kHz / 32-bit float is a good default — high enough that any DSP doing internal up-sampling has headroom to operate, low enough that file sizes stay manageable. 48 kHz works fine if your DSP is documented to run at 48 kHz. Going higher than 96 kHz rarely buys anything because most DSPs cap their internal processing rate.
Disable any "Audio Enhancements" you don't want in your IR. In the same Advanced page there's an Audio Enhancements toggle — this controls additional system-level effects that sit between your target DSP and the loopback tap. If you leave them on, they get baked into your IR. For a clean DTS:X-only IR, set Enhancements to Off here and leave only DTS active in its own app.
Step 2 — Generate a log sine sweep
A logarithmic sine sweep (also called an exponential sweep) is the standard excitation signal for IR measurement. It distributes equal energy per octave from a low frequency to a high one, which gives you a clean impulse response after deconvolution even in the presence of moderate non-linearity in the DSP. White noise also works but log sweeps separate harmonic distortion artefacts from the IR cleanly.
A 10-second log sweep from 20 Hz to (your device rate / 2 × 0.95) is a good default. Here's a short Python snippet that produces a 96 kHz, stereo, 10-second log sweep WAV with a 200 ms silence pad at both ends (the silence pad is important — see the onset trap section below):
import numpy as np
from scipy.io import wavfile
sr = 96000 # sample rate (Hz)
duration = 10.0 # sweep duration (seconds)
f_start = 20.0 # start frequency (Hz)
f_end = 0.95 * sr / 2 # end frequency (just under Nyquist)
silence = 0.200 # leading + trailing silence (seconds)
amplitude = 0.5 # peak amplitude (-6 dBFS, safe headroom)
t = np.linspace(0, duration, int(sr * duration), endpoint=False)
k = np.log(f_end / f_start)
sweep = amplitude * np.sin(
2 * np.pi * f_start * duration / k * (np.exp(t * k / duration) - 1)
)
pad = np.zeros(int(sr * silence))
mono = np.concatenate([pad, sweep, pad]).astype(np.float32)
stereo = np.column_stack([mono, mono]) # identical L/R for a mono DSP
wavfile.write("sweep-source.wav", sr, stereo)
print(f"Wrote sweep-source.wav: {len(mono)} samples, {len(mono)/sr:.2f} s")
Run that script. You now have sweep-source.wav — a known, clean log sweep at your device's native rate. Keep this file; you'll need it for the deconvolution step.
Step 3 — Capture the processed output with AudioRoute
In the AudioRoute tray, expand Advanced and set:
- Rec Rate: Auto — resolves to the device's mix rate (the 96 kHz you just set in Step 1) and initialises the loopback client at that rate so the API's internal converter doesn't engage.
- Bit Depth: 32-bit float — matches the engine's internal format; no depth conversion.
Then:
- Make sure your target DSP is active and processing audio normally. If it's been idle for a while, play any sound first to wake the engine up (this matters for avoiding the OS onset transient on the actual capture).
- In AudioRoute, hit Record to File.
- In any media player (foobar2000, VLC, Audacity, whatever), play
sweep-source.wavfrom beginning to end. The 200 ms silence pads at both ends give you alignment headroom. - When the file finishes playing, stop the AudioRoute recording.
You now have a captured file (default location %USERPROFILE%\Music\AudioRoute\recording_<timestamp>.wav) containing the same log sweep, but processed by everything the engine and your target DSP did to it on the way out. Rename it to sweep-captured.wav for clarity.
Step 4 — Deconvolve to extract the IR
The math: in the frequency domain, your captured sweep is the source sweep convolved with the DSP's impulse response. Convolution in the time domain is multiplication in the frequency domain. So dividing the captured spectrum by the source spectrum gives you the DSP's frequency response, and the inverse FFT of that is the IR.
A practical Python script:
import numpy as np
from scipy.io import wavfile
from scipy.signal import fftconvolve
# Load source + captured
sr_s, src = wavfile.read("sweep-source.wav")
sr_c, cap = wavfile.read("sweep-captured.wav")
assert sr_s == sr_c, "Source and capture must be at the same rate"
sr = sr_s
# Use left channel only for the IR (or process L+R separately for a stereo IR)
src = src[:, 0].astype(np.float64) / np.iinfo(src.dtype).max if src.dtype != np.float32 else src[:, 0].astype(np.float64)
cap = cap[:, 0].astype(np.float64) / np.iinfo(cap.dtype).max if cap.dtype != np.float32 else cap[:, 0].astype(np.float64)
# Trim the first 200 ms of the capture to skip the OS anti-click ramp
# (see "The OS anti-click onset trap" section)
trim = int(0.200 * sr)
cap = cap[trim:]
# Time-align: cross-correlate to find offset of source within capture
corr = fftconvolve(cap, src[::-1], mode="full")
offset = np.argmax(np.abs(corr)) - (len(src) - 1)
cap_aligned = cap[offset : offset + len(src)]
# Pad to next power of 2 for FFT efficiency
N = 1 << (len(src) - 1).bit_length()
src_fft = np.fft.rfft(src, N)
cap_fft = np.fft.rfft(cap_aligned, N)
# Regularised inverse to avoid division-by-zero at the sweep boundaries
eps = 1e-8 * np.max(np.abs(src_fft))
ir_fft = cap_fft * np.conj(src_fft) / (np.abs(src_fft)**2 + eps**2)
ir = np.real(np.fft.irfft(ir_fft, N))
# Trim to a reasonable IR length (most DSP IRs are < 1 second)
ir = ir[:int(0.5 * sr)]
# Normalize peak to -0.5 dBFS to avoid clipping when convolving later
ir = ir / np.max(np.abs(ir)) * 0.95
wavfile.write("dsp.ir.wav", sr, ir.astype(np.float32))
print(f"Wrote dsp.ir.wav: {len(ir)} samples, {len(ir)/sr*1000:.1f} ms")
Run the script. dsp.ir.wav is now a single-channel 32-bit float WAV containing the impulse response of your DSP chain. Most useful IRs from system DSPs are in the 50–500 ms range; longer than that and you're probably capturing room reflections or noise floor.
You can sanity-check the IR by plotting its frequency response — scipy.signal.freqz works, or just 20 * np.log10(np.abs(np.fft.rfft(ir))) with a matplotlib semilog-x plot. A well-captured DSP IR will show a clean curve corresponding to the EQ shape your DSP applies.
Step 5 — Apply the IR with a convolver
The captured IR is now portable to anything that runs a convolver plugin. A few options by platform:
- Any DAW (Mac or Windows): ReaVerb (free, ships with Reaper), Sienna Soft Concerto, Pulsar Mu, SIR Audio Tools SIR3. Load
dsp.ir.wavas the impulse, put the convolver on the master bus, enable. - Linux: JamesDSP via DeckSP / GnomeDSP, or any LV2 convolver plugin in Carla / Cardinal. The original Reddit GPD Win 5 thread that inspired this guide uses exactly this path.
- macOS system-wide: load it into AudioRoute's host DAW of choice as a convolver chain, route system audio in via the VST3/AU. Or use Insert (system-wide AU host) with a convolver AU.
- Standalone playback on Windows: Equalizer APO with the convolver plugin, or a JamesDSP build for Windows.
Play any source through the convolver and the IR replays your DSP exactly. Toggle the convolver to A/B against the dry signal to confirm.
Verifying your capture was clean
Before you trust the IR, verify the capture stage was bit-clean. Three quick checks:
- Rate / depth / channels match. Open the captured file in any audio inspector. It should be at the same rate as
sweep-source.wav, 32-bit float, stereo. If it's anything else, the loopback API resampled — restart the capture with Rec Rate on Auto. - Visual sweep check. Open both files side by side in Audacity. The captured sweep should look like the source sweep with a frequency-dependent gain envelope applied (that envelope is the DSP's response). The shape should be smooth, not chunky or aliased. Pre/post-silence padding should be intact at both ends.
- Null test the bypass case. Optional but conclusive: temporarily disable the DSP, capture the sweep again, null-test the bypassed capture against
sweep-source.wav. If you get digital silence (or near it, <-100 dBFS), the capture path itself is contributing nothing — any residual you measure with the DSP enabled is purely the DSP's processing.
The OS anti-click onset trap (don't skip this)
This is the single biggest source of weird IRs and we found it the hard way during the bit-perfect capture verification work in AudioRoute 0.1.15.
Windows' audio engine applies a short anti-click fade-in ramp to the first ~50–100 ms of any freshly started render stream. The ramp is faithfully captured by loopback because it really is what the engine is producing — but it's not part of your DSP's processing. If your sine sweep starts at the very beginning of a freshly-launched playback session, that ramp contaminates the onset of your captured sweep, which then contaminates the low-frequency end of your IR after deconvolution.
Two mitigations, both effective:
- Prepend silence to the sweep source (the Python generator in Step 2 does this — 200 ms leading silence). The OS applies its ramp to the silence; the sweep itself starts well after the ramp has completed.
- Trim the first ~200 ms of the captured file before deconvolving (the deconvolution script in Step 4 does this).
The two together give belt-and-braces protection — you can do either and the IR comes out clean.
Other common gotchas
Don't re-route audio output to a virtual device
Many DSPs (DTS:X Ultra is the canonical example) refuse to process audio if their target endpoint isn't the system's "real" output device. Tools like VoiceMeeter, VB-CABLE, or aggregate device tricks redirect output to a virtual device — which causes DTS to detect a different endpoint and either disable itself or show a "connect external speakers" error. WASAPI process loopback (and AudioRoute) sidesteps this entirely because the loopback tap reads the engine's mix without changing where the audio is actually playing. The DSP sees the original endpoint and stays happy.
Multiple apps playing at once
The engine mixes all active streams to its native format before the loopback tap reads them. For IR capture, make sure only your sweep player is active — close Discord, Slack, browser tabs playing notification sounds, anything that could land in the loopback during your capture window.
Sample-rate mismatches in your sweep generator
The Python snippet in Step 2 hard-codes the sample rate to match what you set in Sound Settings. If you generate the sweep at, say, 48 kHz and your device is at 96 kHz, the player will resample your sweep on the way to the engine, and your "source" sweep no longer matches what was played. Generate the sweep at the device's rate.
Compressors / limiters in the DSP chain
Convolution can only characterise linear time-invariant systems. If the DSP you're capturing includes dynamic processing (compressors, limiters, loudness restorers), the IR is an approximation — it captures the linear part of the response correctly but the time-varying part will leave audible residual. Use a low-amplitude sweep (the −6 dBFS default in Step 2) so the compressor stays off its threshold, or accept that the IR is "DTS in its steady-state EQ mode" rather than "DTS exactly."
Use cases this is good for
- Porting an OEM DSP across operating systems. Boot to Windows, capture DTS:X Ultra / Nahimic / Atmos as an IR, replay on Linux / macOS / mobile via convolver. The Reddit GPD Win 5 thread that prompted this guide is exactly this use case.
- Bringing a system-wide EQ into a DAW project. Capture your macOS Loudness Equalizer / Windows EQ APO config as an IR, drop it on a DAW master bus to A/B mixes "as my listening chain hears them."
- Reverse-engineering a reference processing chain. Capture a finished mix's processing footprint at a sub-mix bus and replicate it on a new project.
- Validating a custom plugin against a reference. Capture the reference plugin's IR, capture your plugin's IR, null-test the two IRs to find where your implementation diverges.
- Documenting a hardware device's frequency response. Capture the device's output through a calibrated microphone (different workflow but same deconvolution math) to get its room/speaker IR.
FAQ
Does this work on macOS?
In principle yes — the deconvolution math is the same on any OS. In practice macOS adds a wrinkle: Apple's Core Audio process-tap API performs some ingestion-side reconstruction filtering that no third-party tool can opt out of. That filter ends up in your captured sweep and therefore in your deconvolved IR. For broadband signals (music, speech), the practical effect is small. For an IR — which by definition contains content right up to Nyquist — the filter is more visible. Windows is the recommended OS for IR capture work. See the macOS bit-perfect guide for the full honest writeup of the Apple-side caveat.
What about MLS / Golay sequences instead of sine sweeps?
Both work, both produce valid IRs. Log sine sweeps are easier to handle in software (clean Python deconvolution), less sensitive to background noise, and separate harmonic distortion from the IR more cleanly than MLS does. Unless you have a specific reason to use MLS (legacy tooling, etc.), sweeps are the modern default.
How long should the sweep be?
Longer is better up to a point: more energy per frequency bin = lower noise floor in the IR. 10 seconds is the practical sweet spot for system DSP IRs. Below 5 seconds you start losing low-frequency resolution; above 20 seconds you're hitting diminishing returns and risking that something else on the system makes noise during the capture window.
The captured sweep clips at high frequencies. Is my IR ruined?
Probably yes. Some DSPs (loudness restorers, certain limiters) push the signal closer to 0 dBFS, and a −6 dBFS source sweep can overshoot to clipping after the DSP. Drop the source amplitude to −12 dBFS or even −18 dBFS, regenerate the sweep, recapture. The IR is invariant to source amplitude — only the deconvolution noise floor changes — so going quieter is safe.
Can I capture a stereo IR (different L vs R)?
Yes — process L and R independently with the same deconvolution script, save as a stereo WAV with each channel as its own IR. Some convolvers want this as two separate mono IRs; check your convolver's documentation.
How do I know my IR is right?
Best validation: capture a second sweep through the convolver applying your IR (so original sweep → your convolver → capture). The output should approximate what the original DSP produced when given the same sweep. If you A/B the DSP's captured sweep vs the convolver's output sweep, they should match closely (allow for the convolver's own latency, regularisation choices, and the linear-time-invariant approximation discussed above).
Will AudioRoute add an IR convolver natively?
No plans to today — AudioRoute is purpose-built for clean capture, and there are already excellent convolvers (free and paid) in every relevant platform. We're better off doing one thing very well than absorbing adjacent tooling. Pair us with your convolver of choice.
Related guides
- Bit-perfect system audio capture on Windows — the underlying capture-path verification this guide is built on. Includes the full null-test methodology + results.
- Bit-perfect system audio capture on Mac — the macOS sibling, including the honest discussion of why Mac isn't the ideal OS for IR-capture work.
- AudioRoute vs VoiceMeeter — why the process-loopback architecture matters for system-DSP work.
- How AudioRoute works under the hood — daemon, tap, ring buffer, and rate-resolution path.
Stuck somewhere in the IR-capture workflow?
The deconvolution result looks weird, the sweep clips, the IR replay doesn't sound like the original DSP — we like debugging this stuff. Send us your sweep + capture + IR and we'll take a look.
Email support Back to guides