@jtarrio/signals 0.9.0

package/dist/dsp/filters.d.ts

@@ -0,0 +1,197 @@
+export interface Filter {
+    /** Returns a newly initialized clone of this filter. */
+    clone(): Filter;
+    /** Returns this filter's delay, in samples. */
+    getDelay(): number;
+    /** Applies the filter to the input samples, in place. */
+    inPlace(samples: Float32Array): void;
+}
+/** A class to apply a FIR filter to a sequence of samples. */
+export declare class FIRFilter implements Filter {
+    private coefs;
+    /** @param coefs The coefficients of the filter to apply. */
+    constructor(coefs: Float32Array);
+    private offset;
+    private center;
+    private curSamples;
+    setCoefficients(coefs: Float32Array): void;
+    clone(): FIRFilter;
+    getDelay(): number;
+    inPlace(samples: Float32Array): void;
+    delayInPlace(samples: Float32Array): void;
+    /**
+     * Loads a new block of samples to filter.
+     * @param samples The samples to load.
+     */
+    loadSamples(samples: Float32Array): void;
+    /**
+     * Returns a filtered sample.
+     * Be very careful when you modify this function. About 85% of the total execution
+     * time is spent here, so performance is critical.
+     * @param index The index of the sample to return, corresponding
+     *     to the same index in the latest sample block loaded via loadSamples().
+     */
+    get(index: number): number;
+    /**
+     * Returns a delayed sample.
+     * @param index The index of the relative sample to return.
+     */
+    getDelayed(index: number): number;
+}
+/** Automatic gain control for audio signals. */
+export declare class AGC implements Filter {
+    private sampleRate;
+    constructor(sampleRate: number, timeConstantSeconds: number, maxGain?: number);
+    private dcBlocker;
+    private alpha;
+    private counter;
+    private maxPower;
+    private maxGain;
+    clone(): AGC;
+    getDelay(): number;
+    inPlace(samples: Float32Array): void;
+}
+/** A filter that blocks DC signals. */
+export declare class DcBlocker implements Filter {
+    constructor(sampleRate: number);
+    private alpha;
+    private dc;
+    clone(): DcBlocker;
+    getDelay(): number;
+    inPlace(samples: Float32Array): void;
+}
+/**
+ * Returns the decay value to use in a single-pole low-pass or high-pass IIR filter
+ * with the given time constant.
+ * @param sampleRate The signal's sample rate.
+ * @param timeConstant The time constant in seconds
+ */
+export declare function decay(sampleRate: number, timeConstant: number): number;
+export declare function frequencyToTimeConstant(freq: number): number;
+export interface IIRFilter extends Filter {
+    /** Returns a newly initialized clone of this filter. */
+    clone(): IIRFilter;
+    /** Filters an individual sample. */
+    add(sample: number): number;
+    /** Returns the value currently held by the filter. */
+    get value(): number;
+    /** Returns the phase shift at the given frequency. */
+    phaseShift(freq: number): number;
+}
+/** IIR filter with two 'b' coefficients and one 'a' coefficient. */
+declare class IIRFilter21 implements IIRFilter {
+    private sampleRate;
+    private b0;
+    private b1;
+    private a1;
+    constructor(sampleRate: number, b0: number, b1: number, a1: number);
+    private prev;
+    private val;
+    /** Returns a copy of this filter. */
+    clone(): IIRFilter;
+    getDelay(): number;
+    /**
+     * Filters the given samples in place.
+     * @param samples The samples to filter.
+     */
+    inPlace(samples: Float32Array): void;
+    /** Filters an individual sample. */
+    add(sample: number): number;
+    /** Returns the value currently held by the filter. */
+    get value(): number;
+    /** Returns the phase shift at the given angular frequency. */
+    phaseShift(freq: number): number;
+}
+/** A FM de-emphasis filter. */
+export declare class Deemphasis extends IIRFilter21 {
+    /**
+     * @param sampleRate The signal's sample rate.
+     * @param timeConstant The filter's time constant, in seconds.
+     */
+    constructor(sampleRate: number, timeConstant: number);
+}
+/** A FM pre-emphasis filter. */
+export declare class Preemphasis extends IIRFilter21 {
+    /**
+     * @param sampleRate The signal's sample rate.
+     * @param timeConstant The filter's time constant, in seconds.
+     */
+    constructor(sampleRate: number, timeConstant: number);
+}
+/** A single-pole IIR low-pass filter. */
+export declare class IIRLowPass extends Deemphasis {
+    /**
+     * @param sampleRate The signal's sample rate.
+     * @param freq The filter's corner frequency.
+     */
+    constructor(sampleRate: number, freq: number);
+}
+declare class IIRFilterChain implements IIRFilter {
+    private filters;
+    constructor(filters: IIRFilter[]);
+    /** Returns a copy of this filter. */
+    clone(): IIRFilter;
+    getDelay(): number;
+    /**
+     * Filters the given samples in place.
+     * @param samples The samples to filter.
+     */
+    inPlace(samples: Float32Array): void;
+    /** Filters an individual sample. */
+    add(sample: number): number;
+    /** Returns the value currently held by the filter. */
+    get value(): number;
+    /** Returns the phase shift at the given frequency. */
+    phaseShift(freq: number): number;
+}
+/** A chain of single-pole IIR low-pass filters. */
+export declare class IIRLowPassChain extends IIRFilterChain {
+    /**
+     * @param count Number of filters in the chain.
+     * @param sampleRate The signal's sample rate.
+     * @param freq The corner frequency for the whole chain.
+     */
+    constructor(count: number, sampleRate: number, freq: number);
+}
+/**
+ * Shifts IQ samples by a given frequency.
+ */
+export declare class FrequencyShifter {
+    private sampleRate;
+    constructor(sampleRate: number);
+    private cosine;
+    private sine;
+    inPlace(I: Float32Array, Q: Float32Array, freq: number): void;
+}
+/** A phase-locked loop that can detect a signal with a given frequency. */
+export declare class PLL {
+    private sampleRate;
+    /**
+     * @param sampleRate The sample rate for the input signal.
+     * @param freq The frequency of the signal to detect, in Hz.
+     * @param tolerance The frequency tolerance for the signal, in Hz.
+     */
+    constructor(sampleRate: number, freq: number, tolerance: number);
+    private phase;
+    private speed;
+    private maxSpeedCorr;
+    private speedCorrection;
+    private phaseCorrection;
+    private biFlt;
+    private bqFlt;
+    private siFlt;
+    private sqFlt;
+    private piFlt;
+    private pqFlt;
+    private lbI;
+    private lbQ;
+    private iMagFlt;
+    private bMagFlt;
+    cos: number;
+    sin: number;
+    locked: boolean;
+    add(sample: number): void;
+    addRemaining(sample: number): void;
+}
+export {};
+//# sourceMappingURL=filters.d.ts.map

package/dist/dsp/filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/dsp/filters.ts"],"names":[],"mappings":"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"}

package/dist/dsp/filters.js

@@ -0,0 +1,486 @@
+// Copyright 2024 Jacobo Tarrio Barreiro. All rights reserved.
+// Copyright 2013 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { atan2 } from "./math.js";
+/** A class to apply a FIR filter to a sequence of samples. */
+export class FIRFilter {
+    coefs;
+    /** @param coefs The coefficients of the filter to apply. */
+    constructor(coefs) {
+        this.coefs = coefs;
+        this.offset = this.coefs.length - 1;
+        this.center = Math.floor(this.coefs.length / 2);
+        this.curSamples = new Float32Array(this.offset);
+    }
+    offset;
+    center;
+    curSamples;
+    setCoefficients(coefs) {
+        const oldSamples = this.curSamples;
+        this.coefs = coefs;
+        this.offset = this.coefs.length - 1;
+        this.center = Math.floor(this.coefs.length / 2);
+        this.curSamples = new Float32Array(this.offset);
+        this.loadSamples(oldSamples);
+    }
+    clone() {
+        return new FIRFilter(this.coefs);
+    }
+    getDelay() {
+        return this.center;
+    }
+    inPlace(samples) {
+        this.loadSamples(samples);
+        for (let i = 0; i < samples.length; ++i) {
+            samples[i] = this.get(i);
+        }
+    }
+    delayInPlace(samples) {
+        this.loadSamples(samples);
+        for (let i = 0; i < samples.length; ++i) {
+            samples[i] = this.getDelayed(i);
+        }
+    }
+    /**
+     * Loads a new block of samples to filter.
+     * @param samples The samples to load.
+     */
+    loadSamples(samples) {
+        const len = samples.length + this.offset;
+        if (this.curSamples.length != len) {
+            let newSamples = new Float32Array(len);
+            newSamples.set(this.curSamples.subarray(this.curSamples.length - this.offset));
+            this.curSamples = newSamples;
+        }
+        else {
+            this.curSamples.copyWithin(0, samples.length);
+        }
+        this.curSamples.set(samples, this.offset);
+    }
+    /**
+     * Returns a filtered sample.
+     * Be very careful when you modify this function. About 85% of the total execution
+     * time is spent here, so performance is critical.
+     * @param index The index of the sample to return, corresponding
+     *     to the same index in the latest sample block loaded via loadSamples().
+     */
+    get(index) {
+        let i = 0;
+        let out = 0;
+        let len = this.coefs.length;
+        let len4 = 4 * Math.floor(len / 4);
+        while (i < len4) {
+            out +=
+                this.coefs[i++] * this.curSamples[index++] +
+                    this.coefs[i++] * this.curSamples[index++] +
+                    this.coefs[i++] * this.curSamples[index++] +
+                    this.coefs[i++] * this.curSamples[index++];
+        }
+        let len2 = 2 * Math.floor(len / 2);
+        while (i < len2) {
+            out +=
+                this.coefs[i++] * this.curSamples[index++] +
+                    this.coefs[i++] * this.curSamples[index++];
+        }
+        while (i < len) {
+            out += this.coefs[i++] * this.curSamples[index++];
+        }
+        return out;
+    }
+    /**
+     * Returns a delayed sample.
+     * @param index The index of the relative sample to return.
+     */
+    getDelayed(index) {
+        return this.curSamples[index + this.center];
+    }
+}
+/** Automatic gain control for audio signals. */
+export class AGC {
+    sampleRate;
+    constructor(sampleRate, timeConstantSeconds, maxGain) {
+        this.sampleRate = sampleRate;
+        this.dcBlocker = new DcBlocker(sampleRate);
+        this.alpha = decay(sampleRate, timeConstantSeconds);
+        this.counter = 0;
+        this.maxPower = 0;
+        this.maxGain = maxGain || 100;
+    }
+    dcBlocker;
+    alpha;
+    counter;
+    maxPower;
+    maxGain;
+    clone() {
+        let copy = new AGC(this.sampleRate, 1, this.maxGain);
+        copy.alpha = this.alpha;
+        return copy;
+    }
+    getDelay() {
+        return 0;
+    }
+    inPlace(samples) {
+        const alpha = this.alpha;
+        let maxPower = this.maxPower;
+        let counter = this.counter;
+        let gain;
+        this.dcBlocker.inPlace(samples);
+        for (let i = 0; i < samples.length; ++i) {
+            const v = samples[i];
+            const power = v * v;
+            if (power > 0.9 * maxPower) {
+                counter = this.sampleRate;
+                if (power > maxPower) {
+                    maxPower = power;
+                }
+            }
+            else if (counter > 0) {
+                --counter;
+            }
+            else {
+                maxPower -= alpha * maxPower;
+            }
+            gain = Math.min(this.maxGain, 1 / Math.sqrt(maxPower));
+            samples[i] *= gain;
+        }
+        this.maxPower = maxPower;
+        this.counter = counter;
+    }
+}
+/** A filter that blocks DC signals. */
+export class DcBlocker {
+    constructor(sampleRate) {
+        this.alpha = decay(sampleRate, 0.5);
+        this.dc = 0;
+    }
+    alpha;
+    dc;
+    clone() {
+        let copy = new DcBlocker(1000);
+        copy.alpha = this.alpha;
+        copy.dc = this.dc;
+        return copy;
+    }
+    getDelay() {
+        return 0;
+    }
+    inPlace(samples) {
+        const alpha = this.alpha;
+        let dc = this.dc;
+        for (let i = 0; i < samples.length; ++i) {
+            dc += alpha * (samples[i] - dc);
+            samples[i] -= dc;
+        }
+        this.dc = dc;
+    }
+}
+/**
+ * Returns the decay value to use in a single-pole low-pass or high-pass IIR filter
+ * with the given time constant.
+ * @param sampleRate The signal's sample rate.
+ * @param timeConstant The time constant in seconds
+ */
+export function decay(sampleRate, timeConstant) {
+    return 1 - Math.exp(-1 / (sampleRate * timeConstant));
+}
+/* Returns the time constant corresponding to a -3dB frequency. */
+export function frequencyToTimeConstant(freq) {
+    return 1 / (2 * Math.PI * freq);
+}
+/** IIR filter with two 'b' coefficients and one 'a' coefficient. */
+class IIRFilter21 {
+    sampleRate;
+    b0;
+    b1;
+    a1;
+    constructor(sampleRate, b0, b1, a1) {
+        this.sampleRate = sampleRate;
+        this.b0 = b0;
+        this.b1 = b1;
+        this.a1 = a1;
+        this.prev = 0;
+        this.val = 0;
+    }
+    prev;
+    val;
+    /** Returns a copy of this filter. */
+    clone() {
+        return new IIRFilter21(this.sampleRate, this.b0, this.b1, this.a1);
+    }
+    getDelay() {
+        return 0;
+    }
+    /**
+     * Filters the given samples in place.
+     * @param samples The samples to filter.
+     */
+    inPlace(samples) {
+        let prev = this.prev;
+        let val = this.val;
+        for (let i = 0; i < samples.length; ++i) {
+            val = this.b0 * samples[i] + this.b1 * prev + this.a1 * val;
+            prev = samples[i];
+            samples[i] = val;
+        }
+        this.prev = prev;
+        this.val = val;
+    }
+    /** Filters an individual sample. */
+    add(sample) {
+        this.val = this.b0 * sample + this.b1 * this.prev + this.a1 * this.val;
+        this.prev = sample;
+        return this.val;
+    }
+    /** Returns the value currently held by the filter. */
+    get value() {
+        return this.val;
+    }
+    /** Returns the phase shift at the given angular frequency. */
+    phaseShift(freq) {
+        const w = (2 * Math.PI * freq) / this.sampleRate;
+        const real = Math.cos(w) * (this.b1 - this.b0 * this.a1) + this.b0 - this.b1 * this.a1;
+        const imag = Math.sin(w) * (this.b1 + this.b0 * this.a1);
+        return atan2(imag, real);
+    }
+}
+/** A FM de-emphasis filter. */
+export class Deemphasis extends IIRFilter21 {
+    /**
+     * @param sampleRate The signal's sample rate.
+     * @param timeConstant The filter's time constant, in seconds.
+     */
+    constructor(sampleRate, timeConstant) {
+        const wd = 1 / (timeConstant * sampleRate);
+        const wa = 2 * sampleRate * Math.tan(wd / 2);
+        const tau = 1 / wa;
+        let a = 1 + 2 * tau * sampleRate;
+        let b = 1 - 2 * tau * sampleRate;
+        super(sampleRate, 1 / a, 1 / a, -b / a);
+    }
+}
+/** A FM pre-emphasis filter. */
+export class Preemphasis extends IIRFilter21 {
+    /**
+     * @param sampleRate The signal's sample rate.
+     * @param timeConstant The filter's time constant, in seconds.
+     */
+    constructor(sampleRate, timeConstant) {
+        const wdl = 1 / (timeConstant * sampleRate);
+        const wdh = Math.PI * 0.9;
+        const wal = Math.tan(wdl / 2);
+        const wah = Math.tan(wdh / 2);
+        const a = wal + 1;
+        const b = wal - 1;
+        const c = wah + 1;
+        const d = wah - 1;
+        const zg = wal / wah;
+        super(sampleRate, a / (c * zg), b / (c * zg), -d / c);
+    }
+}
+/** A single-pole IIR low-pass filter. */
+export class IIRLowPass extends Deemphasis {
+    /**
+     * @param sampleRate The signal's sample rate.
+     * @param freq The filter's corner frequency.
+     */
+    constructor(sampleRate, freq) {
+        super(sampleRate, frequencyToTimeConstant(freq));
+    }
+}
+class IIRFilterChain {
+    filters;
+    constructor(filters) {
+        this.filters = filters;
+    }
+    /** Returns a copy of this filter. */
+    clone() {
+        return new IIRFilterChain(this.filters.map((f) => f.clone()));
+    }
+    getDelay() {
+        return 0;
+    }
+    /**
+     * Filters the given samples in place.
+     * @param samples The samples to filter.
+     */
+    inPlace(samples) {
+        for (let f of this.filters) {
+            f.inPlace(samples);
+        }
+    }
+    /** Filters an individual sample. */
+    add(sample) {
+        for (let f of this.filters) {
+            sample = f.add(sample);
+        }
+        return sample;
+    }
+    /** Returns the value currently held by the filter. */
+    get value() {
+        return this.filters[this.filters.length - 1].value;
+    }
+    /** Returns the phase shift at the given frequency. */
+    phaseShift(freq) {
+        let lag = 0;
+        for (let f of this.filters) {
+            lag += f.phaseShift(freq);
+        }
+        return ((lag + Math.PI) % (2 * Math.PI)) - Math.PI;
+    }
+}
+/** A chain of single-pole IIR low-pass filters. */
+export class IIRLowPassChain extends IIRFilterChain {
+    /**
+     * @param count Number of filters in the chain.
+     * @param sampleRate The signal's sample rate.
+     * @param freq The corner frequency for the whole chain.
+     */
+    constructor(count, sampleRate, freq) {
+        const cf = freq / Math.sqrt(Math.pow(2, 1 / count) - 1);
+        let filters = Array.from({ length: count }).map((_) => new IIRLowPass(sampleRate, cf));
+        super(filters);
+    }
+}
+/**
+ * Shifts IQ samples by a given frequency.
+ */
+export class FrequencyShifter {
+    sampleRate;
+    constructor(sampleRate) {
+        this.sampleRate = sampleRate;
+        this.cosine = 1;
+        this.sine = 0;
+    }
+    cosine;
+    sine;
+    inPlace(I, Q, freq) {
+        let cosine = this.cosine;
+        let sine = this.sine;
+        const deltaCos = Math.cos((2 * Math.PI * freq) / this.sampleRate);
+        const deltaSin = Math.sin((2 * Math.PI * freq) / this.sampleRate);
+        for (let i = 0; i < I.length; ++i) {
+            const newI = I[i] * cosine - Q[i] * sine;
+            Q[i] = I[i] * sine + Q[i] * cosine;
+            I[i] = newI;
+            const newSine = cosine * deltaSin + sine * deltaCos;
+            cosine = cosine * deltaCos - sine * deltaSin;
+            sine = newSine;
+        }
+        this.cosine = cosine;
+        this.sine = sine;
+    }
+}
+/** A phase-locked loop that can detect a signal with a given frequency. */
+export class PLL {
+    sampleRate;
+    /**
+     * @param sampleRate The sample rate for the input signal.
+     * @param freq The frequency of the signal to detect, in Hz.
+     * @param tolerance The frequency tolerance for the signal, in Hz.
+     */
+    constructor(sampleRate, freq, tolerance) {
+        this.sampleRate = sampleRate;
+        this.phase = 0;
+        this.speed = (2 * Math.PI * freq) / sampleRate;
+        this.maxSpeedCorr = (2 * Math.PI * tolerance) / sampleRate;
+        this.speedCorrection = 0;
+        this.phaseCorrection = 0;
+        this.biFlt = new IIRLowPassChain(4, sampleRate, tolerance);
+        this.bqFlt = new IIRLowPassChain(4, sampleRate, tolerance);
+        this.siFlt = new IIRLowPassChain(4, sampleRate, 7);
+        this.sqFlt = new IIRLowPassChain(4, sampleRate, 7);
+        this.piFlt = new IIRLowPassChain(4, sampleRate, 250);
+        this.pqFlt = new IIRLowPassChain(4, sampleRate, 250);
+        this.lbI = 0;
+        this.lbQ = 0;
+        this.iMagFlt = new IIRLowPass(sampleRate, 7);
+        this.bMagFlt = new IIRLowPass(sampleRate, 7);
+        this.cos = 1;
+        this.sin = 0;
+        this.locked = true;
+    }
+    phase;
+    speed;
+    maxSpeedCorr;
+    speedCorrection;
+    phaseCorrection;
+    biFlt;
+    bqFlt;
+    siFlt;
+    sqFlt;
+    piFlt;
+    pqFlt;
+    lbI;
+    lbQ;
+    iMagFlt;
+    bMagFlt;
+    cos;
+    sin;
+    locked;
+    add(sample) {
+        let phase = this.phase;
+        // Generate outputs with last computed parameters
+        this.cos = Math.cos(phase);
+        this.sin = Math.sin(phase);
+        // Compute I+jQ, the difference between the input and our internal oscillator
+        this.lbI = this.biFlt.add(Math.cos(-phase) * sample);
+        this.lbQ = this.bqFlt.add(Math.sin(-phase) * sample);
+        this.phase += this.speed;
+        this.add = this.addRemaining;
+    }
+    addRemaining(sample) {
+        let phase = this.phase;
+        // Generate outputs with last computed parameters
+        let angle = phase + this.speedCorrection + this.phaseCorrection;
+        this.cos = Math.cos(angle);
+        this.sin = Math.sin(angle);
+        // Compute (bI, bQ), the beat (difference) between the input and our reference oscillator
+        const rawI = Math.cos(-phase) * sample;
+        const rawQ = Math.sin(-phase) * sample;
+        const bI = this.biFlt.add(rawI);
+        const bQ = this.bqFlt.add(rawQ);
+        this.phase = this.phase + this.speed;
+        // The beat is going to lag or advance wrt the input because of the input filter chain
+        // Compute (sI, sQ), the average phase speed of (bI, bQ). That's the difference in frequency.
+        // rs = b * conj(lb)
+        const rsI = this.lbI * bI + this.lbQ * bQ;
+        const rsQ = this.lbI * bQ - bI * this.lbQ;
+        const sI = this.siFlt.add(rsI);
+        const sQ = this.sqFlt.add(rsQ);
+        this.lbI = bI;
+        this.lbQ = bQ;
+        const beatSpeed = atan2(sQ, sI);
+        const speedCorr = Math.max(-this.maxSpeedCorr, Math.min(beatSpeed, this.maxSpeedCorr));
+        this.speedCorrection += speedCorr;
+        // Compute (dI, dQ), the difference between the beat (bI, bQ) and our speed correction (cI, cQ)
+        // That's the difference in phase.
+        const cI = Math.cos(this.speedCorrection);
+        const cQ = Math.sin(this.speedCorrection);
+        // rd = b * conj(c)
+        const rdI = bI * cI + bQ * cQ;
+        const rdQ = cI * bQ - bI * cQ;
+        const dI = this.piFlt.add(rdI);
+        const dQ = this.pqFlt.add(rdQ);
+        // But the biFlt/bqFlt are going to shift the phase of (bI, bQ), so compensate for that.
+        const freqCorrectionHz = (speedCorr * this.sampleRate) / (2 * Math.PI);
+        const shift = this.biFlt.phaseShift(freqCorrectionHz);
+        const phaseDiff = atan2(dQ, dI) + shift;
+        this.phaseCorrection = phaseDiff;
+        // Check if we are locked
+        let mag = this.iMagFlt.add(Math.abs(sample));
+        let bimag = this.bMagFlt.add(Math.hypot(bI, bQ) * 2);
+        this.locked = bimag > mag / 15;
+    }
+}
+//# sourceMappingURL=filters.js.map