axio-audio 0.9.2__tar.gz

axio_audio-0.9.2/.gitignore

@@ -0,0 +1,14 @@
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+_build/
+.DS_Store
+*.sqlite
+*.db

axio_audio-0.9.2/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: axio-audio
+Version: 0.9.2
+Summary: Microphone and speaker helpers for Axio realtime agents
+Project-URL: Documentation, https://docs.axio-agent.com
+Project-URL: Homepage, https://github.com/mosquito/axio-agent
+Project-URL: Repository, https://github.com/mosquito/axio-agent
+License: MIT
+Keywords: agent,ai,audio,llm,realtime,sounddevice
+Requires-Python: >=3.12
+Requires-Dist: axio
+Requires-Dist: numpy>=2
+Requires-Dist: sounddevice>=0.5

axio_audio-0.9.2/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "axio-audio"
+version = "0.9.2"
+description = "Microphone and speaker helpers for Axio realtime agents"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+keywords = ["llm", "agent", "ai", "audio", "realtime", "sounddevice"]
+dependencies = ["axio", "sounddevice>=0.5", "numpy>=2"]
+
+[project.urls]
+Documentation = "https://docs.axio-agent.com"
+Homepage = "https://github.com/mosquito/axio-agent"
+Repository = "https://github.com/mosquito/axio-agent"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/axio_audio"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 119
+output-format = "concise"
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.mypy]
+strict = true
+python_version = "3.12"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "mypy>=1.14",
+    "ruff>=0.9",
+    "pytest-cov>=7.1.0",
+]

axio_audio-0.9.2/src/axio_audio/__init__.py

@@ -0,0 +1,7 @@
+"""Microphone and speaker helpers for axio realtime agents."""
+
+from .duplex import DuplexAudio
+from .microphone import Microphone
+from .speaker import Speaker
+
+__all__ = ["DuplexAudio", "Microphone", "Speaker"]

axio_audio-0.9.2/src/axio_audio/duplex.py

@@ -0,0 +1,291 @@
+"""Sample-aligned duplex audio: one PortAudio stream, one callback, one clock.
+
+``Microphone`` and ``Speaker`` open independent ``sd.RawInputStream`` and
+``sd.RawOutputStream`` instances — each on its own PortAudio host clock.
+On most consumer audio stacks (PipeWire/PulseAudio over ALSA) those two
+clocks drift by tens of ppm relative to each other, accumulating
+~10–25 ms/sec of skew between captured mic samples and played speaker
+samples.  Echo cancellers — Speex linear AEC, AEC3, anything — depend on
+the relative timing of the far-end reference (speaker output) and the
+near-end signal (mic input).  Drift past the algorithm's filter / search
+window destroys cancellation quality after only a few minutes of
+continuous use.
+
+``DuplexAudio`` opens **one** ``sd.RawStream`` with both directions
+hooked into a single callback.  Mic and speaker share the same
+PortAudio clock; relative timing is sample-exact for the lifetime of
+the stream.  This is the same architecture PipeWire's
+``module-echo-cancel`` uses internally and is what lets in-process
+AEC3 reach production-grade suppression without an external graph.
+
+Usage mirrors the ``Microphone`` / ``Speaker`` pair so callers can
+swap with minimal change::
+
+    async with DuplexAudio(sample_rate=48000) as duplex:
+        async def consume_mic() -> None:
+            async for chunk in duplex.mic_chunks():
+                await agent.send(chunk)
+
+        async def play_audio_output() -> None:
+            async for ev in agent.events():
+                if isinstance(ev, AudioOutputDelta):
+                    await duplex.feed_speaker(ev.data)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Any, Self
+
+import numpy as np
+import sounddevice as sd  # type: ignore[import-untyped]
+from axio.blocks import AudioBlock
+
+
+@dataclass
+class DuplexAudio:
+    """One sd.RawStream, both directions, sample-aligned by PortAudio.
+
+    The callback runs on PortAudio's audio thread for every block of
+    ``chunk_ms`` worth of frames; it (a) pulls the next chunk of
+    speaker bytes out of an internal buffer into ``outdata`` and (b)
+    forwards ``indata`` to a thread-safe queue that the asyncio side
+    drains via :meth:`mic_chunks`.
+
+    ``channels`` is how many channels we open the **device** with.  On
+    a stereo-only device (e.g. PipeWire's ``Echo-Cancel Sink/Source``,
+    or most laptop default outputs) you must set ``channels=2`` to
+    drive both speakers correctly.  The ``feed_speaker`` /
+    ``mic_chunks`` API itself is mono — ``feed_speaker`` upmixes by
+    duplicating samples across channels and ``mic_chunks`` downmixes by
+    averaging.  Set ``mono_io=False`` to skip the conversions and
+    pass interleaved PCM through unchanged.
+    """
+
+    sample_rate: int = 48000
+    chunk_ms: int = 20
+    channels: int = 1
+    device: int | str | tuple[int | str | None, int | str | None] | None = None
+    mono_io: bool = True
+    queue_maxsize: int = 100
+    playback_tap: Callable[[bytes], None] | None = None
+    """Optional sync callback fired from the audio thread with the *mono*
+    bytes we just handed to the speaker (silence-padded when the buffer
+    underruns).  Useful as a far-end reference for an external AEC, or
+    for level meters that need real playback timing rather than enqueue
+    timing.  Receives the same bytes the mono ``feed_speaker`` API
+    accepts, so it's symmetric with ``mic_chunks``."""
+
+    _stream: sd.RawStream | None = field(default=None, init=False, repr=False)
+    _mic_queue: asyncio.Queue[bytes] | None = field(default=None, init=False, repr=False)
+    _spk_buffer: bytearray = field(default_factory=bytearray, init=False, repr=False)
+    _lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False)
+    _loop: asyncio.AbstractEventLoop | None = field(default=None, init=False, repr=False)
+
+    async def __aenter__(self) -> Self:
+        self._loop = asyncio.get_running_loop()
+        self._mic_queue = asyncio.Queue(maxsize=self.queue_maxsize)
+        loop = self._loop
+        queue = self._mic_queue
+        ch = self.channels
+        bytes_per_device_sample = 2 * ch
+
+        def callback(
+            indata: Any,
+            outdata: Any,
+            frames: int,
+            time_info: Any,
+            status: sd.CallbackFlags,
+        ) -> None:
+            wanted = frames * bytes_per_device_sample
+            with self._lock:
+                # ``_spk_buffer`` is laid out for the device (multi-channel
+                # if ch > 1, see ``feed_speaker``).  Copy what we have, pad
+                # with silence on underflow so the device never starves.
+                available = len(self._spk_buffer)
+                n = min(wanted, available)
+                if n:
+                    outdata[:n] = bytes(self._spk_buffer[:n])
+                    del self._spk_buffer[:n]
+            if n < wanted:
+                outdata[n:wanted] = b"\x00" * (wanted - n)
+
+            mono_far: bytes
+            mono_near: bytes
+            if self.mono_io and ch > 1:
+                mono_far = (
+                    np.frombuffer(bytes(outdata[:wanted]), dtype="<i2")
+                    .reshape(-1, ch)
+                    .mean(axis=1)
+                    .astype("<i2")
+                    .tobytes()
+                )
+                mono_near = (
+                    np.frombuffer(bytes(indata), dtype="<i2").reshape(-1, ch).mean(axis=1).astype("<i2").tobytes()
+                )
+            else:
+                mono_far = bytes(outdata[:wanted])
+                mono_near = bytes(indata)
+
+            # Tap fires before the mic-queue push so the consumer can
+            # use it as a perfectly time-aligned far reference.  Cheap
+            # ops only — this is the audio thread.
+            if self.playback_tap is not None:
+                try:
+                    self.playback_tap(mono_far)
+                except Exception:
+                    # Don't propagate — a buggy tap shouldn't kill audio.
+                    pass
+
+            loop.call_soon_threadsafe(_put_or_drop, queue, mono_near)
+
+        chunk_frames = max(1, self.sample_rate * self.chunk_ms // 1000)
+        self._stream = sd.RawStream(
+            samplerate=self.sample_rate,
+            channels=(ch, ch),
+            dtype="int16",
+            blocksize=chunk_frames,
+            device=self.device,
+            callback=callback,
+        )
+        self._stream.start()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        if self._stream is not None:
+            self._stream.stop()
+            self._stream.close()
+            self._stream = None
+        if self._mic_queue is not None:
+            # Same evict-then-sentinel dance Microphone uses: don't deadlock
+            # close on a slow consumer.
+            try:
+                self._mic_queue.put_nowait(b"")
+            except asyncio.QueueFull:
+                self._mic_queue.get_nowait()
+                self._mic_queue.put_nowait(b"")
+
+    # ── mic side ─────────────────────────────────────────────────────
+
+    def mic_chunks(self) -> AsyncIterator[AudioBlock]:
+        """Async-iterate captured mic data as :class:`AudioBlock` chunks.
+
+        Chunk size is whatever PortAudio hands the callback (typically
+        ``chunk_ms`` worth of frames).  Yields mono PCM16 when
+        ``mono_io`` is True, otherwise interleaved as opened.
+        """
+        return _MicChunks(self)
+
+    # ── speaker side ─────────────────────────────────────────────────
+
+    async def feed_speaker(self, pcm: bytes) -> None:
+        """Append PCM16 to the speaker buffer.
+
+        Input is mono when ``mono_io`` is True (samples are duplicated
+        across channels for the device), otherwise must be in the
+        device's exact channel layout.
+        """
+        if not pcm:
+            return
+        if self.mono_io and self.channels > 1:
+            mono = np.frombuffer(pcm, dtype="<i2")
+            interleaved = np.repeat(mono, self.channels).tobytes()
+        else:
+            interleaved = pcm
+        with self._lock:
+            self._spk_buffer.extend(interleaved)
+
+    async def stop_speaker(self) -> None:
+        """Drop everything queued for playback (use on user interruption)."""
+        with self._lock:
+            self._spk_buffer.clear()
+
+    def speaker_pending_bytes(self) -> int:
+        """Mono-equivalent bytes still waiting to be played."""
+        with self._lock:
+            n = len(self._spk_buffer)
+        if self.mono_io and self.channels > 1:
+            return n // self.channels
+        return n
+
+    # ── Microphone / Speaker compatibility views ─────────────────────
+    # Existing realtime examples are built around the ``Microphone`` and
+    # ``Speaker`` classes; ``duplex.mic`` / ``duplex.speaker`` expose the
+    # same surface (async-iter on the mic, ``feed`` / ``stop`` /
+    # ``pending_bytes`` on the speaker) so callers can swap to duplex
+    # by replacing two ``async with`` arms with one.
+
+    @property
+    def mic(self) -> _MicView:
+        return _MicView(self)
+
+    @property
+    def speaker(self) -> _SpeakerView:
+        return _SpeakerView(self)
+
+
+class _MicView:
+    """Quacks like :class:`Microphone` — async-iterable of AudioBlocks."""
+
+    __slots__ = ("_duplex",)
+
+    def __init__(self, duplex: DuplexAudio) -> None:
+        self._duplex = duplex
+
+    def __aiter__(self) -> _MicChunks:
+        return _MicChunks(self._duplex)
+
+
+class _SpeakerView:
+    """Quacks like :class:`Speaker` — feed/stop/pending_bytes."""
+
+    __slots__ = ("_duplex",)
+
+    def __init__(self, duplex: DuplexAudio) -> None:
+        self._duplex = duplex
+
+    async def feed(self, pcm: bytes) -> None:
+        await self._duplex.feed_speaker(pcm)
+
+    async def stop(self) -> None:
+        await self._duplex.stop_speaker()
+
+    def pending_bytes(self) -> int:
+        return self._duplex.speaker_pending_bytes()
+
+
+class _MicChunks:
+    """Lightweight iterator wrapper so callers don't accidentally exhaust
+    the duplex object itself."""
+
+    __slots__ = ("_duplex",)
+
+    def __init__(self, duplex: DuplexAudio) -> None:
+        self._duplex = duplex
+
+    def __aiter__(self) -> _MicChunks:
+        return self
+
+    async def __anext__(self) -> AudioBlock:
+        if self._duplex._mic_queue is None:
+            raise RuntimeError("DuplexAudio not started — use 'async with DuplexAudio() as d:'.")
+        chunk = await self._duplex._mic_queue.get()
+        if not chunk:
+            raise StopAsyncIteration
+        return AudioBlock(media_type="audio/pcm", data=chunk)
+
+
+def _put_or_drop(queue: asyncio.Queue[bytes], data: bytes) -> None:
+    try:
+        queue.put_nowait(data)
+    except asyncio.QueueFull:
+        pass

axio_audio-0.9.2/src/axio_audio/microphone.py

@@ -0,0 +1,99 @@
+"""Microphone capture: yields :class:`AudioBlock` chunks from the system microphone."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Any, Self
+
+import sounddevice as sd  # type: ignore[import-untyped]
+from axio.blocks import AudioBlock
+
+
+@dataclass
+class Microphone:
+    """Async-iterable wrapper around a sounddevice ``RawInputStream``.
+
+    Captures PCM16 mono audio at ``sample_rate`` and yields
+    :class:`AudioBlock` chunks of approximately ``chunk_ms`` milliseconds
+    each.  The defaults match the OpenAI Realtime API (24 kHz PCM16).
+
+    Usage::
+
+        async with Microphone() as mic:
+            async for chunk in mic:
+                await agent.send(chunk)
+    """
+
+    sample_rate: int = 24000
+    chunk_ms: int = 50
+    device: int | str | None = None
+    queue_maxsize: int = 100  # cap to avoid unbounded growth on slow consumers
+    _stream: sd.RawInputStream | None = field(default=None, init=False, repr=False)
+    _queue: asyncio.Queue[bytes] | None = field(default=None, init=False, repr=False)
+    _loop: asyncio.AbstractEventLoop | None = field(default=None, init=False, repr=False)
+
+    async def __aenter__(self) -> Self:
+        self._loop = asyncio.get_running_loop()
+        self._queue = asyncio.Queue(maxsize=self.queue_maxsize)
+        chunk_frames = max(1, self.sample_rate * self.chunk_ms // 1000)
+        loop = self._loop
+        queue = self._queue
+
+        def callback(indata: Any, frames: int, time_info: Any, status: sd.CallbackFlags) -> None:
+            data = bytes(indata)
+            loop.call_soon_threadsafe(_put_or_drop, queue, data)
+
+        self._stream = sd.RawInputStream(
+            samplerate=self.sample_rate,
+            channels=1,
+            dtype="int16",
+            blocksize=chunk_frames,
+            device=self.device,
+            callback=callback,
+        )
+        self._stream.start()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        if self._stream is not None:
+            self._stream.stop()
+            self._stream.close()
+            self._stream = None
+        if self._queue is not None:
+            # Stream is now stopped, so the callback won't push more.  Push the
+            # sentinel non-blockingly and evict the oldest chunk if the queue
+            # is full — a blocking ``put`` here would deadlock close when the
+            # consumer has already stopped draining.
+            try:
+                self._queue.put_nowait(b"")
+            except asyncio.QueueFull:
+                self._queue.get_nowait()
+                self._queue.put_nowait(b"")
+
+    def __aiter__(self) -> AsyncIterator[AudioBlock]:
+        return self
+
+    async def __anext__(self) -> AudioBlock:
+        if self._queue is None:
+            raise RuntimeError("Microphone not started — use 'async with Microphone() as mic:'.")
+        chunk = await self._queue.get()
+        if not chunk:
+            raise StopAsyncIteration
+        return AudioBlock(media_type="audio/pcm", data=chunk)
+
+
+def _put_or_drop(queue: asyncio.Queue[bytes], data: bytes) -> None:
+    """Push ``data`` into ``queue``; silently drop if full to keep the audio
+    callback non-blocking under back-pressure."""
+    try:
+        queue.put_nowait(data)
+    except asyncio.QueueFull:
+        pass

axio_audio-0.9.2/src/axio_audio/py.typed

@@ -0,0 +1 @@
+

axio_audio-0.9.2/src/axio_audio/speaker.py

@@ -0,0 +1,94 @@
+"""Speaker playback: consumes PCM16 chunks and plays them through the default output device."""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Any, Self
+
+import sounddevice as sd  # type: ignore[import-untyped]
+
+
+@dataclass
+class Speaker:
+    """Async-friendly wrapper around a sounddevice ``RawOutputStream``.
+
+    Holds an internal byte buffer; ``feed()`` appends, the audio callback
+    drains as the device asks for samples.  ``stop()`` clears the buffer
+    (use it to honour user interruptions — drops everything still queued
+    so the assistant goes silent immediately).
+
+    Usage::
+
+        async with Speaker() as spk:
+            async for ev in agent.events():
+                if isinstance(ev, AudioOutputDelta):
+                    await spk.feed(ev.data)
+    """
+
+    sample_rate: int = 24000
+    device: int | str | None = None
+    playback_tap: Callable[[bytes], None] | None = None
+    """Optional callback invoked from the audio thread with each chunk that
+    is actually being played.  Useful as the far-end reference for an echo
+    canceller — the timing here matches what hits the speaker driver, not
+    when the application called :meth:`feed`."""
+
+    _stream: sd.RawOutputStream | None = field(default=None, init=False, repr=False)
+    _buffer: bytearray = field(default_factory=bytearray, init=False, repr=False)
+    _lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False)
+
+    def _callback(self, outdata: Any, frames: int, time_info: Any, status: sd.CallbackFlags) -> None:
+        wanted = frames * 2  # int16 mono = 2 bytes per frame
+        with self._lock:
+            available = len(self._buffer)
+            n = min(wanted, available)
+            if n:
+                outdata[:n] = bytes(self._buffer[:n])
+                del self._buffer[:n]
+        if n < wanted:
+            # Pad with silence so the device never starves.
+            outdata[n:wanted] = b"\x00" * (wanted - n)
+        # Notify the tap with exactly what hit the device this tick — including
+        # any silence padding — so the consumer's clock matches real playback.
+        if self.playback_tap is not None:
+            self.playback_tap(bytes(outdata[:wanted]))
+
+    async def __aenter__(self) -> Self:
+        self._stream = sd.RawOutputStream(
+            samplerate=self.sample_rate,
+            channels=1,
+            dtype="int16",
+            device=self.device,
+            callback=self._callback,
+        )
+        self._stream.start()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        if self._stream is not None:
+            self._stream.stop()
+            self._stream.close()
+            self._stream = None
+
+    async def feed(self, pcm: bytes) -> None:
+        """Append PCM16 mono bytes to the playback buffer."""
+        with self._lock:
+            self._buffer.extend(pcm)
+
+    async def stop(self) -> None:
+        """Drop everything queued for playback (user interrupted)."""
+        with self._lock:
+            self._buffer.clear()
+
+    def pending_bytes(self) -> int:
+        """Bytes still waiting to be played — useful for back-pressure decisions."""
+        with self._lock:
+            return len(self._buffer)

axio_audio-0.9.2/tests/test_microphone.py

@@ -0,0 +1,49 @@
+"""Tests for Microphone helpers that don't require an actual audio device."""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from axio_audio.microphone import Microphone, _put_or_drop
+
+
+async def test_put_or_drop_pushes_when_space_available() -> None:
+    queue: asyncio.Queue[bytes] = asyncio.Queue(maxsize=2)
+    _put_or_drop(queue, b"a")
+    _put_or_drop(queue, b"b")
+    assert queue.qsize() == 2
+    assert await queue.get() == b"a"
+    assert await queue.get() == b"b"
+
+
+async def test_put_or_drop_silently_drops_when_full() -> None:
+    queue: asyncio.Queue[bytes] = asyncio.Queue(maxsize=1)
+    _put_or_drop(queue, b"a")
+    _put_or_drop(queue, b"dropped")  # full — must not raise
+    assert queue.qsize() == 1
+    assert await queue.get() == b"a"
+
+
+async def test_close_does_not_hang_when_queue_full_and_no_consumer() -> None:
+    """Regression: ``__aexit__`` used to ``await put(sentinel)`` which deadlocks
+    if the consumer has already stopped draining and the queue is at capacity.
+    Closing must complete promptly and leave the sentinel in the queue."""
+    mic = Microphone(queue_maxsize=2)
+    mic._queue = asyncio.Queue(maxsize=2)
+    mic._queue.put_nowait(b"chunk1")
+    mic._queue.put_nowait(b"chunk2")  # queue is full, no one is draining
+
+    await asyncio.wait_for(mic.__aexit__(None, None, None), timeout=1.0)
+
+    drained: list[bytes] = []
+    while not mic._queue.empty():
+        drained.append(mic._queue.get_nowait())
+    assert b"" in drained, "sentinel must be present after close"
+
+
+async def test_anext_raises_before_aenter() -> None:
+    mic = Microphone()
+    with pytest.raises(RuntimeError):
+        await mic.__anext__()

axio_audio-0.9.2/tests/test_speaker.py

@@ -0,0 +1,51 @@
+"""Tests for Speaker buffer semantics — exercise the callback directly without
+actually opening an audio device."""
+
+from __future__ import annotations
+
+import pytest
+
+from axio_audio.speaker import Speaker
+
+
+@pytest.fixture
+def speaker() -> Speaker:
+    return Speaker()
+
+
+def test_callback_drains_buffer(speaker: Speaker) -> None:
+    pcm = bytes(range(20))  # 10 int16 frames
+    speaker._buffer.extend(pcm)
+    out = bytearray(20)
+    speaker._callback(out, frames=10, time_info=None, status=0)
+    assert bytes(out) == pcm
+    assert len(speaker._buffer) == 0
+
+
+def test_callback_pads_with_silence_when_underflowing(speaker: Speaker) -> None:
+    speaker._buffer.extend(b"\x01\x02\x03\x04")  # 2 frames of audio
+    out = bytearray(20)  # caller wants 10 frames = 20 bytes
+    speaker._callback(out, frames=10, time_info=None, status=0)
+    assert bytes(out[:4]) == b"\x01\x02\x03\x04"
+    assert bytes(out[4:]) == b"\x00" * 16
+
+
+def test_callback_only_consumes_requested_frames(speaker: Speaker) -> None:
+    speaker._buffer.extend(bytes(range(40)))
+    out = bytearray(10)
+    speaker._callback(out, frames=5, time_info=None, status=0)
+    assert bytes(out) == bytes(range(10))
+    assert len(speaker._buffer) == 30  # remainder still queued
+
+
+async def test_feed_appends_bytes(speaker: Speaker) -> None:
+    await speaker.feed(b"\xaa\xbb")
+    await speaker.feed(b"\xcc\xdd")
+    assert bytes(speaker._buffer) == b"\xaa\xbb\xcc\xdd"
+
+
+async def test_stop_clears_buffer(speaker: Speaker) -> None:
+    await speaker.feed(b"\xff" * 100)
+    assert speaker.pending_bytes() == 100
+    await speaker.stop()
+    assert speaker.pending_bytes() == 0