@audio/speech-lpc 1.0.0

package/lpc.d.ts

@@ -0,0 +1,26 @@
+type Buf = Float32Array | Float64Array | number[]
+interface BiquadCoef { b0: number; b1: number; b2: number; a1: number; a2: number }
+type SOS = BiquadCoef[]
+
+export interface LpcParams {
+  order?: number     // LPC order (default 12)
+  [key: string]: unknown
+}
+
+export interface LpcResult {
+  coefs: Float64Array    // LPC coefficients a[1..order] of A(z) = 1 + Σ a_k·z⁻ᵏ
+  gain: number            // prediction-error gain (per-sample std of the whitening filter output, pre-normalization)
+  residual: Float64Array  // whitened residual e[n] = A(z)x[n], normalized to unit power (divided by gain) — feed to lpcSynthesize as-is, or scale by a new gain to resynthesize
+}
+
+/** LPC analysis — autocorrelation + Levinson-Durbin. Throws if params.order is not set on a fresh params object (no default without one). */
+export function lpcAnalysis(data: Buf, params: LpcParams): LpcResult
+
+export interface LpcSynthParams {
+  coefs: Float64Array | number[]
+  gain?: number      // default 1
+  [key: string]: unknown
+}
+
+/** LPC synthesis — all-pole filter reconstruction. y[n] = gain·excitation[n] − Σ coefs[k]·y[n−1−k], the algebraic inverse of lpcAnalysis's residual. */
+export function lpcSynthesize(residual: Buf, params: LpcSynthParams): Buf

package/lpc.js

@@ -0,0 +1,88 @@
+/**
+ * Linear Predictive Coding analysis/synthesis.
+ * Autocorrelation method with Levinson-Durbin recursion.
+ *
+ * @module  audio-filter/speech/lpc
+ */
+
+/**
+ * LPC analysis via autocorrelation + Levinson-Durbin.
+ * @param {Float64Array} data - Input signal
+ * @param {object} params - { order (12) }
+ * @returns {{ coefs: Float64Array, gain: number, residual: Float64Array }}
+ */
+export function lpcAnalysis(data, params) {
+	let order = params.order || 12
+	let N = data.length
+
+	// Autocorrelation r[0..order], normalized per-sample (Rabiner & Schafer biased
+	// estimator) so E/gain are frame-length invariant, not sum-length dependent
+	let r = new Float64Array(order + 1)
+	for (let i = 0; i <= order; i++) {
+		for (let n = i; n < N; n++) r[i] += data[n] * data[n - i]
+		r[i] /= N
+	}
+
+	// Levinson-Durbin
+	let a = new Float64Array(order + 1)
+	let prev = new Float64Array(order + 1)
+	a[0] = 1
+	let E = r[0]
+
+	for (let i = 1; i <= order; i++) {
+		let sum = 0
+		for (let j = 1; j < i; j++) sum += a[j] * r[i - j]
+		let k = -(r[i] + sum) / E
+
+		// Copy current coefficients
+		prev.set(a)
+
+		for (let j = 1; j < i; j++) a[j] = prev[j] + k * prev[i - j]
+		a[i] = k
+
+		E *= (1 - k * k)
+	}
+
+	let gain = Math.sqrt(E) // per-sample prediction-error std (E is already per-sample)
+	let coefs = a.subarray(1) // a[1..order] of A(z) = 1 + Σ a_k z⁻ᵏ
+
+	// Whitening filter e[n] = A(z)x[n] = x[n] + Σ coefs[k]·x[n−1−k], normalized to unit power
+	let residual = new Float64Array(N)
+	for (let n = 0; n < N; n++) {
+		let sum = 0
+		for (let k = 1; k <= order; k++) if (n - k >= 0) sum += coefs[k - 1] * data[n - k]
+		residual[n] = (data[n] + sum) / gain
+	}
+
+	return { coefs: new Float64Array(coefs), gain, residual }
+}
+
+/**
+ * All-pole synthesis filter.
+ * @param {Float64Array} excitation - Excitation/residual signal, unit power (modified in-place)
+ * @param {object} params - { coefs, gain (1), _s (internal state) }
+ * @returns {Float64Array} Synthesized signal
+ */
+export function lpcSynthesize(excitation, params) {
+	let coefs = params.coefs
+	let gain = params.gain != null ? params.gain : 1
+	let order = coefs.length
+	let N = excitation.length
+
+	if (!params._s || params._s.length !== order) params._s = new Float64Array(order)
+	let s = params._s
+
+	// y[n] = gain·u[n] - Σ coefs[k]·y[n-1-k] — algebraic inverse of lpcAnalysis's
+	// e[n] = x[n] + Σ coefs[k]·x[n-1-k], u = e/gain
+	for (let n = 0; n < N; n++) {
+		let y = gain * excitation[n]
+		for (let k = 0; k < order; k++) y -= coefs[k] * s[k]
+		excitation[n] = y
+
+		// Shift state
+		for (let k = order - 1; k > 0; k--) s[k] = s[k - 1]
+		s[0] = y
+	}
+
+	return excitation
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@audio/speech-lpc",
+  "version": "1.0.0",
+  "description": "Linear Predictive Coding analysis/synthesis",
+  "type": "module",
+  "sideEffects": false,
+  "main": "lpc.js",
+  "exports": {
+    ".": "./lpc.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lpc.js",
+    "lpc.d.ts"
+  ],
+  "keywords": [
+    "audio",
+    "dsp",
+    "speech",
+    "lpc"
+  ],
+  "license": "MIT",
+  "author": "Dmitry Iv. <dfcreative@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/filter.git",
+    "directory": "packages/speech-lpc"
+  },
+  "homepage": "https://github.com/audiojs/filter/tree/main/packages/speech-lpc",
+  "bugs": {
+    "url": "https://github.com/audiojs/filter/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "lpc.d.ts"
+}