pipecat-resampler 0.1.0__tar.gz

pipecat_resampler-0.1.0/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Daily
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pipecat_resampler-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include src/pipecat_resampler/*.h
+recursive-include tests *.py
+recursive-include scripts *.py

pipecat_resampler-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: pipecat-resampler
+Version: 0.1.0
+Summary: Streaming audio resampler whose output keeps pace with its input
+License-Expression: BSD-2-Clause
+Project-URL: Source, https://github.com/pipecat-ai/pipecat-resampler
+Project-URL: Issues, https://github.com/pipecat-ai/pipecat-resampler/issues
+Keywords: audio,resampling,real-time,voice
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pipecat-resampler
+
+A small C extension for Python that converts 16-bit PCM audio, mono or with interleaved channels, from one sample rate to another, chunk by chunk. It's made for real-time audio, such as voice pipelines built with [Pipecat](https://github.com/pipecat-ai/pipecat). Equal chunks in give equal chunks out: 40 ms of audio in always gives 40 ms out, the first chunk included.
+
+```python
+from pipecat_resampler import Resampler
+
+resampler = Resampler(24000, 16000)
+chunk_16k = resampler.process(chunk_24k)  # bytes in, bytes out
+tail = resampler.flush()  # the audio the filter is delaying
+
+stereo = Resampler(48000, 16000, channels=2)
+frames_16k = stereo.process(frames_48k)  # interleaved frames in and out
+```
+
+## Platforms
+
+The extension uses Python's stable ABI, so one wheel per platform covers Python 3.11 and later.
+
+| Platform | Wheels |
+|---|---|
+| Linux x86-64 and ARM64 | manylinux (glibc 2.17 or later) and musllinux (Alpine 3.13 or later) |
+| macOS | x86-64 and ARM64 |
+| Windows | x86-64 |
+
+## Why it exists
+
+A real-time voice pipeline has to resample whenever its parts run at different rates. WebRTC audio arrives at 48 kHz while a speech recognizer might want 16 kHz, or a TTS voice that only comes at 24 kHz has to go out on an 8 kHz phone call. When that happens, the conversion runs chunk by chunk, every 10 to 40 ms, for every stream the process is handling.
+
+We wanted a resampler built for that:
+
+- **Sinc quality.** A band-limited polyphase sinc filter, flat to 90% of the band, with about 90 dB of aliasing rejection.
+- **Fast.** C with SIMD, so one process can carry many streams at once.
+- **Small.** About 0.1 MB installed, with no runtime dependencies.
+- **Steady output.** The same input size gives the same output size on every call, so nothing downstream has to absorb bursts of audio or wait for audio that's held back.
+- **Low latency.** A fixed delay of a few milliseconds.
+- **Easy to ship.** BSD 2-Clause licensed, like Pipecat, with wheels for Linux (glibc 2.17 or later, and Alpine), macOS and Windows.
+
+Each library we tried covers part of this list, and none covered all of it.
+
+## Comparison
+
+Each resampler converted 24 kHz noise to 16 kHz in 40 ms chunks, called from Python, on an Intel i9-10920X. Aliasing is how loud a 10 kHz tone comes out after it folds down to 6 kHz; lower is better.
+
+| Resampler | Samples per 40 ms chunk (640 expected) | Aliasing | CPU per chunk | Install size |
+|---|---|---|---|---|
+| soxr VHQ | 0 to 1100 | -93 dB | 13.5 µs | 0.5 MB |
+| soxr QQ | 639 to 640 | -3 dB | 6.5 µs | 0.5 MB |
+| samplerate (libsamplerate) `sinc_medium` | 640, first chunk 594 | -100 dB | 198 µs | 1.8 MB |
+| PyAV (FFmpeg) | 640, first chunk 624 | -88 dB | 33.7 µs | 127 MB |
+| Speex resampler, quality 7 | 640 | -100 dB | 26.9 µs | no PyPI binding |
+| **pipecat-resampler** | 640 | -98 dB | 9.1 µs | 0.1 MB |
+
+How each one fits this use:
+
+- **soxr** reaches its quality cheaply by filtering with FFTs over large blocks. Fed small chunks, that means its output arrives in bursts. Its quick setting, QQ, is steady and the fastest option here; it uses cubic interpolation instead of a long filter, so content above the new rate folds back into the speech. soxr is licensed under the LGPL 2.1, and its Linux wheels need glibc 2.27 or later (2.26 on ARM), with none for Alpine.
+- **samplerate** (libsamplerate) is steady after its first chunk and very clean. Its sinc converters compute the filter for each output sample, which handles any ratio and costs about 15 times soxr's CPU here.
+- **PyAV** wraps FFmpeg's resampler, which is steady after its first chunk and fast. It brings FFmpeg along, 127 MB installed, and each call from Python costs about 30 µs whatever the chunk size.
+- **Speex** has a steady, clean resampler. It has no Python binding on PyPI (the `speexdsp` package covers its echo canceller), so we measured the system library through ctypes. It uses about twice soxr's CPU here, and more at 44.1 kHz, where it computes the filter on the fly.
+
+## Performance
+
+Called from Python, in microseconds per chunk, from the same run as the comparison; lower is better.
+
+At 24 → 16 kHz, by chunk size:
+
+| Resampler | 10 ms | 20 ms | 40 ms |
+|---|---|---|---|
+| **pipecat-resampler** | 2.4 | 4.7 | 9.1 |
+| soxr VHQ | 5.7 | 8.1 | 13.5 |
+| soxr QQ | 3.3 | 4.6 | 6.5 |
+| samplerate `sinc_medium` | 55.0 | 103.0 | 198.1 |
+| PyAV | 29.0 | 31.3 | 33.7 |
+| Speex quality 7 | 9.2 | 14.9 | 26.9 |
+
+At 40 ms chunks, the size Pipecat's output transport sends, by rate pair:
+
+| Resampler | 24 → 16 kHz | 24 → 8 kHz | 16 → 8 kHz | 8 → 16 kHz | 48 → 16 kHz | 44.1 → 16 kHz |
+|---|---|---|---|---|---|---|
+| **pipecat-resampler** | 9.2 | 8.6 | 6.1 | 7.9 | 17.0 | 17.0 |
+| soxr VHQ | 13.8 | 9.2 | 6.1 | 6.9 | 15.1 | 18.0 |
+| soxr QQ | 7.0 | 4.8 | 4.6 | 6.9 | 7.2 | 7.1 |
+| samplerate `sinc_medium` | 198.8 | 184.0 | 127.8 | 145.1 | 357.0 | 388.8 |
+| PyAV | 33.5 | 32.8 | 31.8 | 31.2 | 36.0 | 35.6 |
+| Speex quality 7 | 27.4 | 29.7 | 19.6 | 19.0 | 55.5 | 217.3 |
+
+At 24 → 16 kHz, pipecat-resampler is the fastest of the filtered options at every chunk size, and its lead grows as chunks get smaller, because each call costs less. With 40 ms chunks, soxr VHQ is a little faster on 8 → 16 and 48 → 16 kHz, where its multistage FFT design is very cheap. Even pipecat-resampler's slowest case here, 17 µs per 40 ms chunk, is under 0.05% of one core per stream.
+
+Run `uv run python scripts/bench.py` to measure on your machine. It times soxr, and also samplerate, PyAV and the Speex library when they're installed.
+
+## How it works
+
+It's a polyphase Kaiser-windowed sinc filter, the design WebRTC and Speex use. The filter keeps the lower rate's band flat up to 90% of its Nyquist frequency and attenuates aliasing and images by about 90 dB.
+
+Each call works out how many output samples its input is worth and carries any fraction of a sample into the next call. That's what keeps the output steady, for any pair of rates and any chunk size. Instead of holding output back, the filter delays the audio by a few milliseconds; `flush()` returns that delayed end, and `reset()` discards it.
+
+With several channels, the audio is interleaved frames, and each channel is filtered on its own with the same filter. The cost grows with the channel count, so stereo costs twice what mono does.
+
+The inner loop picks the fastest kernel the CPU supports when a resampler is created: AVX2 with FMA or SSE2 on x86-64, NEON on ARM64, and plain C elsewhere. Filter phases with symmetric taps add mirrored samples before multiplying, which halves the multiplications. Set `PIPECAT_RESAMPLER_KERNEL` to `generic`, `sse2`, `avx2` or `neon` to force a kernel.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run python scripts/bench.py
+```
+
+Wheels are built and tested with [cibuildwheel](https://cibuildwheel.pypa.io) on every pull request and every push to `main`.
+
+## License
+
+pipecat-resampler is released under the [BSD 2-Clause License](LICENSE).

pipecat_resampler-0.1.0/README.md

@@ -0,0 +1,113 @@
+# pipecat-resampler
+
+A small C extension for Python that converts 16-bit PCM audio, mono or with interleaved channels, from one sample rate to another, chunk by chunk. It's made for real-time audio, such as voice pipelines built with [Pipecat](https://github.com/pipecat-ai/pipecat). Equal chunks in give equal chunks out: 40 ms of audio in always gives 40 ms out, the first chunk included.
+
+```python
+from pipecat_resampler import Resampler
+
+resampler = Resampler(24000, 16000)
+chunk_16k = resampler.process(chunk_24k)  # bytes in, bytes out
+tail = resampler.flush()  # the audio the filter is delaying
+
+stereo = Resampler(48000, 16000, channels=2)
+frames_16k = stereo.process(frames_48k)  # interleaved frames in and out
+```
+
+## Platforms
+
+The extension uses Python's stable ABI, so one wheel per platform covers Python 3.11 and later.
+
+| Platform | Wheels |
+|---|---|
+| Linux x86-64 and ARM64 | manylinux (glibc 2.17 or later) and musllinux (Alpine 3.13 or later) |
+| macOS | x86-64 and ARM64 |
+| Windows | x86-64 |
+
+## Why it exists
+
+A real-time voice pipeline has to resample whenever its parts run at different rates. WebRTC audio arrives at 48 kHz while a speech recognizer might want 16 kHz, or a TTS voice that only comes at 24 kHz has to go out on an 8 kHz phone call. When that happens, the conversion runs chunk by chunk, every 10 to 40 ms, for every stream the process is handling.
+
+We wanted a resampler built for that:
+
+- **Sinc quality.** A band-limited polyphase sinc filter, flat to 90% of the band, with about 90 dB of aliasing rejection.
+- **Fast.** C with SIMD, so one process can carry many streams at once.
+- **Small.** About 0.1 MB installed, with no runtime dependencies.
+- **Steady output.** The same input size gives the same output size on every call, so nothing downstream has to absorb bursts of audio or wait for audio that's held back.
+- **Low latency.** A fixed delay of a few milliseconds.
+- **Easy to ship.** BSD 2-Clause licensed, like Pipecat, with wheels for Linux (glibc 2.17 or later, and Alpine), macOS and Windows.
+
+Each library we tried covers part of this list, and none covered all of it.
+
+## Comparison
+
+Each resampler converted 24 kHz noise to 16 kHz in 40 ms chunks, called from Python, on an Intel i9-10920X. Aliasing is how loud a 10 kHz tone comes out after it folds down to 6 kHz; lower is better.
+
+| Resampler | Samples per 40 ms chunk (640 expected) | Aliasing | CPU per chunk | Install size |
+|---|---|---|---|---|
+| soxr VHQ | 0 to 1100 | -93 dB | 13.5 µs | 0.5 MB |
+| soxr QQ | 639 to 640 | -3 dB | 6.5 µs | 0.5 MB |
+| samplerate (libsamplerate) `sinc_medium` | 640, first chunk 594 | -100 dB | 198 µs | 1.8 MB |
+| PyAV (FFmpeg) | 640, first chunk 624 | -88 dB | 33.7 µs | 127 MB |
+| Speex resampler, quality 7 | 640 | -100 dB | 26.9 µs | no PyPI binding |
+| **pipecat-resampler** | 640 | -98 dB | 9.1 µs | 0.1 MB |
+
+How each one fits this use:
+
+- **soxr** reaches its quality cheaply by filtering with FFTs over large blocks. Fed small chunks, that means its output arrives in bursts. Its quick setting, QQ, is steady and the fastest option here; it uses cubic interpolation instead of a long filter, so content above the new rate folds back into the speech. soxr is licensed under the LGPL 2.1, and its Linux wheels need glibc 2.27 or later (2.26 on ARM), with none for Alpine.
+- **samplerate** (libsamplerate) is steady after its first chunk and very clean. Its sinc converters compute the filter for each output sample, which handles any ratio and costs about 15 times soxr's CPU here.
+- **PyAV** wraps FFmpeg's resampler, which is steady after its first chunk and fast. It brings FFmpeg along, 127 MB installed, and each call from Python costs about 30 µs whatever the chunk size.
+- **Speex** has a steady, clean resampler. It has no Python binding on PyPI (the `speexdsp` package covers its echo canceller), so we measured the system library through ctypes. It uses about twice soxr's CPU here, and more at 44.1 kHz, where it computes the filter on the fly.
+
+## Performance
+
+Called from Python, in microseconds per chunk, from the same run as the comparison; lower is better.
+
+At 24 → 16 kHz, by chunk size:
+
+| Resampler | 10 ms | 20 ms | 40 ms |
+|---|---|---|---|
+| **pipecat-resampler** | 2.4 | 4.7 | 9.1 |
+| soxr VHQ | 5.7 | 8.1 | 13.5 |
+| soxr QQ | 3.3 | 4.6 | 6.5 |
+| samplerate `sinc_medium` | 55.0 | 103.0 | 198.1 |
+| PyAV | 29.0 | 31.3 | 33.7 |
+| Speex quality 7 | 9.2 | 14.9 | 26.9 |
+
+At 40 ms chunks, the size Pipecat's output transport sends, by rate pair:
+
+| Resampler | 24 → 16 kHz | 24 → 8 kHz | 16 → 8 kHz | 8 → 16 kHz | 48 → 16 kHz | 44.1 → 16 kHz |
+|---|---|---|---|---|---|---|
+| **pipecat-resampler** | 9.2 | 8.6 | 6.1 | 7.9 | 17.0 | 17.0 |
+| soxr VHQ | 13.8 | 9.2 | 6.1 | 6.9 | 15.1 | 18.0 |
+| soxr QQ | 7.0 | 4.8 | 4.6 | 6.9 | 7.2 | 7.1 |
+| samplerate `sinc_medium` | 198.8 | 184.0 | 127.8 | 145.1 | 357.0 | 388.8 |
+| PyAV | 33.5 | 32.8 | 31.8 | 31.2 | 36.0 | 35.6 |
+| Speex quality 7 | 27.4 | 29.7 | 19.6 | 19.0 | 55.5 | 217.3 |
+
+At 24 → 16 kHz, pipecat-resampler is the fastest of the filtered options at every chunk size, and its lead grows as chunks get smaller, because each call costs less. With 40 ms chunks, soxr VHQ is a little faster on 8 → 16 and 48 → 16 kHz, where its multistage FFT design is very cheap. Even pipecat-resampler's slowest case here, 17 µs per 40 ms chunk, is under 0.05% of one core per stream.
+
+Run `uv run python scripts/bench.py` to measure on your machine. It times soxr, and also samplerate, PyAV and the Speex library when they're installed.
+
+## How it works
+
+It's a polyphase Kaiser-windowed sinc filter, the design WebRTC and Speex use. The filter keeps the lower rate's band flat up to 90% of its Nyquist frequency and attenuates aliasing and images by about 90 dB.
+
+Each call works out how many output samples its input is worth and carries any fraction of a sample into the next call. That's what keeps the output steady, for any pair of rates and any chunk size. Instead of holding output back, the filter delays the audio by a few milliseconds; `flush()` returns that delayed end, and `reset()` discards it.
+
+With several channels, the audio is interleaved frames, and each channel is filtered on its own with the same filter. The cost grows with the channel count, so stereo costs twice what mono does.
+
+The inner loop picks the fastest kernel the CPU supports when a resampler is created: AVX2 with FMA or SSE2 on x86-64, NEON on ARM64, and plain C elsewhere. Filter phases with symmetric taps add mirrored samples before multiplying, which halves the multiplications. Set `PIPECAT_RESAMPLER_KERNEL` to `generic`, `sse2`, `avx2` or `neon` to force a kernel.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run python scripts/bench.py
+```
+
+Wheels are built and tested with [cibuildwheel](https://cibuildwheel.pypa.io) on every pull request and every push to `main`.
+
+## License
+
+pipecat-resampler is released under the [BSD 2-Clause License](LICENSE).

pipecat_resampler-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pipecat-resampler"
+version = "0.1.0"
+description = "Streaming audio resampler whose output keeps pace with its input"
+license = "BSD-2-Clause"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["audio", "resampling", "real-time", "voice"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: C",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Sound/Audio :: Conversion",
+]
+dependencies = []
+
+[project.urls]
+Source = "https://github.com/pipecat-ai/pipecat-resampler"
+Issues = "https://github.com/pipecat-ai/pipecat-resampler/issues"
+
+[dependency-groups]
+dev = ["pytest>=8", "numpy>=1.26", "soxr>=1.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+pipecat_resampler = ["py.typed", "*.pyi"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.cibuildwheel]
+# The extension uses the stable ABI, so a cp311 wheel serves every later Python.
+build = "cp311-*"
+skip = "*-win32 *-manylinux_i686 *-musllinux_i686"
+test-requires = ["pytest", "numpy"]
+test-command = "pytest {project}/tests"
+
+[tool.cibuildwheel.macos]
+archs = ["x86_64", "arm64"]
+
+# Tag the glibc wheels for the oldest glibc they run on, 2.17, and nothing newer.
+[[tool.cibuildwheel.overrides]]
+select = "*-manylinux_x86_64"
+repair-wheel-command = "auditwheel repair --plat manylinux_2_17_x86_64 --only-plat -w {dest_dir} {wheel}"
+
+[[tool.cibuildwheel.overrides]]
+select = "*-manylinux_aarch64"
+repair-wheel-command = "auditwheel repair --plat manylinux_2_17_aarch64 --only-plat -w {dest_dir} {wheel}"

pipecat_resampler-0.1.0/scripts/bench.py

@@ -0,0 +1,178 @@
+#
+# Copyright (c) 2026, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Time pipecat-resampler against other streaming resamplers, called from Python.
+
+Prints microseconds per chunk, median of five runs: first at 24 -> 16 kHz by chunk
+size, then by rate pair at 40 ms chunks, the size Pipecat's output transport sends.
+soxr is a dev dependency; samplerate, PyAV and the Speex library are measured when
+they're installed.
+"""
+
+import ctypes
+import ctypes.util
+import statistics
+import time
+
+import numpy as np
+import soxr
+
+from pipecat_resampler import Resampler
+
+PAIRS = [
+    (24000, 16000),
+    (24000, 8000),
+    (16000, 8000),
+    (8000, 16000),
+    (48000, 16000),
+    (44100, 16000),
+]
+
+
+def pipecat_resampler(i, o):
+    process = Resampler(i, o).process
+    return lambda x: process(x.tobytes())
+
+
+def soxr_vhq(i, o):
+    return soxr.ResampleStream(i, o, 1, dtype="int16", quality="VHQ").resample_chunk
+
+
+def soxr_qq(i, o):
+    return soxr.ResampleStream(i, o, 1, dtype="int16", quality="QQ").resample_chunk
+
+
+def samplerate_medium(i, o):
+    import samplerate
+
+    r = samplerate.Resampler("sinc_medium", channels=1)
+    ratio = o / i
+
+    def run(x):
+        y = r.process(x.astype(np.float32) * (1 / 32768), ratio)
+        return np.clip(np.round(y * 32768), -32768, 32767).astype(np.int16)
+
+    return run
+
+
+def pyav(i, o):
+    import av
+
+    r = av.AudioResampler(format="s16", layout="mono", rate=o)
+
+    def run(x):
+        frame = av.AudioFrame.from_ndarray(x.reshape(1, -1), format="s16", layout="mono")
+        frame.sample_rate = i
+        return [f.to_ndarray() for f in r.resample(frame)]
+
+    return run
+
+
+def speex_q7(i, o):
+    path = ctypes.util.find_library("speexdsp")
+    if not path:
+        raise OSError("libspeexdsp isn't installed")
+    lib = ctypes.CDLL(path)
+    lib.speex_resampler_init.restype = ctypes.c_void_p
+    lib.speex_resampler_init.argtypes = [
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.c_uint32,
+        ctypes.c_int,
+        ctypes.POINTER(ctypes.c_int),
+    ]
+    lib.speex_resampler_process_int.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_uint32,
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint32),
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint32),
+    ]
+    err = ctypes.c_int(0)
+    state = lib.speex_resampler_init(1, i, o, 7, ctypes.byref(err))
+    out = np.zeros(o, dtype=np.int16)
+    in_len, out_len = ctypes.c_uint32(), ctypes.c_uint32()
+
+    def run(x):
+        in_len.value, out_len.value = len(x), len(out)
+        lib.speex_resampler_process_int(
+            state, 0, x.ctypes.data, ctypes.byref(in_len), out.ctypes.data, ctypes.byref(out_len)
+        )
+        return out[: out_len.value].copy()
+
+    return run
+
+
+def available():
+    candidates = {
+        "pipecat-resampler": pipecat_resampler,
+        "soxr VHQ": soxr_vhq,
+        "soxr QQ": soxr_qq,
+        "samplerate sinc_medium": samplerate_medium,
+        "PyAV": pyav,
+        "Speex quality 7": speex_q7,
+    }
+    found = {}
+    for name, make in candidates.items():
+        try:
+            make(24000, 16000)(np.zeros(960, dtype=np.int16))
+        except Exception:
+            continue
+        found[name] = make
+    return found
+
+
+def per_chunk_us(make, i, o, ms):
+    rng = np.random.default_rng(0)
+    parts = [(rng.standard_normal(i * ms // 1000) * 8000).astype(np.int16) for _ in range(500)]
+    # An untimed pass first, so the CPU and caches are warm for every resampler.
+    warm_up = make(i, o)
+    for p in parts:
+        warm_up(p)
+    runs = []
+    for _ in range(5):
+        process = make(i, o)
+        start = time.perf_counter()
+        for p in parts:
+            process(p)
+        runs.append((time.perf_counter() - start) / len(parts) * 1e6)
+    return statistics.median(runs)
+
+
+def table(header, rows):
+    print("| " + " | ".join(header) + " |")
+    print("|" + "---|" * len(header))
+    for row in rows:
+        print("| " + " | ".join(row) + " |")
+
+
+def main():
+    resamplers = available()
+    print(f"pipecat-resampler kernel: {Resampler(24000, 16000).kernel}\n")
+
+    print("24 -> 16 kHz, µs per chunk\n")
+    sizes = (10, 20, 40)
+    table(
+        ["Resampler"] + [f"{ms} ms" for ms in sizes],
+        [
+            [name] + [f"{per_chunk_us(make, 24000, 16000, ms):.1f}" for ms in sizes]
+            for name, make in resamplers.items()
+        ],
+    )
+
+    print("\n40 ms chunks, µs per chunk\n")
+    table(
+        ["Resampler"] + [f"{i / 1000:g} -> {o / 1000:g} kHz" for i, o in PAIRS],
+        [
+            [name] + [f"{per_chunk_us(make, i, o, 40):.1f}" for i, o in PAIRS]
+            for name, make in resamplers.items()
+        ],
+    )
+
+
+if __name__ == "__main__":
+    main()

pipecat_resampler-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pipecat_resampler-0.1.0/setup.py

@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2026, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Builds the C extension on the stable ABI, one wheel per platform for Python 3.11+."""
+
+import sys
+
+from setuptools import Extension, setup
+
+if sys.platform == "win32":
+    compile_args = ["/O2"]
+    libraries = []
+else:
+    compile_args = ["-O3", "-fvisibility=hidden", "-std=c11"]
+    libraries = ["m"]
+
+setup(
+    ext_modules=[
+        Extension(
+            "pipecat_resampler._resampler",
+            sources=["src/pipecat_resampler/_resampler.c", "src/pipecat_resampler/_kernel.c"],
+            define_macros=[("Py_LIMITED_API", "0x030B0000")],
+            py_limited_api=True,
+            extra_compile_args=compile_args,
+            libraries=libraries,
+        )
+    ],
+    options={"bdist_wheel": {"py_limited_api": "cp311"}},
+)

pipecat_resampler-0.1.0/src/pipecat_resampler/__init__.py

@@ -0,0 +1,11 @@
+#
+# Copyright (c) 2026, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Streaming audio resampler whose output keeps pace with its input."""
+
+from pipecat_resampler._resampler import Resampler
+
+__all__ = ["Resampler"]