pyminidsp 0.2.0__tar.gz

pyminidsp-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chuck Wooters
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyminidsp-0.2.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+include README.md
+include pyproject.toml
+include setup.py
+recursive-include pyminidsp *.py
+recursive-include vendor/miniDSP *.c *.h

pyminidsp-0.2.0/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: pyminidsp
+Version: 0.2.0
+Summary: Python bindings to the miniDSP C library
+Author: Chuck Wooters
+License: MIT
+Project-URL: Homepage, https://github.com/wooters/pyminidsp
+Project-URL: Repository, https://github.com/wooters/pyminidsp
+Project-URL: Documentation, https://wooters.github.io/pyminidsp/
+Project-URL: Issues, https://github.com/wooters/pyminidsp/issues
+Keywords: dsp,audio,signal-processing,fft,biquad,cffi
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cffi>=1.0
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.0; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Dynamic: license-file
+
+# pyminidsp
+
+**[Documentation](https://wooters.github.io/pyminidsp/)**
+
+Python bindings to the [miniDSP](https://github.com/wooters/miniDSP) C library.
+
+A comprehensive DSP toolkit providing signal generation, spectral analysis,
+filtering, effects, and more. All functions accept and return NumPy arrays.
+
+## Prerequisites
+
+- Python >= 3.9
+- [FFTW3](http://www.fftw.org/) development headers
+  - Ubuntu/Debian: `sudo apt install libfftw3-dev`
+  - macOS: `brew install fftw`
+- A C compiler (gcc or clang)
+
+## Installation
+
+```bash
+# Clone the miniDSP C library (if not already present)
+git clone https://github.com/wooters/miniDSP.git
+
+# Create virtual environment (uses .python-version for Python version)
+uv venv
+
+# Install pyminidsp (set MINIDSP_SRC to point to the C library)
+MINIDSP_SRC=./miniDSP uv sync
+```
+
+Or for development:
+
+```bash
+MINIDSP_SRC=./miniDSP uv sync --extra dev
+```
+
+## Quick Start
+
+```python
+import pyminidsp as md
+
+# Generate a 440 Hz sine wave (1 second at 44.1 kHz)
+signal = md.sine_wave(44100, amplitude=1.0, freq=440.0, sample_rate=44100.0)
+
+# Compute the magnitude spectrum
+mag = md.magnitude_spectrum(signal)
+
+# Compute MFCCs from a frame
+coeffs = md.mfcc(signal[:512], sample_rate=44100.0, num_mels=26, num_coeffs=13)
+
+# Apply a low-pass biquad filter
+lpf = md.BiquadFilter(md.LPF, freq=1000.0, sample_rate=44100.0)
+filtered = lpf.process_array(signal)
+
+# Clean up FFT caches when done
+md.shutdown()
+```
+
+## API Overview
+
+### Signal Generators
+
+| Function | Description |
+|----------|-------------|
+| `sine_wave(n, amplitude, freq, sample_rate)` | Pure sine tone |
+| `white_noise(n, amplitude, seed)` | Gaussian white noise |
+| `impulse(n, amplitude, position)` | Kronecker delta |
+| `chirp_linear(n, amplitude, f_start, f_end, sample_rate)` | Linear frequency sweep |
+| `chirp_log(n, amplitude, f_start, f_end, sample_rate)` | Logarithmic frequency sweep |
+| `square_wave(n, amplitude, freq, sample_rate)` | Square wave |
+| `sawtooth_wave(n, amplitude, freq, sample_rate)` | Sawtooth wave |
+| `shepard_tone(n, amplitude, base_freq, sample_rate, rate, num_octaves)` | Shepard tone illusion |
+
+### Spectral Analysis
+
+| Function | Description |
+|----------|-------------|
+| `magnitude_spectrum(signal)` | One-sided magnitude spectrum via FFT |
+| `power_spectral_density(signal)` | Periodogram PSD estimate |
+| `phase_spectrum(signal)` | Phase spectrum in radians |
+| `stft(signal, n, hop)` | Short-Time Fourier Transform |
+| `mel_filterbank(n, sample_rate, num_mels)` | Mel-spaced triangular filterbank |
+| `mel_energies(signal, sample_rate, num_mels)` | Mel-band energies |
+| `mfcc(signal, sample_rate, num_mels, num_coeffs)` | Mel-frequency cepstral coefficients |
+
+### Signal Analysis
+
+| Function | Description |
+|----------|-------------|
+| `rms(signal)` | Root mean square |
+| `energy(signal)` | Signal energy |
+| `power(signal)` / `power_db(signal)` | Signal power (linear / dB) |
+| `zero_crossing_rate(signal)` | Zero-crossing rate |
+| `autocorrelation(signal, max_lag)` | Normalised autocorrelation |
+| `peak_detect(signal, threshold, min_distance)` | Local maxima detection |
+| `f0_autocorrelation(signal, sample_rate, min_freq, max_freq)` | F0 via autocorrelation |
+| `f0_fft(signal, sample_rate, min_freq, max_freq)` | F0 via FFT peak picking |
+
+### Effects & Filters
+
+| Function | Description |
+|----------|-------------|
+| `delay_echo(signal, delay_samples, feedback, dry, wet)` | Echo effect |
+| `tremolo(signal, rate_hz, depth, sample_rate)` | Amplitude modulation |
+| `comb_reverb(signal, delay_samples, feedback, dry, wet)` | Comb-filter reverb |
+| `convolution_time(signal, kernel)` | Time-domain convolution |
+| `convolution_fft_ola(signal, kernel)` | FFT overlap-add convolution |
+| `moving_average(signal, window_len)` | Moving average filter |
+| `fir_filter(signal, coeffs)` | FIR filter |
+| `BiquadFilter(type, freq, sample_rate)` | IIR biquad filter (LPF/HPF/BPF/etc.) |
+
+### DTMF
+
+| Function | Description |
+|----------|-------------|
+| `dtmf_generate(digits, sample_rate, tone_ms, pause_ms)` | Generate DTMF tones |
+| `dtmf_detect(signal, sample_rate)` | Detect DTMF digits |
+
+### Delay Estimation (GCC-PHAT)
+
+| Function | Description |
+|----------|-------------|
+| `get_delay(sig_a, sig_b, margin, weighting)` | Delay between two signals |
+| `gcc(sig_a, sig_b, weighting)` | Full cross-correlation |
+
+### Audio Steganography
+
+| Function | Description |
+|----------|-------------|
+| `steg_encode(host, message, sample_rate, method)` | Hide text in audio |
+| `steg_decode(stego, sample_rate, method)` | Recover hidden text |
+| `steg_encode_bytes(host, data, sample_rate, method)` | Hide binary data |
+| `steg_decode_bytes(stego, sample_rate, method)` | Recover binary data |
+| `steg_detect(signal, sample_rate)` | Detect steganography method |
+
+### Spectrogram Art
+
+| Function | Description |
+|----------|-------------|
+| `spectrogram_text(text, freq_lo, freq_hi, duration, sample_rate)` | Text visible in spectrogram |
+
+## Running Tests
+
+```bash
+MINIDSP_SRC=./miniDSP uv run pytest tests/ -v
+```
+
+## License
+
+MIT

pyminidsp-0.2.0/README.md

@@ -0,0 +1,150 @@
+# pyminidsp
+
+**[Documentation](https://wooters.github.io/pyminidsp/)**
+
+Python bindings to the [miniDSP](https://github.com/wooters/miniDSP) C library.
+
+A comprehensive DSP toolkit providing signal generation, spectral analysis,
+filtering, effects, and more. All functions accept and return NumPy arrays.
+
+## Prerequisites
+
+- Python >= 3.9
+- [FFTW3](http://www.fftw.org/) development headers
+  - Ubuntu/Debian: `sudo apt install libfftw3-dev`
+  - macOS: `brew install fftw`
+- A C compiler (gcc or clang)
+
+## Installation
+
+```bash
+# Clone the miniDSP C library (if not already present)
+git clone https://github.com/wooters/miniDSP.git
+
+# Create virtual environment (uses .python-version for Python version)
+uv venv
+
+# Install pyminidsp (set MINIDSP_SRC to point to the C library)
+MINIDSP_SRC=./miniDSP uv sync
+```
+
+Or for development:
+
+```bash
+MINIDSP_SRC=./miniDSP uv sync --extra dev
+```
+
+## Quick Start
+
+```python
+import pyminidsp as md
+
+# Generate a 440 Hz sine wave (1 second at 44.1 kHz)
+signal = md.sine_wave(44100, amplitude=1.0, freq=440.0, sample_rate=44100.0)
+
+# Compute the magnitude spectrum
+mag = md.magnitude_spectrum(signal)
+
+# Compute MFCCs from a frame
+coeffs = md.mfcc(signal[:512], sample_rate=44100.0, num_mels=26, num_coeffs=13)
+
+# Apply a low-pass biquad filter
+lpf = md.BiquadFilter(md.LPF, freq=1000.0, sample_rate=44100.0)
+filtered = lpf.process_array(signal)
+
+# Clean up FFT caches when done
+md.shutdown()
+```
+
+## API Overview
+
+### Signal Generators
+
+| Function | Description |
+|----------|-------------|
+| `sine_wave(n, amplitude, freq, sample_rate)` | Pure sine tone |
+| `white_noise(n, amplitude, seed)` | Gaussian white noise |
+| `impulse(n, amplitude, position)` | Kronecker delta |
+| `chirp_linear(n, amplitude, f_start, f_end, sample_rate)` | Linear frequency sweep |
+| `chirp_log(n, amplitude, f_start, f_end, sample_rate)` | Logarithmic frequency sweep |
+| `square_wave(n, amplitude, freq, sample_rate)` | Square wave |
+| `sawtooth_wave(n, amplitude, freq, sample_rate)` | Sawtooth wave |
+| `shepard_tone(n, amplitude, base_freq, sample_rate, rate, num_octaves)` | Shepard tone illusion |
+
+### Spectral Analysis
+
+| Function | Description |
+|----------|-------------|
+| `magnitude_spectrum(signal)` | One-sided magnitude spectrum via FFT |
+| `power_spectral_density(signal)` | Periodogram PSD estimate |
+| `phase_spectrum(signal)` | Phase spectrum in radians |
+| `stft(signal, n, hop)` | Short-Time Fourier Transform |
+| `mel_filterbank(n, sample_rate, num_mels)` | Mel-spaced triangular filterbank |
+| `mel_energies(signal, sample_rate, num_mels)` | Mel-band energies |
+| `mfcc(signal, sample_rate, num_mels, num_coeffs)` | Mel-frequency cepstral coefficients |
+
+### Signal Analysis
+
+| Function | Description |
+|----------|-------------|
+| `rms(signal)` | Root mean square |
+| `energy(signal)` | Signal energy |
+| `power(signal)` / `power_db(signal)` | Signal power (linear / dB) |
+| `zero_crossing_rate(signal)` | Zero-crossing rate |
+| `autocorrelation(signal, max_lag)` | Normalised autocorrelation |
+| `peak_detect(signal, threshold, min_distance)` | Local maxima detection |
+| `f0_autocorrelation(signal, sample_rate, min_freq, max_freq)` | F0 via autocorrelation |
+| `f0_fft(signal, sample_rate, min_freq, max_freq)` | F0 via FFT peak picking |
+
+### Effects & Filters
+
+| Function | Description |
+|----------|-------------|
+| `delay_echo(signal, delay_samples, feedback, dry, wet)` | Echo effect |
+| `tremolo(signal, rate_hz, depth, sample_rate)` | Amplitude modulation |
+| `comb_reverb(signal, delay_samples, feedback, dry, wet)` | Comb-filter reverb |
+| `convolution_time(signal, kernel)` | Time-domain convolution |
+| `convolution_fft_ola(signal, kernel)` | FFT overlap-add convolution |
+| `moving_average(signal, window_len)` | Moving average filter |
+| `fir_filter(signal, coeffs)` | FIR filter |
+| `BiquadFilter(type, freq, sample_rate)` | IIR biquad filter (LPF/HPF/BPF/etc.) |
+
+### DTMF
+
+| Function | Description |
+|----------|-------------|
+| `dtmf_generate(digits, sample_rate, tone_ms, pause_ms)` | Generate DTMF tones |
+| `dtmf_detect(signal, sample_rate)` | Detect DTMF digits |
+
+### Delay Estimation (GCC-PHAT)
+
+| Function | Description |
+|----------|-------------|
+| `get_delay(sig_a, sig_b, margin, weighting)` | Delay between two signals |
+| `gcc(sig_a, sig_b, weighting)` | Full cross-correlation |
+
+### Audio Steganography
+
+| Function | Description |
+|----------|-------------|
+| `steg_encode(host, message, sample_rate, method)` | Hide text in audio |
+| `steg_decode(stego, sample_rate, method)` | Recover hidden text |
+| `steg_encode_bytes(host, data, sample_rate, method)` | Hide binary data |
+| `steg_decode_bytes(stego, sample_rate, method)` | Recover binary data |
+| `steg_detect(signal, sample_rate)` | Detect steganography method |
+
+### Spectrogram Art
+
+| Function | Description |
+|----------|-------------|
+| `spectrogram_text(text, freq_lo, freq_hi, duration, sample_rate)` | Text visible in spectrogram |
+
+## Running Tests
+
+```bash
+MINIDSP_SRC=./miniDSP uv run pytest tests/ -v
+```
+
+## License
+
+MIT

pyminidsp-0.2.0/pyminidsp/__init__.py

@@ -0,0 +1,100 @@
+"""
+pyminidsp - Python bindings to the miniDSP C library.
+
+A comprehensive DSP toolkit providing signal generation, spectral analysis,
+filtering, effects, and more. All functions accept and return NumPy arrays.
+
+Example:
+    >>> import pyminidsp as md
+    >>> signal = md.sine_wave(1024, amplitude=1.0, freq=440.0, sample_rate=44100.0)
+    >>> mag = md.magnitude_spectrum(signal)
+    >>> md.shutdown()
+"""
+
+from pyminidsp._core import *  # noqa: F401, F403
+from pyminidsp._core import (
+    # Re-export everything explicitly for documentation
+    # Signal measurement
+    dot, entropy, energy, power, power_db,
+    # Signal analysis
+    rms, zero_crossing_rate, autocorrelation, peak_detect,
+    f0_autocorrelation, f0_fft, mix,
+    # Effects
+    delay_echo, tremolo, comb_reverb,
+    # FIR / Convolution
+    convolution_num_samples, convolution_time, moving_average,
+    fir_filter, convolution_fft_ola,
+    # Scaling
+    scale, scale_vec, fit_within_range, adjust_dblevel,
+    # Spectrum
+    magnitude_spectrum, power_spectral_density, phase_spectrum,
+    stft_num_frames, stft, mel_filterbank, mel_energies, mfcc,
+    # Windows
+    hann_window, hamming_window, blackman_window, rect_window,
+    # Generators
+    sine_wave, white_noise, impulse, chirp_linear, chirp_log,
+    square_wave, sawtooth_wave, shepard_tone,
+    # DTMF
+    dtmf_detect, dtmf_generate, dtmf_signal_length,
+    # Cleanup
+    shutdown,
+    # GCC
+    get_delay, get_multiple_delays, gcc,
+    # Spectrogram text
+    spectrogram_text,
+    # Steganography
+    steg_capacity, steg_encode, steg_decode,
+    steg_encode_bytes, steg_decode_bytes, steg_detect,
+    # Biquad
+    BiquadFilter,
+    # Constants
+    LPF, HPF, BPF, NOTCH, PEQ, LSH, HSH,
+    STEG_LSB, STEG_FREQ_BAND, STEG_TYPE_TEXT, STEG_TYPE_BINARY,
+    GCC_SIMP, GCC_PHAT,
+)
+
+from importlib.metadata import version as _version, PackageNotFoundError as _PNF
+
+try:
+    __version__ = _version("pyminidsp")
+except _PNF:
+    __version__ = "0.0.0"  # not installed via pip (e.g. editable dev checkout)
+__all__ = [
+    # Signal measurement
+    "dot", "entropy", "energy", "power", "power_db",
+    # Signal analysis
+    "rms", "zero_crossing_rate", "autocorrelation", "peak_detect",
+    "f0_autocorrelation", "f0_fft", "mix",
+    # Effects
+    "delay_echo", "tremolo", "comb_reverb",
+    # FIR / Convolution
+    "convolution_num_samples", "convolution_time", "moving_average",
+    "fir_filter", "convolution_fft_ola",
+    # Scaling
+    "scale", "scale_vec", "fit_within_range", "adjust_dblevel",
+    # Spectrum
+    "magnitude_spectrum", "power_spectral_density", "phase_spectrum",
+    "stft_num_frames", "stft", "mel_filterbank", "mel_energies", "mfcc",
+    # Windows
+    "hann_window", "hamming_window", "blackman_window", "rect_window",
+    # Generators
+    "sine_wave", "white_noise", "impulse", "chirp_linear", "chirp_log",
+    "square_wave", "sawtooth_wave", "shepard_tone",
+    # DTMF
+    "dtmf_detect", "dtmf_generate", "dtmf_signal_length",
+    # Cleanup
+    "shutdown",
+    # GCC
+    "get_delay", "get_multiple_delays", "gcc",
+    # Spectrogram text
+    "spectrogram_text",
+    # Steganography
+    "steg_capacity", "steg_encode", "steg_decode",
+    "steg_encode_bytes", "steg_decode_bytes", "steg_detect",
+    # Biquad
+    "BiquadFilter",
+    # Constants
+    "LPF", "HPF", "BPF", "NOTCH", "PEQ", "LSH", "HSH",
+    "STEG_LSB", "STEG_FREQ_BAND", "STEG_TYPE_TEXT", "STEG_TYPE_BINARY",
+    "GCC_SIMP", "GCC_PHAT",
+]

pyminidsp-0.2.0/pyminidsp/_analysis.py

@@ -0,0 +1,169 @@
+"""Signal measurement, analysis, and scaling functions."""
+
+import numpy as np
+
+from pyminidsp._minidsp_cffi import ffi, lib
+from pyminidsp._helpers import _as_double_ptr, _new_double_array
+
+# ---------------------------------------------------------------------------
+# Signal measurement
+# ---------------------------------------------------------------------------
+
+def dot(a, b):
+    """Compute the dot product of two vectors."""
+    a_ptr, a = _as_double_ptr(a)
+    b_ptr, b = _as_double_ptr(b)
+    n = min(len(a), len(b))
+    return lib.MD_dot(a_ptr, b_ptr, n)
+
+
+def entropy(a, clip=False):
+    """Compute the normalized entropy of a distribution."""
+    a_ptr, a = _as_double_ptr(a)
+    return lib.MD_entropy(a_ptr, len(a), clip)
+
+
+def energy(a):
+    """Compute signal energy: sum of squared samples."""
+    a_ptr, a = _as_double_ptr(a)
+    return lib.MD_energy(a_ptr, len(a))
+
+
+def power(a):
+    """Compute signal power: energy / N."""
+    a_ptr, a = _as_double_ptr(a)
+    return lib.MD_power(a_ptr, len(a))
+
+
+def power_db(a):
+    """Compute signal power in decibels."""
+    a_ptr, a = _as_double_ptr(a)
+    return lib.MD_power_db(a_ptr, len(a))
+
+
+# ---------------------------------------------------------------------------
+# Signal analysis
+# ---------------------------------------------------------------------------
+
+def rms(a):
+    """Compute the root mean square (RMS) of a signal."""
+    a_ptr, a = _as_double_ptr(a)
+    return lib.MD_rms(a_ptr, len(a))
+
+
+def zero_crossing_rate(a):
+    """Compute the zero-crossing rate of a signal."""
+    a_ptr, a = _as_double_ptr(a)
+    return lib.MD_zero_crossing_rate(a_ptr, len(a))
+
+
+def autocorrelation(a, max_lag):
+    """
+    Compute the normalised autocorrelation of a signal.
+
+    Args:
+        a: Input signal.
+        max_lag: Number of lag values to compute.
+
+    Returns:
+        numpy array of autocorrelation values, length max_lag.
+    """
+    a_ptr, a = _as_double_ptr(a)
+    out, out_ptr = _new_double_array(max_lag)
+    lib.MD_autocorrelation(a_ptr, len(a), out_ptr, max_lag)
+    return out
+
+
+def peak_detect(a, threshold=0.0, min_distance=1):
+    """
+    Detect peaks (local maxima) in a signal.
+
+    Args:
+        a: Input signal.
+        threshold: Minimum value for a peak.
+        min_distance: Minimum index gap between peaks.
+
+    Returns:
+        numpy array of peak indices.
+    """
+    a_ptr, a = _as_double_ptr(a)
+    n = len(a)
+    peaks = np.zeros(n, dtype=np.uint32)
+    num_peaks = ffi.new("unsigned *")
+    lib.MD_peak_detect(
+        a_ptr, n, threshold, min_distance,
+        ffi.cast("unsigned *", peaks.ctypes.data), num_peaks,
+    )
+    return peaks[: num_peaks[0]].copy()
+
+
+def f0_autocorrelation(signal, sample_rate, min_freq_hz=80.0, max_freq_hz=400.0):
+    """Estimate F0 using autocorrelation."""
+    s_ptr, signal = _as_double_ptr(signal)
+    return lib.MD_f0_autocorrelation(s_ptr, len(signal), sample_rate, min_freq_hz, max_freq_hz)
+
+
+def f0_fft(signal, sample_rate, min_freq_hz=80.0, max_freq_hz=400.0):
+    """Estimate F0 using FFT peak picking."""
+    s_ptr, signal = _as_double_ptr(signal)
+    return lib.MD_f0_fft(s_ptr, len(signal), sample_rate, min_freq_hz, max_freq_hz)
+
+
+def mix(a, b, w_a=0.5, w_b=0.5):
+    """
+    Mix (weighted sum) two signals.
+
+    Args:
+        a, b: Input signals of the same length.
+        w_a, w_b: Weights for signals a and b.
+
+    Returns:
+        numpy array of the mixed signal.
+    """
+    a_ptr, a = _as_double_ptr(a)
+    b_ptr, b = _as_double_ptr(b)
+    n = min(len(a), len(b))
+    out, out_ptr = _new_double_array(n)
+    lib.MD_mix(a_ptr, b_ptr, out_ptr, n, w_a, w_b)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Signal scaling
+# ---------------------------------------------------------------------------
+
+def scale(value, oldmin, oldmax, newmin, newmax):
+    """Map a single value from one range to another."""
+    return lib.MD_scale(value, oldmin, oldmax, newmin, newmax)
+
+
+def scale_vec(a, oldmin, oldmax, newmin, newmax):
+    """Map every element of a vector from one range to another."""
+    a_ptr, a_arr = _as_double_ptr(a)
+    n = len(a_arr)
+    out, out_ptr = _new_double_array(n)
+    # MD_scale_vec takes non-const input pointer
+    in_copy = np.array(a_arr, dtype=np.float64, copy=True)
+    in_ptr = ffi.cast("double *", in_copy.ctypes.data)
+    lib.MD_scale_vec(in_ptr, out_ptr, n, oldmin, oldmax, newmin, newmax)
+    return out
+
+
+def fit_within_range(a, newmin, newmax):
+    """Fit values within [newmin, newmax]."""
+    a_arr = np.ascontiguousarray(a, dtype=np.float64)
+    n = len(a_arr)
+    in_copy = np.array(a_arr, copy=True)
+    in_ptr = ffi.cast("double *", in_copy.ctypes.data)
+    out, out_ptr = _new_double_array(n)
+    lib.MD_fit_within_range(in_ptr, out_ptr, n, newmin, newmax)
+    return out
+
+
+def adjust_dblevel(signal, dblevel):
+    """Automatic Gain Control: scale signal to target dB level, clip to [-1, 1]."""
+    s_ptr, signal = _as_double_ptr(signal)
+    n = len(signal)
+    out, out_ptr = _new_double_array(n)
+    lib.MD_adjust_dblevel(s_ptr, out_ptr, n, dblevel)
+    return out