rushaudio 1.1.0__tar.gz

rushaudio-1.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: rushaudio
+Version: 1.1.0
+Summary: Low-latency audio over IP live streaming protocol (Python port)
+Author: RushAudio Contributors
+License: MIT
+Project-URL: Repository, https://github.com/OseMine/rushaudio
+Keywords: audio,streaming,low-latency,protocol,udp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# RushAudio — Python port
+
+A pure-Python, zero-dependency implementation of the [RushAudio](https://github.com/OseMine/rushaudio) protocol: a **binary protocol for low-latency audio streaming over UDP**.
+
+This port mirrors the public API and wire format of the Rust reference implementation, so it is interoperable byte-for-byte on the wire.
+
+| Property | Value |
+|----------|-------|
+| Transport | UDP (default port 4210) |
+| Header size | 14 bytes |
+| Max payload | 4096 bytes |
+| Latency target | 30–100ms |
+| Loss recovery | XOR FEC (recovers 1 loss per group) |
+| Codecs | Opus, PCM S16LE, A-law, μ-law |
+| Metadata | TLV key-value pairs (built-in + custom) |
+| Byte order | Big-endian (except PCM samples: little-endian) |
+| Python | ≥ 3.9, standard library only |
+
+## Install
+
+```bash
+pip install rushaudio            # from PyPI (once published)
+# or build/install from source:
+cd ports/python
+python -m pip wheel . -w dist    # -> dist/rushaudio-1.1.0-py3-none-any.whl
+pip install dist/rushaudio-1.1.0-py3-none-any.whl
+```
+
+## Quick start
+
+```python
+import rushaudio
+from rushaudio.prelude import *
+
+server = rushaudio.create_server("0.0.0.0:4210")   # receiver
+client = rushaudio.create_client()                 # sender
+peer = "127.0.0.1:4210"
+
+# Encode/decode an audio frame (AudioData payload, spec §4.1)
+payload = Packet.encode_audio_payload(2, 48000, AudioCodec.OPUS, opus_bytes)
+pkt = Packet.new(PacketType.AUDIO_DATA, seq=1, ts=0, payload=payload)
+client.send_packet(pkt, peer)
+
+got = server.recv_packet()          # non-blocking: None if nothing available
+if got is not None:
+    packet, addr = got
+    ch, sr, codec, frame = Packet.decode_audio_payload(packet.payload)
+```
+
+## Metadata (TLV)
+
+```python
+meta = (
+    MetadataBuilder()
+    .track_title("My Song")
+    .artist("Artist Name")
+    .album("Album")
+    .sample_rate(48000)
+    .channels(2)
+    .codec_info("Opus")
+    .bitrate(128000)
+    .custom(0x80, b"app-specific-data")
+    .build()
+)
+client.send_packet(meta.to_packet(seq=2, ts=20), peer)
+
+received = Metadata.from_packet(packet)          # on the other side
+title = received.get_string(META_TRACK_TITLE)    # -> "My Song"
+```
+
+## Handshake
+
+```python
+config = StreamConfig(sample_rate=48000, channels=2, bitrate=128000, codec=AudioCodec.OPUS)
+hs = Handshake(role=HandshakeRole.INITIATOR, ssrc=12345, config=config)
+client.send_packet(hs.build_request(0, 0), peer)
+
+# server side:
+got = server.recv_packet()
+remote_ssrc, cfg = Handshake.parse_request(got[0])
+responder = Handshake(role=HandshakeRole.RESPONDER, ssrc=67890, config=cfg)
+server.send_packet(responder.build_response(0, 0, accepted=True), got[1])
+```
+
+## FEC recovery
+
+```python
+group = [pkt1, pkt2, pkt3]                      # original AudioData packets
+repair = FecEncoder.generate_repair(group, seq=100, ts=0)
+client.send_packet(repair, peer)
+
+# receiver, having lost pkt2 of the group:
+recovered = FecEncoder.try_recover(repair, [pkt1, pkt3])   # -> (2, b"...")
+```
+
+## Jitter buffer
+
+```python
+jb = JitterBuffer()                     # 80ms target delay
+jb.push(seq, ts, payload_bytes)         # inserts in sequence order
+out = jb.pop()                          # (ts, payload) once aged, else None
+jb.adapt_delay()                        # clamp(2*jitter + 10ms, 20ms, 400ms)
+stats = jb.stats()                      # depth, dropped, late, jitter
+```
+
+## Wire / raw bytes
+
+```python
+wire = pkt.encode()                 # header + payload, 14+N bytes
+parsed = Packet.decode(wire)        # raises PacketError subclasses on invalid data
+```
+
+`UdpTransport.recv_packet()` returns `(Packet, (host, port))` or `None` when
+nothing is available (non-blocking). Non-parseable datagrams are skipped.
+
+## Layout
+
+```
+ports/python/
+├── pyproject.toml
+├── rushaudio/
+│   ├── __init__.py      # public API: create_server / create_client / DEFAULT_PORT
+│   ├── prelude.py       # from rushaudio.prelude import *
+│   ├── constants.py     # magic, metadata keys, timing, FEC/level constants
+│   ├── types.py         # PacketType, AudioCodec, StreamConfig, StreamStats
+│   ├── packet.py        # 14-byte header, Packet encode/decode, errors
+│   ├── metadata.py      # Metadata / MetadataBuilder TLV codec
+│   ├── levels.py        # AudioLevels (VU meter) packet type
+│   ├── fec.py           # XOR FEC encode + single-loss recovery
+│   ├── jitter.py        # adaptive jitter buffer
+│   ├── handshake.py     # handshake state machine + payload builders
+│   ├── transport.py     # non-blocking UdpTransport
+│   ├── connection.py    # Connection + bounded ConnectionPool
+│   └── session.py       # SessionManager (keepalive, stale sweeping)
+└── tests/
+    └── test_protocol.py # 37 tests (mirrors tests/integration.rs)
+```
+
+## Running the tests
+
+```bash
+cd ports/python
+python -m unittest discover -s tests -v    # 37 tests, stdlib only
+```
+
+## Parity with the Rust reference
+
+| Rust (v1.1.0) | Python |
+|----------------|--------|
+| `Packet::new / encode / decode` | `Packet.new / encode / decode` |
+| `PacketType` | `PacketType` (`AUDIO_DATA`, …) |
+| `AudioCodec` | `AudioCodec` (`OPUS`, `RAW_PCM_I16`, …) |
+| `Packet::encode_audio_payload / decode_audio_payload` | same names, static methods |
+| `MetadataBuilder` fluent API | identical fluent API |
+| `Metadata {get,get_string,get_u32,get_u16,encode,decode,to_packet,…}` | identical methods |
+| `AudioLevels` | `AudioLevels` |
+| `FecEncoder::generate_repair / try_recover` | `FecEncoder.generate_repair / try_recover` |
+| `JitterBuffer` | `JitterBuffer` |
+| `Handshake` (roles/states, build/parse) | `Handshake` |
+| `UdpTransport::bind / send_packet / recv_packet` | `UdpTransport.bind / send_packet / recv_packet` |
+| `Connection`, `ConnectionPool` | `Connection`, `ConnectionPool` |
+| `SessionManager` | `SessionManager` |
+| `prelude` | `rushaudio.prelude` |
+| `create_server(addr)` / `create_client()` | identical |
+
+Naming intentionally follows PEP 8 in Python (e.g. `PacketType.AUDIO_DATA`,
+`ConnectionState.STREAMING`) while behavior remains wire-identical.
+
+## License
+
+MIT

rushaudio-1.1.0/README.md

@@ -0,0 +1,171 @@
+# RushAudio — Python port
+
+A pure-Python, zero-dependency implementation of the [RushAudio](https://github.com/OseMine/rushaudio) protocol: a **binary protocol for low-latency audio streaming over UDP**.
+
+This port mirrors the public API and wire format of the Rust reference implementation, so it is interoperable byte-for-byte on the wire.
+
+| Property | Value |
+|----------|-------|
+| Transport | UDP (default port 4210) |
+| Header size | 14 bytes |
+| Max payload | 4096 bytes |
+| Latency target | 30–100ms |
+| Loss recovery | XOR FEC (recovers 1 loss per group) |
+| Codecs | Opus, PCM S16LE, A-law, μ-law |
+| Metadata | TLV key-value pairs (built-in + custom) |
+| Byte order | Big-endian (except PCM samples: little-endian) |
+| Python | ≥ 3.9, standard library only |
+
+## Install
+
+```bash
+pip install rushaudio            # from PyPI (once published)
+# or build/install from source:
+cd ports/python
+python -m pip wheel . -w dist    # -> dist/rushaudio-1.1.0-py3-none-any.whl
+pip install dist/rushaudio-1.1.0-py3-none-any.whl
+```
+
+## Quick start
+
+```python
+import rushaudio
+from rushaudio.prelude import *
+
+server = rushaudio.create_server("0.0.0.0:4210")   # receiver
+client = rushaudio.create_client()                 # sender
+peer = "127.0.0.1:4210"
+
+# Encode/decode an audio frame (AudioData payload, spec §4.1)
+payload = Packet.encode_audio_payload(2, 48000, AudioCodec.OPUS, opus_bytes)
+pkt = Packet.new(PacketType.AUDIO_DATA, seq=1, ts=0, payload=payload)
+client.send_packet(pkt, peer)
+
+got = server.recv_packet()          # non-blocking: None if nothing available
+if got is not None:
+    packet, addr = got
+    ch, sr, codec, frame = Packet.decode_audio_payload(packet.payload)
+```
+
+## Metadata (TLV)
+
+```python
+meta = (
+    MetadataBuilder()
+    .track_title("My Song")
+    .artist("Artist Name")
+    .album("Album")
+    .sample_rate(48000)
+    .channels(2)
+    .codec_info("Opus")
+    .bitrate(128000)
+    .custom(0x80, b"app-specific-data")
+    .build()
+)
+client.send_packet(meta.to_packet(seq=2, ts=20), peer)
+
+received = Metadata.from_packet(packet)          # on the other side
+title = received.get_string(META_TRACK_TITLE)    # -> "My Song"
+```
+
+## Handshake
+
+```python
+config = StreamConfig(sample_rate=48000, channels=2, bitrate=128000, codec=AudioCodec.OPUS)
+hs = Handshake(role=HandshakeRole.INITIATOR, ssrc=12345, config=config)
+client.send_packet(hs.build_request(0, 0), peer)
+
+# server side:
+got = server.recv_packet()
+remote_ssrc, cfg = Handshake.parse_request(got[0])
+responder = Handshake(role=HandshakeRole.RESPONDER, ssrc=67890, config=cfg)
+server.send_packet(responder.build_response(0, 0, accepted=True), got[1])
+```
+
+## FEC recovery
+
+```python
+group = [pkt1, pkt2, pkt3]                      # original AudioData packets
+repair = FecEncoder.generate_repair(group, seq=100, ts=0)
+client.send_packet(repair, peer)
+
+# receiver, having lost pkt2 of the group:
+recovered = FecEncoder.try_recover(repair, [pkt1, pkt3])   # -> (2, b"...")
+```
+
+## Jitter buffer
+
+```python
+jb = JitterBuffer()                     # 80ms target delay
+jb.push(seq, ts, payload_bytes)         # inserts in sequence order
+out = jb.pop()                          # (ts, payload) once aged, else None
+jb.adapt_delay()                        # clamp(2*jitter + 10ms, 20ms, 400ms)
+stats = jb.stats()                      # depth, dropped, late, jitter
+```
+
+## Wire / raw bytes
+
+```python
+wire = pkt.encode()                 # header + payload, 14+N bytes
+parsed = Packet.decode(wire)        # raises PacketError subclasses on invalid data
+```
+
+`UdpTransport.recv_packet()` returns `(Packet, (host, port))` or `None` when
+nothing is available (non-blocking). Non-parseable datagrams are skipped.
+
+## Layout
+
+```
+ports/python/
+├── pyproject.toml
+├── rushaudio/
+│   ├── __init__.py      # public API: create_server / create_client / DEFAULT_PORT
+│   ├── prelude.py       # from rushaudio.prelude import *
+│   ├── constants.py     # magic, metadata keys, timing, FEC/level constants
+│   ├── types.py         # PacketType, AudioCodec, StreamConfig, StreamStats
+│   ├── packet.py        # 14-byte header, Packet encode/decode, errors
+│   ├── metadata.py      # Metadata / MetadataBuilder TLV codec
+│   ├── levels.py        # AudioLevels (VU meter) packet type
+│   ├── fec.py           # XOR FEC encode + single-loss recovery
+│   ├── jitter.py        # adaptive jitter buffer
+│   ├── handshake.py     # handshake state machine + payload builders
+│   ├── transport.py     # non-blocking UdpTransport
+│   ├── connection.py    # Connection + bounded ConnectionPool
+│   └── session.py       # SessionManager (keepalive, stale sweeping)
+└── tests/
+    └── test_protocol.py # 37 tests (mirrors tests/integration.rs)
+```
+
+## Running the tests
+
+```bash
+cd ports/python
+python -m unittest discover -s tests -v    # 37 tests, stdlib only
+```
+
+## Parity with the Rust reference
+
+| Rust (v1.1.0) | Python |
+|----------------|--------|
+| `Packet::new / encode / decode` | `Packet.new / encode / decode` |
+| `PacketType` | `PacketType` (`AUDIO_DATA`, …) |
+| `AudioCodec` | `AudioCodec` (`OPUS`, `RAW_PCM_I16`, …) |
+| `Packet::encode_audio_payload / decode_audio_payload` | same names, static methods |
+| `MetadataBuilder` fluent API | identical fluent API |
+| `Metadata {get,get_string,get_u32,get_u16,encode,decode,to_packet,…}` | identical methods |
+| `AudioLevels` | `AudioLevels` |
+| `FecEncoder::generate_repair / try_recover` | `FecEncoder.generate_repair / try_recover` |
+| `JitterBuffer` | `JitterBuffer` |
+| `Handshake` (roles/states, build/parse) | `Handshake` |
+| `UdpTransport::bind / send_packet / recv_packet` | `UdpTransport.bind / send_packet / recv_packet` |
+| `Connection`, `ConnectionPool` | `Connection`, `ConnectionPool` |
+| `SessionManager` | `SessionManager` |
+| `prelude` | `rushaudio.prelude` |
+| `create_server(addr)` / `create_client()` | identical |
+
+Naming intentionally follows PEP 8 in Python (e.g. `PacketType.AUDIO_DATA`,
+`ConnectionState.STREAMING`) while behavior remains wire-identical.
+
+## License
+
+MIT

rushaudio-1.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rushaudio"
+version = "1.1.0"
+description = "Low-latency audio over IP live streaming protocol (Python port)"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [{ name = "RushAudio Contributors" }]
+keywords = ["audio", "streaming", "low-latency", "protocol", "udp"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Sound/Audio",
+]
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/OseMine/rushaudio"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["rushaudio*"]
+
+[tool.setuptools.package-data]
+rushaudio = ["py.typed"]

rushaudio-1.1.0/rushaudio/__init__.py

@@ -0,0 +1,94 @@
+"""RushAudio — low-latency audio over IP live streaming protocol.
+
+Pure-Python, zero-dependency port of the Rust reference implementation
+(https://github.com/OseMine/rushaudio). Follows the canonical wire spec in
+``docs/protocol.md`` of the rushaudio repository.
+
+Public API mirrors the Rust crate:
+
+    import rushaudio
+    server = rushaudio.create_server("0.0.0.0:4210")
+    client = rushaudio.create_client()
+
+    pkt = Packet.new(PacketType.AUDIO_DATA, seq=1, ts=0,
+                     payload=b"...")
+    wire = pkt.encode()
+    parsed = Packet.decode(wire)
+"""
+
+from . import constants as _c
+from .connection import Connection, ConnectionPool
+from .fec import FecEncoder
+from .handshake import Handshake, HandshakeRole, HandshakeState
+from .jitter import JitterBuffer, JitterStats
+from .levels import AudioLevels
+from .metadata import Metadata, MetadataBuilder, MetadataEntry, MetadataMap
+from .packet import (
+    BadMagicError,
+    InvalidPayloadError,
+    Packet,
+    PacketError,
+    PacketHeader,
+    PacketTooShortError,
+    TruncatedPayloadError,
+    UnknownTypeError,
+)
+from .session import Session, SessionManager
+from .transport import UdpTransport
+from .types import (
+    AudioCodec,
+    ConnectionState,
+    PacketType,
+    StreamConfig,
+    StreamStats,
+)
+
+VERSION = "1.1.0"
+DEFAULT_PORT: int = 4210
+
+
+def create_server(bind_addr: str) -> UdpTransport:
+    """Bind a non-blocking UDP server, e.g. ``create_server("0.0.0.0:4210")``."""
+    return UdpTransport.bind(bind_addr)
+
+
+def create_client() -> UdpTransport:
+    """Bind a non-blocking UDP socket on an ephemeral port."""
+    return UdpTransport.bind("0.0.0.0:0")
+
+
+__all__ = [
+    "AudioCodec",
+    "AudioLevels",
+    "BadMagicError",
+    "Connection",
+    "ConnectionPool",
+    "ConnectionState",
+    "FecEncoder",
+    "Handshake",
+    "HandshakeRole",
+    "HandshakeState",
+    "InvalidPayloadError",
+    "JitterBuffer",
+    "JitterStats",
+    "Metadata",
+    "MetadataBuilder",
+    "MetadataEntry",
+    "MetadataMap",
+    "Packet",
+    "PacketError",
+    "PacketHeader",
+    "PacketTooShortError",
+    "PacketType",
+    "Session",
+    "SessionManager",
+    "StreamConfig",
+    "StreamStats",
+    "TruncatedPayloadError",
+    "UdpTransport",
+    "UnknownTypeError",
+    "VERSION",
+    "DEFAULT_PORT",
+    "create_server",
+    "create_client",
+]

rushaudio-1.1.0/rushaudio/connection.py

@@ -0,0 +1,99 @@
+"""Per-peer connection tracking and a bounded connection pool.
+
+Mirrors ``src/transport/connection.rs`` in the Rust reference implementation.
+"""
+
+import time
+from dataclasses import dataclass, field
+from typing import Hashable, Iterator, List, Optional
+
+from .types import ConnectionState, StreamConfig, StreamStats
+
+
+@dataclass
+class Connection:
+    """State and statistics for one remote peer."""
+
+    remote_addr: Hashable
+    state: ConnectionState = ConnectionState.DISCONNECTED
+    config: StreamConfig = field(default_factory=StreamConfig)
+    stats: StreamStats = field(default_factory=StreamStats)
+    sequence_number: int = 0
+    connected_at: Optional[float] = None
+    last_activity: float = field(default_factory=time.monotonic)
+    ssrc: int = 0
+
+    def next_seq(self) -> int:
+        """Return the current sequence number and advance it (mod 2^32)."""
+        value = self.sequence_number
+        self.sequence_number = (self.sequence_number + 1) & 0xFFFFFFFF
+        return value
+
+    def current_seq(self) -> int:
+        return self.sequence_number
+
+    def mark_activity(self) -> None:
+        self.last_activity = time.monotonic()
+
+    def elapsed_since_activity(self) -> float:
+        return time.monotonic() - self.last_activity
+
+    def set_state(self, state: ConnectionState) -> None:
+        self.state = state
+        if state == ConnectionState.CONNECTED:
+            self.connected_at = time.monotonic()
+
+    def record_sent(self, size: int) -> None:
+        self.stats.packets_sent += 1
+        self.stats.bytes_sent += size
+
+    def record_received(self, size: int) -> None:
+        self.stats.packets_received += 1
+        self.stats.bytes_received += size
+
+    def record_loss(self, count: int) -> None:
+        self.stats.packets_lost += count
+
+
+class ConnectionPool:
+    """A bounded collection of connections keyed by remote address."""
+
+    def __init__(self, max_connections: int) -> None:
+        self._connections: List[Connection] = []
+        self._max_connections = max_connections
+
+    def get(self, addr: Hashable) -> Optional[Connection]:
+        for conn in self._connections:
+            if conn.remote_addr == addr:
+                return conn
+        return None
+
+    def get_mut(self, addr: Hashable) -> Optional[Connection]:
+        return self.get(addr)
+
+    def add(self, conn: Connection) -> bool:
+        if len(self._connections) >= self._max_connections:
+            return False
+        self._connections.append(conn)
+        return True
+
+    def remove(self, addr: Hashable) -> None:
+        self._connections = [c for c in self._connections if c.remote_addr != addr]
+
+    def len(self) -> int:
+        return len(self._connections)
+
+    def __len__(self) -> int:
+        return len(self._connections)
+
+    def is_empty(self) -> bool:
+        return not self._connections
+
+    def iter(self) -> Iterator[Connection]:
+        return iter(self._connections)
+
+    def __iter__(self) -> Iterator[Connection]:
+        return iter(self._connections)
+
+    def contains(self, addr: Hashable) -> bool:
+        return any(c.remote_addr == addr for c in self._connections)

rushaudio-1.1.0/rushaudio/constants.py

@@ -0,0 +1,62 @@
+"""Protocol constants for the RushAudio Python port.
+
+Mirrors ``src/protocol/constants.rs`` in the Rust reference implementation.
+"""
+
+PROTOCOL_MAGIC = bytes((0x52, 0x41))  # ASCII "RA"
+PROTOCOL_VERSION = 1
+
+HEADER_SIZE = 14  # 2(magic) + 1(ver) + 1(type) + 4(seq) + 4(ts) + 2(len)
+MAX_PAYLOAD_SIZE = 4096
+MAX_PACKET_SIZE = HEADER_SIZE + MAX_PAYLOAD_SIZE
+
+# Default timing
+DEFAULT_SAMPLE_RATE = 48000
+DEFAULT_FRAME_DURATION_MS = 20
+DEFAULT_JITTER_BUFFER_MS = 80
+DEFAULT_KEEPALIVE_INTERVAL_MS = 5000
+DEFAULT_HANDSHAKE_TIMEOUT_MS = 3000
+
+# Opus defaults
+OPUS_FRAME_SIZE_20MS = 960  # 48000 * 0.020
+OPUS_CHANNELS = 2
+
+# FEC
+FEC_REDUNDANCY_COUNT = 1
+FEC_GROUP_SIZE = 4
+
+# Control codes
+CONTROL_STREAM_START = 0x01
+CONTROL_STREAM_STOP = 0x02
+CONTROL_STREAM_PAUSE = 0x03
+CONTROL_STREAM_RESUME = 0x04
+
+# Metadata entry header: 1(key) + 2(length) = 3 bytes
+METADATA_ENTRY_HEADER_SIZE = 3
+
+# Built-in metadata keys (0x00 reserved, 0x01-0x7F reserved by protocol)
+META_SSRC = 0x01
+META_TRACK_TITLE = 0x02
+META_ARTIST = 0x03
+META_ALBUM = 0x04
+META_GENRE = 0x05
+META_SAMPLE_RATE = 0x06
+META_CHANNELS = 0x07
+META_CODEC_INFO = 0x08
+META_BITRATE = 0x09
+META_DURATION_MS = 0x0A
+META_STREAM_TITLE = 0x0B
+META_STREAM_URL = 0x0C
+
+# Custom metadata keys start at 0x80
+META_CUSTOM_BASE = 0x80
+
+# Audio level / VU meter
+# Payload: 4(audio_sequence) + 4(audio_timestamp) + 1(peak) + 1(rms)
+AUDIO_LEVELS_PAYLOAD_SIZE = 10
+# Levels are encoded in dBFS with 1 dB per unit. 0 = full scale (0 dBFS),
+# -127 = quietest non-silent level. LEVEL_SILENCE (-128) means -infinity dBFS
+# (digital silence).
+LEVEL_DBFS_MAX = 0
+LEVEL_DBFS_MIN = -127
+LEVEL_SILENCE = -128