Calibration

Every audio interface adds its own fingerprint to a measurement: a delay, a slight tone shape, a little distortion of its own. Calibration measures all of that once — with a plain cable in place of the pedal — so PedalScope can subtract the interface from every pedal measurement that follows. It’s how the app can honestly claim a chart shows the pedal, not the pedal plus your converter.

Gain staging, in order

The first calibration you run is also the first time PedalScope records audio, so macOS asks for microphone access then — hardware capture needs it, and nothing else does (see Permissions).

Calibration measures the loop including your knob positions, so the knobs get set first and the calibration comes second. Four steps, in this order:

1. The same path, single-ended at the pedal. The loopback you calibrate with must be the electrical path the pedal will drive — the interface’s first output pair (the one PedalScope drives), the same input, the same cables and adapters — and single-ended, tip and sleeve only, where it meets the pedal, because that is what a pedal jack is. Plain TS (“mono” guitar) cables on a ¼″ output do this by themselves; an XLR-only output needs an XLR-to-¼″ cable or an adapter, and Setting up your rig says where either can sit, and why the level then lands about 6 dB under the manual’s figure on any balanced output. A TRS cable straight from output to input in the loopback is a different path: into a balanced input it typically arrives about 6 dB hotter than the TS path, and the loop response — including phase — it calibrates isn’t the one your measurements go through, silently corrupting the compensation baked into everything that follows. (A TRS plug that ends in a two-contact jack — the Breakout Box’s input, or a pedal’s — is single-ended by that jack and is fine.)

2. Set the input gain for the pedal, not the loop. With the pedal in the loop at the loudest drive you plan to use, set the interface input gain so peaks land in the −12…−6 dBFS window — loud enough to use the converter’s resolution, with headroom to spare.

3. Calibrate at that same gain. Take the pedal out, patch the TS cable straight from output to input, and run Calibrate. If the direct loop clips or runs hot, lower the calibration sweep level (Settings → Calibration) — not the input gain you just staged for the pedal.

4. Then leave the knobs alone. The calibration is only a picture of the loop as it was; any knob change between calibration and measurement silently invalidates it. If a knob moves, recalibrate — it’s two minutes.

The sweep level

The calibration sweep’s digital level is a preference (Settings → Calibration; default −26 dBFS — the standard measurement drive level; range −40…−6 dBFS). The loopback chain is linear, so calibration is equally valid anywhere in that range: the level changes the loop’s signal-to-noise ratio and how much of the input converter’s dynamic range it uses — distance above the noise floor, headroom below clipping — not its measured response. Trim it so the direct loop peaks in the −12…−6 dBFS window at the input gain you staged for the pedal. A fixed, louder sweep would clip direct loops at input gains that are perfectly healthy for pedal measurements, which is why the level is yours to set. Every calibration records the level it ran at and the loop gain it measured. Very low levels trade away signal-to-noise; runs under 20 dB SNR are rejected outright.

Before you calibrate: a quiet machine and a known interface

Three things outside the cable can change what a calibration measures without changing how it looks. Check them before you press Calibrate.

No system-wide audio utility running. A background application that installs its own audio driver — a system-wide volume, routing or capture utility — can put a stage of its own into the loop. On the bench this app was developed on, one such utility added about 28 ms of round trip (2,739 samples at 96 kHz) to a loopback whose flatness, distortion floor and loop gain read exactly as they did without it: only the latency moved, so nothing else in the calibration would have said so. Quitting the application is not always enough, because its driver can stay loaded — log out and back in, and remove it from your login items so it is not running at the next start-up. “Always leave it on” is not a way round this either: whether such a utility was running is recorded nowhere in a calibration, so consistency would be an assumption nobody can check afterwards. (Whether any other program using the interface costs the same has not been measured; this is about the kind that installs a driver.) The site’s FAQ names the utility that was measured: audio utilities.

A known interface first. Keep one interface whose calibration figures you have written down — latency, loop flatness, distortion floor, loop gain — and calibrate it first at the start of a session. The same interface on the same machine should read the same latency within a sample, and the same flatness and floor, as last time; if it does not, something on the machine changed, and you found it in two minutes instead of in a set of measurements. The bench this app was developed on uses a small two-input interface for this control: it read 1250 samples of latency, flatness +0.07 / −0.70 dB and a floor of 0.011 % on two dates a week apart.

The interface’s own mixer is part of the rig. Many interfaces carry a software mixer — a monitor blend, or a full routing matrix with a fader for every input on every output bus. For a loopback calibration the only thing feeding the interface output should be PedalScope’s playback: every hardware-input send to every output bus at −∞, and no EQ, low cut or other processing on any strip in the path. On a routing matrix, check every bus, not only the one on screen — a fader there belongs to a source and a bus, so a strip can read −∞ on the bus you are looking at and still feed another one. Setting up your rig covers the same routing from the listening side.

A mixer send from the loop’s return input back to its own output closes a feedback loop through the cable, and it has a signature. Measured on a matrix interface with exactly that send left up: loop flatness +23.5 / −3.2 dB — a narrow resonant peak where the loop’s phase lines up — against +0.10 / −0.63 dB once the send was zeroed, and a distortion floor that climbed over three consecutive runs of an unchanged rig, 0.056 %, then 0.155 %, then 0.349 %, against 0.015 % clean. A floor that grows run over run is not the interface warming up; look at the mixer.

Save the mixer’s state as a named preset in the interface’s own software (one that captures the whole mixer, not a single snapshot slot), load it as step zero of every calibration, and add a screenshot of it to the calibration’s Rig photos (below) — the routing is as much part of the rig as the cable.

Running it

1. Patch a short TS cable from either channel of the interface’s first output pair — the pair PedalScope drives; there is no output to choose — to the input you’ll use, through whatever adapter the output needs (Setting up your rig). No pedal in the loop.

2. In the measure flow, pick your device, input, and sample rate on the Setup step, then run Calibrate. It plays a sweep through the cable and takes about ten seconds. The sweep level in use is shown next to the button.

3. Re-patch the pedal into the loop and carry on measuring. The calibration is saved and reused until you change something.

If the run is refused before any sound with a sentence about the audio engine’s output stream or input stream being disabled, or about the stimulus never being rendered, PedalScope has declined to play into an audio engine the operating system brought up with a stream switched off (first seen on macOS 27.0, where the engine’s output element came up off after the interface was selected and a sweep would otherwise have played into nothing and blamed your cables). Run it again; if it recurs, re-select the interface on the Setup step. It is not a cable or a knob, and nothing about your rig needs to change.

Three optional companions live next to the Run button, all about making rig state recorded instead of remembered:

• Rig controls. Click Define… to describe the interface’s own panel once — gain knob, INST/PAD/AIR switches — exactly as you define a pedal’s controls (there’s an interface template). Every calibration then records the positions you set, so “did the gain knob move since last week?” is answerable from stored data instead of memory. The knob’s effect is measured anyway (the chain gain); the recorded positions are the human-readable half.

• The volts reference — optional. PedalScope is fully usable without multimeter voltage measurements: every level is quoted in dBFS, and everything relative — harmonic ratios, THD, the knee, comparing your own records on your own rig — needs no volts. The volts factor is an optional provenance upgrade, not a setup step; Who needs a multimeter, and what it buys, below, says what it adds and what instrument it takes. If you measure it, the Play test tone button next to the field emits the meter-readable stimulus for exactly this (the procedure is under Verifying your level factor with a meter); enter the result in the 0 dBFS = … V peak field (also in Settings → Calibration), or let Compute from a reading… do the units arithmetic for you. Each calibration stamps the value it ran with; write how you measured it in that calibration’s Calibration rig notes (on the Calibrate step and in Manage…). Leave it empty when unmeasured — charts then stay honestly in dBFS — and to return it to empty, delete the value and leave the field blank. The factor describes one interface: single-ending a balanced output costs about 6 dB against the manual’s figure on every rig, and where each rig actually lands is what the factor records — so when you pick a different device, PedalScope empties the field and says so beside it. Measure again on the new interface, or leave it empty. (The source impedance is not cleared: it describes the fixture, which moves between rigs with you.)

• The source impedance. The Source impedance field states what sits in series between the interface output and the pedal’s input jack: 0 for the line output driving the pedal directly (the interface’s own output impedance is not counted), 10000 for the 10 kΩ series fixture. It pre-fills with 0 — the bare rig — and each calibration stamps the value it ran with, beside the volts factor, so every record made with that calibration shows it in its header (“source impedance 0 Ω”) and Compare flags records made at different values. Change it before running the calibration; a fixture inline at the output changes what the volts factor describes at the pedal, so switching jacks is a recalibration either way. (The 10 kΩ fixture is also declared on the pedal’s own SOURCE control for the PSC-1 condition string — see Bench fixtures; the two say the same thing from the rig’s side and the pedal’s.)

• Calibration rig notes. The calibration’s own notes field — cable routing, how the volts factor was measured, anything the numbers can’t say — right here on the step. Typed before the calibration runs, the text waits and is saved onto the calibration when it is; once this sheet has saved one, the field edits that calibration directly. It is the same field Manage… shows in each row, and it is not a measurement’s Capture notes.

• Rig photos. Photograph the knob positions and the cable routing right here, while you’re standing at the rig — drop, browse, paste, or shoot with an iPhone via right-click, several at once. The heading says which calibration the photos and notes belong to: for the next calibration you run until one is saved from this sheet, then for the calibration saved at its time. When you start another calibration, the section goes back to the next-calibration state, so a photo added while a sweep runs attaches to the calibration about to be saved — never to the previous one, whose photos stay with it (edit them in Manage…). If Take Photo fails, the menu beside it carries the remedy (connect the iPhone by USB, or check Wi-Fi on both devices) and Browse / Paste always work.

Who needs a multimeter, and what it buys

Nobody needs one to use the app. Without a volts factor every level stays in dBFS — the interface’s own digital scale — and every relative quantity PedalScope measures is complete: the harmonic recipe, THD, the compression knee and cleanup level, the Chord IMD products, the waveform matrix, and any comparison between your own records on your own rig. Nothing is missing and nothing breaks. If you have no meter, skip this section and the next; the volts field stays empty and honest.

A measured factor buys three things. It qualifies a record for the PSC-1 standard condition — the stated drive level in volts that makes your measurement comparable with one made on someone else’s rig (see Comparing measurements). It lets the input axes speak volts: the Transfer Curve’s input axis and the knee and cleanup readouts in volts at the pedal input rather than in a dBFS that means a different voltage on every interface. And it makes levels comparable across rigs: two calibrated rigs quote knee gaps and drive levels in the same physical unit, where two uncalibrated ones can only be compared with themselves.

The requirement is a specification, not a brand. The test tone at the −26 dBFS sweep level is about 119 mV RMS at the interface output on the reference rig (0 dBFS = 3.35 V peak there; your rig’s figure is the same order). Reading that takes an AC-volts range of a few volts or less with millivolt resolution, specified to at least a few hundred hertz. A mains-regime meter — the very cheapest tier, with AC ranges of 200 V and 750 V only — reads 119 mV as 0.0 or 0.1 and cannot do this measurement at all; nothing about its accuracy helps, because it never resolves the digit. For example, a meter whose AC volts range reaches 4 V at 1 mV resolution and is specified over 50–400 Hz covers this measurement. The site’s FAQ names meters whose published figures meet the requirement: which multimeter. That is a check against datasheets, not a test result: the recommendation stands on the published specifications and says so.

The level lever is the most useful thing on this page. The app divides the tone level out, so any known level gives the same factor — but a meter’s fixed “plus N digits” term is the same size whatever you read, so it dominates at small readings, and a louder tone is strictly more precise. On a meter specified at ±(1.0 % + 3 digits) on a 4.000 V range (one digit = 1 mV), with the reference rig’s factor:

PSC-1’s whole drive tolerance is ±0.5 dB. Metering at the sweep level spends about 60 % of that budget on the meter alone; metering at −12 dBFS spends about 26 %. Read the factor at the −12 dBFS preset. Both presets deliver the same factor; the louder one resolves more of its digits.

Verifying your level factor with a meter

Every measurement stimulus is a sweep or a level ladder — statistics on a scope, invisible to a multimeter. The Play test tone button (next to the volts field, and only when a hardware device is selected) plays a steady sine out the selected interface at a known digital level, looping click-free until you press Stop. That turns the volts factor into a thirty-second reading instead of an exercise in max-hold statistics — and peak-detect max-hold on a sweep also rides up on noise coincidence, so the steady tone isn’t just easier, it’s more accurate.

Two level presets match the levels that matter: the calibration sweep level (whatever Settings → Calibration says, −26 dBFS by default) and −12 dBFS, the loudest moment of a fingerprint run — the one to use for a meter read, for the reason given above, and the one the picker opens on; a custom field takes any other level. The frequency presets are 220 Hz and 1 kHz. 220 Hz is the right default for a meter because mid-tier meters specify their AC-volts accuracy over roughly 50–400 Hz, and 220 Hz sits inside that window where 1 kHz sits outside it (220 Hz is also the compression probe’s frequency); 1 kHz is the classic scope reference. Frequency range is not what limits a meter on this measurement — resolution is, as the previous section says.

The loop gain, live, while the tone plays. Under the tone’s controls the app reads the selected input continuously and shows the loop gain at the tone’s frequency — the level it reads against the level it plays, in dB — with the input’s peak beside it, about twelve times a second, so the interface’s input-gain control can be set by turning it while the number moves instead of by calibrate-read-adjust cycles. Three lines put the number in context, and every figure in them is derived, never a typed target: the selected calibration’s own loop gain on this interface (its band figure, and its gain at the tone’s frequency, which is what the readout should equal if nothing has moved), with how far the reading stands from it — the aim, when one exists; where no calibration was made on the selected interface, the line says there is no earlier one to aim at, and the first calibration you run records where the input gain is now. Then the clipping ceiling: at the app’s loudest standard drive (−12 dBFS) a bare loop clips the interface input once the loop gain passes +12 dB — arithmetic on that drive ceiling, and a bare-loop figure only; with a pedal in the loop the pedal’s output decides the real limit. And the sanity window the calibration will be judged against at the current sweep level (−6…+26 dB at −26 dBFS — the window the cable check below applies, quoted, not a target).

When an aim exists, the digits also shade with their distance from it: green at the aim, a cooler blue the further the reading falls under it, a warmer amber the further it rises over — a visual aid that says which way to turn and roughly how far, fading smoothly over a few dB with no edge anywhere, because no band is a pass criterion. With no earlier calibration to aim at, the digits keep their normal color. The clipping warning is a separate line and is never what the digits’ color means. The lines under the number are selectable, so a figure can be copied into your notes.

The number is a loop gain only with nothing but a cable between the output and the selected input; with a pedal in the loop it is the pedal’s gain at that note plus the loop’s, and the line under the readout says so. An input at or past full scale shows a clipping warning first. If the Microphone permission is off, the tone still plays and the readout says the input cannot be read; if the input is silent, it says so with the peak it saw, the same “No signal captured” a calibration would stop with. Nothing about the readout is stored: the calibration you run afterwards is the measurement, and the reading is how you set up for it.

The custom field is the one place in PedalScope you can ask for a steady sine at digital full scale, sounding until you stop it — which is why the output level guard asks before it plays anything at or above −10 dBFS, quoting the level in volts once your factor is entered. Neither preset crosses that line.

To verify a factor you’ve already entered:

1. Clip the meter to the interface output (tip–sleeve of the cable that normally feeds the pedal). Getting two clips onto tip and sleeve without unplugging anything takes a small fixture — the Breakout Box’s TIP and SLEEVE posts, or a bare plug or a cable with its cover unscrewed; see Bench fixtures.

2. Play the tone at a chosen level. While it plays, the app shows the peak, peak-to-peak, and RMS volts it expects from your entered factor.

3. Read the meter — on a scope use averaging acquisition and cursors (or the RMS/amplitude measurement); on a DMM read AC volts, which is RMS, at 220 Hz — and compare against the displayed expectation. Agreement within a few percent means the factor (and your whole output level chain) still stands.

To obtain the factor in the first place, same setup — and the Compute from a reading… button next to the volts field does the arithmetic for you: it already knows the tone level — the play picker’s own setting, and while the tone is sounding, the level that is sounding — so say what the instrument reported, type the number, and the app shows its work and fills the field. What it computes is one translation table:

A meter’s AC-volts reading is an RMS statistic, and average-responding meters are sine-calibrated, so a True-RMS meter is not required (fine if you have one) — what is required is the range and resolution stated in Who needs a multimeter: a few volts full scale, millivolt digits, specified to a few hundred hertz. On a scope, use averaging acquisition and cursors (or the amplitude/RMS measurement), as above. Example: −12 dBFS tone at 220 Hz, scope reads 1.68 V peak-to-peak → halve for 0.84 V peak → 0.84 ÷ 0.251 ≈ 3.35 V peak at 0 dBFS.

The tone is a utility, not a measurement: nothing is recorded, and it never plays while a calibration or measurement is running. If the reading disagrees with the expectation, an output knob has moved since the factor was measured — re-measure the factor, then recalibrate (the chain gain will have moved too).

A measured volts factor is also the ticket to the PSC-1 standard condition — the stated drive level that makes your measurements comparable with someone else’s rig. See Comparing measurements.

Recalibrate when anything in the chain changes: interface gain settings (input gain, output/monitor level — on the panel or in the interface’s control software), the instrument/line switch, sample rate, which jacks you use (a series-resistor jack included — update the source impedance field first), cables, or the interface itself. The app stores calibrations per device and sample rate and warns on a mismatch, but it can’t read your interface’s gain settings — keeping them where they were calibrated is on you.

Plugins never calibrate

A hardware calibration is a measurement of your rig — cables, knobs, converters, that day — which is why it has to be a step you perform. A plugin run has no rig: the loop is the offline render path itself, a constant with no cables, no gain staging, and nothing user-dependent in it. So PedalScope never asks — when a plugin run needs a calibration at the session’s sample rate and none exists, it measures the render path itself and proceeds, noting it in one progress line. The resulting “Plugin render path” baseline lands in the calibration manager like any other: same stored snapshot, same provenance chain under every record, archived rather than deleted once referenced. Only the ceremony is gone. One reading note: its flatness stamp legitimately shows about −0.6…+0.1 dB — that residue is the sweep analysis’s own fade edges, not the loop (a perfect pass-through reads exactly the same), so it never wears a badge.

The cable check (“is there a pedal in the loop?”)

The easiest calibration mistake to make is also the worst one: running the loopback sweep with the pedal still patched in. The result looks like a calibration — it has a latency, a response, a gain — but it’s a picture of the pedal, and every measurement compensated by it silently divides the pedal’s own tone and gain out of the results.

So before a completed calibration is saved, PedalScope compares it against what a plain cable produces:

• Distortion. A cable loop measures around 0.01 % THD (the interface’s own floor). A distortion floor over 1 % means something in the loop is clipping — that’s a pedal, not a cable.

• Flatness. A cable is flat; over the assessed band — the audible 20 Hz–20 kHz, clear of the sweep’s fade edges, and the stamp says so — the loop should stay within a couple of dB of its 1 kHz gain. Swings beyond ±4 dB look like a tone stack. (Ultrasonic converter rolloff above the audible band is honest interface behavior and stays out of the statistic, and so is the sweep’s own fade-in ramp: the assessed band starts where the response actually reaches full level — typically a couple of hertz above the sweep’s 20 Hz start — not at the nominal edge, so the ramp can never masquerade as a low-frequency cut.)

• Loop gain. The input-gain knob is part of the measured loop, so a correctly staged rig doesn’t read unity — it reads roughly the staging target minus the sweep level (about +14…+20 dB at the default −26 dBFS sweep level). The app derives the acceptable window from your calibration’s own sweep level and widens it generously (−6…+26 dB at the default); gain outside it with the loop otherwise clean gets milder wording: a pad or attenuator below the window, an unexpected gain stage above it — either may well be deliberate.

When a check fires, the app asks plainly — “Is the pedal still connected in the loop?” — with Recalibrate as the primary action and an explicit Save Anyway override. It’s a warning, never a gate: if the odd loop is intentional (a fixed pad, a known-weird path), save it and carry on. The same verdict is computed retroactively in the calibration manager, so a suspect calibration that was already saved wears a badge there (“pedal in loop?” or “gain shifted”) instead of hiding among the clean ones.

The badge also follows the calibration to where it matters most: any measurement resting on a suspect calibration wears the same badge in its own header, next to the “calibrated, latency …” chip. Its tooltip names the evidence and which readings are most affected — a suspect loop response is divided out of every chart, so voicing and absolute-level claims inherit its faults first, while ratios read at a single drive are the most robust. It’s a badge on the calibration, never a verdict on the measurement: the device may still have been measured perfectly well at the frequencies the loop was honest about. Clicking the calibration chip on any measurement opens the stored calibration’s full detail — its stamps, the verdict, and the measured curves behind them (the loop response the flatness numbers summarize, the interface distortion floor behind the THD figure), read from the snapshot copy the measurement itself carries.

Managing stored calibrations

Calibrations accumulate — one per rig change, forever. Manage… next to the calibration list in the measure flow (or Manage Stored Calibrations… in Settings → Calibration) lists every one with its date, device, sample rate, measured loop gain, sweep level, and how many stored measurements reference it. Calibrations that fail the cable check wear a badge here — “pedal in loop?” or “gain shifted” — computed fresh from the stored numbers.

The rule the manager enforces: a calibration no measurement references can be deleted; one that measurements reference can only be archived — hidden from the pickers, kept as provenance. Nothing cascades: every measurement carries its own copy of the calibration it ran with, so neither deleting nor archiving can ever change a stored result.

The reference count is made in one pass over the library, in the background: each row’s own numbers appear at once and the rows stay usable — expand one, edit its notes, add a photo — while “counting references…” resolves, a second or two on a large library. If the count cannot be made, the row says so in words with the reason, offers Archive (which destroys nothing) and withholds Delete until a count succeeds: a count that failed is never read as “no references”.

There is no separate “active” calibration to protect. The first measure sheet of a launch defaults to the newest unarchived calibration at the run’s sample rate, so archiving the newest one promotes the next — or, if none remain, the measure flow asks for a fresh calibration, which is the honest state after a rig change anyway.

The reference count is navigable: click “referenced by N measurements” to list the records resting on that calibration — each one names its pedal, title, and date, and clicking it opens the measurement itself. That closes the loop in both directions: from a measurement, the calibration chip opens the stored calibration; from a calibration, the reference line reaches every measurement that depends on it — exactly what a “which results did that bad loop touch?” morning needs.

The list comes from the same background pass as the count, so opening it never reads the library a second time. If the list cannot be read, it says so with the reason — never an empty list standing in for “none” — and a measurement deleted since the count was made is counted as gone rather than silently left out. An Archive, Unarchive or Delete that the library refuses is stated beside the row’s button, with the reason; nothing happens silently.

Each row also expands (the chevron) to a Calibration rig notes field and its rig photos. The notes are where the volts reference’s how-I-measured-it story and any cable-routing description belong (they are the calibration’s own field, not a record’s capture notes); the photo wells take multiple shots — one of the interface’s knob positions, another of the cable routing — because routing state is exactly what a later “was that loop clean?” question needs, and it is the one thing the measured numbers cannot show. The add well takes several images in one pass — the file picker multi-selects, and a screenshot on the clipboard pastes straight in (right-click ▸ Paste Photo, or ⌘V with the well focused); a filled well’s right-click menu also copies the full-resolution shot back out and rotates a sideways one — the standard photo-well menu. The recorded rig-control positions appear in the row’s detail line.

The expansion also shows the charts behind the row’s numbers: the measured loop response the flatness figures summarize (with the ±4 dB suspicion lines and the assessed band marked, and the fade-edge points the verdict excludes drawn faded) and the interface distortion floor behind the THD figure (with the 100 Hz–5 kHz midband the quoted scalar reads and the 1 % cable-check threshold). The curves behind the numbers are one chevron away — and the same charts open from any measurement’s calibration chip.

The session’s calibration is pinned

Within one launch of the app, the calibration a measure sheet uses — the one a run starts with, or the one you click in the list — becomes the session’s calibration: every later measure sheet in that launch starts on it, and the Calibrate step says so (“Session calibration: … (pinned)”). A calibration you run later in the same session — a probe, a check, a re-test of the loop — is listed as a choice and never quietly replaces it: the step says how many newer calibrations exist, and one click on a row changes the pin. This is what a publishable set needs: one snapshot embedded in every record, without re-selecting it on every reopened sheet.

The pin is a fact about this launch only. Nothing is stored, so quitting and relaunching starts fresh (the newest calibration is the default again). It is keyed to the run’s sample rate — a 48 kHz sheet does not inherit a 96 kHz pin — and to the interface: changing the selected device clears it, with a line saying so, the same way the volts factor is cleared. If the pinned calibration is archived or deleted in Manage…, the step says it was un-pinned and selects the newest one instead.

What the numbers mean

A calibration reports a few figures of merit; here’s how to read them:

• Round-trip latency — how long a signal takes to leave the app and come back, in samples and milliseconds. The value itself doesn’t matter (a few ms is normal); its stability does. The same rig should report the same latency within a sample on every run — if it jumps around, something (usually the interface’s buffer settings) is unstable. A background audio utility that installs its own audio driver (a system-wide routing or capture tool) can add tens of milliseconds to the loop while every other figure here reads normally; see Before you calibrate, above, for how to take it out of the loop, and if one was running when you calibrated, calibrate again without it. Measurements that cut their captures at this figure check it at capture time: Harmonic Distortion locates its own sweep; the Gain Map reads every level’s sweep against it; the Transfer Curve and the Waveform Matrix play a one-second probe sweep first, because a tone cannot be placed by correlation. When the loop’s response arrives more than 1.3 ms from where the calibration puts it, the run is refused in words — the calibration named, both latencies quoted — and nothing is saved; recalibrate with the loop as it is now.

• Loop response — how flat the cable loop measures after compensation. Expect essentially flat (within about ±0.1 dB) across the audio band. A big tilt or ripple means a bad cable or an accidental processing stage (direct-monitor mix, loopback DSP) in the path — a narrow resonant peak with a floor that climbs run over run is the mixer feeding the loop back to itself (Before you calibrate, above).

• Loop gain — the measured digital-out → digital-in gain of the loop, stamped alongside the sweep level it was measured at. PedalScope cannot read your interface’s gain settings — whether they live on hardware knobs or in the interface’s own control software — but the gain they produce is measured, and this pair is the calibration’s settings fingerprint. If a fresh calibration reports a different loop gain than the last one on the same rig, a gain setting moved.

• Interface distortion floor — the harmonics the interface itself adds, typically around 0.01 % THD on a decent interface. This is the measurement’s honesty line: PedalScope will not claim a pedal is cleaner than the interface measuring it. If a pedal reading approaches the floor, the chart is showing you the interface, not the pedal.

• Noise / SNR — hiss picked up from the loop, measured from the silent lead-in. Drives the level recommendations in the measure flow.

Level habits that keep calibrations honest

• Calibrate at the same input gain you measure at — that’s the whole point of the staging order above. The sweep level is free to differ from your measurement drive levels; the knobs are not.

• If the calibration reports clipping, lower the sweep level in Settings and run it again — leave the input gain where you staged it for the pedal. A clipped calibration is invalid, and the app will say so rather than store it.

The low-level warning

Clipping isn’t the only way to waste a converter. If a capture comes in far below the target window, PedalScope warns that you are spending converter resolution on silence — under-driven runs make the static transfer curve jittery near the zero crossing and put a worse noise floor under every derived number. The check projects each capture’s peak to the loudest planned drive using the level that run was actually played at, so deliberately quiet runs — a gain map’s soft steps — never false-alarm.

The warning is advice, not a gate: the run completes either way. It appears when a calibration comes in low, and again at measurement start — there it’s computed from the selected calibration’s measured loop gain, before any audio plays. The remedy is the staging order above: raise the interface input gain for the pedal case, then recalibrate at that gain. (A clipping loopback has the opposite remedy — lower the sweep level in Settings, and leave the input gain alone.)

Once calibrated, you’re two clicks from a real measurement — see your first measurement.