Spaces:
Running
Running
| // How loud a recording is, measured the way broadcast measures it. | |
| // | |
| // THE VOICES CAME IN 14 DB APART. The smith at -34.8 LUFS, the baker at -20.7: | |
| // played as recorded, one letter is five times louder than the next and the | |
| // quiet ones vanish under the torch. So every voice is brought to one level | |
| // when it loads, from its own samples, and a file dropped in later is levelled | |
| // the same way without anybody writing a number down. | |
| // | |
| // NOT A PLAIN AVERAGE. Gated RMS agreed with a real loudness meter to within a | |
| // decibel for ten of the eleven voices and missed the well house keeper by | |
| // three: that voice is breathy and bright, and the ear hears high frequencies | |
| // louder than an average counts them. ITU-R BS.1770 exists for exactly that -- | |
| // a K-weighting filter shaped like the ear, then a gate that ignores the | |
| // silences -- so this is BS.1770-4 integrated loudness, checked against | |
| // ffmpeg's ebur128 on every voice in the game. | |
| /** Biquad coefficients for the two K-weighting stages, at any sample rate. */ | |
| function kWeighting(fs) { | |
| // Stage 1: the head as an acoustic shelf, +4 dB above ~1.7 kHz. | |
| let K = Math.tan(Math.PI * 1681.974450955533 / fs); | |
| const Q1 = 0.7071752369554196; | |
| const Vh = 10 ** (3.999843853973347 / 20); | |
| const Vb = Vh ** 0.4996667741545416; | |
| let a0 = 1 + K / Q1 + K * K; | |
| const shelf = { | |
| b: [(Vh + Vb * K / Q1 + K * K) / a0, 2 * (K * K - Vh) / a0, (Vh - Vb * K / Q1 + K * K) / a0], | |
| a: [2 * (K * K - 1) / a0, (1 - K / Q1 + K * K) / a0], | |
| }; | |
| // Stage 2: the RLB high-pass, which stops rumble counting as loudness. | |
| K = Math.tan(Math.PI * 38.13547087602444 / fs); | |
| const Q2 = 0.5003270373238773; | |
| a0 = 1 + K / Q2 + K * K; | |
| const highpass = { | |
| b: [1, -2, 1], | |
| a: [2 * (K * K - 1) / a0, (1 - K / Q2 + K * K) / a0], | |
| }; | |
| return [shelf, highpass]; | |
| } | |
| function filter(x, { b, a }) { | |
| const y = new Float32Array(x.length); | |
| let x1 = 0, x2 = 0, y1 = 0, y2 = 0; | |
| for (let i = 0; i < x.length; i++) { | |
| const v = b[0] * x[i] + b[1] * x1 + b[2] * x2 - a[0] * y1 - a[1] * y2; | |
| x2 = x1; x1 = x[i]; y2 = y1; y1 = v; | |
| y[i] = v; | |
| } | |
| return y; | |
| } | |
| /** | |
| * Integrated loudness in LUFS of one mono channel, BS.1770-4: K-weight, | |
| * 400ms blocks overlapping by 75%, an absolute gate at -70 LUFS and a relative | |
| * gate 10 LU under the result. -Infinity for silence. | |
| */ | |
| export function loudness(samples, sampleRate) { | |
| const [shelf, highpass] = kWeighting(sampleRate); | |
| const y = filter(filter(samples, shelf), highpass); | |
| const block = Math.round(0.4 * sampleRate); | |
| const hop = Math.round(0.1 * sampleRate); | |
| const powers = []; | |
| for (let i = 0; i + block <= y.length; i += hop) { | |
| let e = 0; | |
| for (let j = i; j < i + block; j++) e += y[j] * y[j]; | |
| powers.push(e / block); | |
| } | |
| const lufs = (p) => -0.691 + 10 * Math.log10(p); | |
| const mean = (list) => list.reduce((s, p) => s + p, 0) / list.length; | |
| const loud = powers.filter((p) => lufs(p) > -70); | |
| if (!loud.length) return -Infinity; | |
| const gate = lufs(mean(loud)) - 10; | |
| const kept = loud.filter((p) => lufs(p) > gate); | |
| return lufs(mean(kept)); | |
| } | |
| /** The largest absolute sample, for keeping a level change clear of clipping. */ | |
| export function peak(samples) { | |
| let m = 0; | |
| for (let i = 0; i < samples.length; i++) { | |
| const v = Math.abs(samples[i]); | |
| if (v > m) m = v; | |
| } | |
| return m; | |
| } | |