ka9q-python 3.14.2__tar.gz → 3.15.1__tar.gz

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## [3.15.1] - 2026-05-21
+
+### Fixed
+
+- **`ka9q.__version__` was stale.**  v3.15.0's wheel correctly identified
+  itself as `3.15.0` in dist-info, but the `__version__` string baked
+  into `ka9q/__init__.py` still read `'3.14.2'` — the in-package
+  introspection answer was wrong for every consumer.  The fix replaces
+  the hardcoded literal with `importlib.metadata.version("ka9q-python")`,
+  so `__version__` now always tracks the installed dist-info — drift
+  between release version and code-reported version is no longer
+  possible.  Falls back to `"0.0.0+unknown"` on import error or when
+  the package is not installed (e.g. running from a source tree
+  without an editable install).
+
+## [3.15.0] - 2026-05-21
+
+### Added
+
+- **F16LE / F16BE RTP payload decoding** in `parse_rtp_samples` for radiod's
+  float16 output mode (encodings 6 and 9).  Both audio and IQ paths.
+- **G.711 µ-law / A-law decoders** for encodings 10 and 11 — pure-numpy
+  table-based, no `audioop` dependency (which was removed in Python 3.13).
+- **`OpusDecoder` class** in `ka9q.stream` for OPUS / OPUS_VOIP payloads
+  (encodings 3 and 7).  Lazy-imports `opuslib`; install via
+  `pip install ka9q-python[opus]`.  Maintains codec state across calls so
+  packet-loss concealment works end-to-end — one instance per stream SSRC.
+- New `opus` optional dependency in `pyproject.toml` (`opuslib>=3.0`).
+
+### Fixed
+
+- **`RadiodControl.set_agc(attack_rate=...)` was unreachable.**  It encoded
+  `StatusType.AGC_ATTACK_RATE`, which does not exist in ka9q-radio's
+  `status.h` or in `ka9q/types.py` — any call passing `attack_rate=` raised
+  `AttributeError`.  Replaced with a working `threshold:` kwarg backed by
+  `AGC_THRESHOLD` (which radiod actually decodes in
+  `decode_radio_commands()`).
+- **Removed 6 stale duplicate `set_*` methods.**  In a single class, second
+  defs silently shadow firsts — so callers were already using the correct
+  versions further down the file.  The dead first defs of `set_squelch`,
+  `set_pll`, `set_output_channels`, `set_independent_sideband`,
+  `set_envelope_detection`, and `set_opus_bitrate` are gone.  One of them
+  (`set_opus_bitrate`) referenced a non-existent `StatusType.OPUS_BITRATE`
+  — the working second def uses the correct `OPUS_BIT_RATE`.
+
+### Tooling / pinning
+
+- Pin advanced from ka9q-radio `f78cff9c` (1.0.0-22) to `d555f1853422`.
+  Drift report confirms zero TLV-tag, encoding-enum, demod-type, or
+  window-type changes across the 68 intervening upstream commits — only
+  packaging, hydrasdr-driver, and internal C-struct refactors.  Existing
+  ka9q-python state (`types.py`, `decode_status_packet`, `SpectrumStream`,
+  every `set_*` method) was already covering the full HEAD protocol
+  surface; this release brings the recorded compatibility tag in line.
+
+### Tests
+
+- Fixed pre-existing `tests/test_filter_edges.py::_bare_control` helper
+  that did not initialise the `client_id` attribute added with v3.14.0
+  per-(client,radiod) multicast destinations.
+
 ## [3.14.2] - 2026-05-14
 
 ### Added

{ka9q_python-3.14.2/ka9q_python.egg-info → ka9q_python-3.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ka9q-python
-Version: 3.14.2
+Version: 3.15.1
 Summary: Python interface for ka9q-radio control and monitoring
 Home-page: https://github.com/mijahauan/ka9q-python
 Author: Michael Hauan AC0G
@@ -30,6 +30,8 @@ Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Provides-Extra: tui
 Requires-Dist: textual>=0.50; extra == "tui"
+Provides-Extra: opus
+Requires-Dist: opuslib>=3.0; extra == "opus"
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file
@@ -60,7 +62,8 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 
 ## Features
 
-- **Complete radiod API** — all 110+ TLV status/command parameters exposed, generated from ka9q-radio's C headers
+- **Complete radiod API** — all 117 TLV status/command parameters exposed, generated from ka9q-radio's C headers
+- **Every radiod RTP encoding decoded** — `S16LE/BE`, `F32LE/BE`, `F16LE/BE`, `MULAW`, `ALAW` via pure-NumPy `parse_rtp_samples()`; `OPUS` / `OPUS_VOIP` via the optional `OpusDecoder` (install with `[opus]` extra)
 - **Four stream abstractions** — `RTPRecorder` (raw packets), `RadiodStream` (samples + gap handling), `ManagedStream` (self-healing single channel), `MultiStream` (shared socket, many SSRCs)
 - **Typed status decoder** — `ChannelStatus`, `FrontendStatus`, `PllStatus`, etc. with dotted-path field access
 - **Precise RTP timing** — GPS_TIME / RTP_TIMESNAP for sample-accurate wallclock timestamps
@@ -76,6 +79,19 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 pip install ka9q-python
 ```
 
+Optional extras:
+
+| Extra | Adds | Needed for |
+|-------|------|------------|
+| `tui` | `textual` | `ka9q tui` interactive terminal UI |
+| `opus` | `opuslib` | decoding `OPUS` / `OPUS_VOIP` RTP payloads via `OpusDecoder` |
+| `dev`  | `pytest`, `pytest-cov` | running the test suite |
+
+```bash
+pip install "ka9q-python[opus]"          # one extra
+pip install "ka9q-python[tui,opus]"      # multiple
+```
+
 Or install from source:
 
 ```bash

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/README.md

@@ -23,7 +23,8 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 
 ## Features
 
-- **Complete radiod API** — all 110+ TLV status/command parameters exposed, generated from ka9q-radio's C headers
+- **Complete radiod API** — all 117 TLV status/command parameters exposed, generated from ka9q-radio's C headers
+- **Every radiod RTP encoding decoded** — `S16LE/BE`, `F32LE/BE`, `F16LE/BE`, `MULAW`, `ALAW` via pure-NumPy `parse_rtp_samples()`; `OPUS` / `OPUS_VOIP` via the optional `OpusDecoder` (install with `[opus]` extra)
 - **Four stream abstractions** — `RTPRecorder` (raw packets), `RadiodStream` (samples + gap handling), `ManagedStream` (self-healing single channel), `MultiStream` (shared socket, many SSRCs)
 - **Typed status decoder** — `ChannelStatus`, `FrontendStatus`, `PllStatus`, etc. with dotted-path field access
 - **Precise RTP timing** — GPS_TIME / RTP_TIMESNAP for sample-accurate wallclock timestamps
@@ -39,6 +40,19 @@ Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, S
 pip install ka9q-python
 ```
 
+Optional extras:
+
+| Extra | Adds | Needed for |
+|-------|------|------------|
+| `tui` | `textual` | `ka9q tui` interactive terminal UI |
+| `opus` | `opuslib` | decoding `OPUS` / `OPUS_VOIP` RTP payloads via `OpusDecoder` |
+| `dev`  | `pytest`, `pytest-cov` | running the test suite |
+
+```bash
+pip install "ka9q-python[opus]"          # one extra
+pip install "ka9q-python[tui,opus]"      # multiple
+```
+
 Or install from source:
 
 ```bash

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/docs/API_REFERENCE.md

@@ -150,7 +150,7 @@ Tuning & filter:
 
 Gain / AGC:
 - `set_gain(ssrc, gain_db)`
-- `set_agc(ssrc, enable, hangtime=None, recovery_rate=None, threshold=None)`
+- `set_agc(ssrc, enable, hangtime=None, headroom=None, recovery_rate=None, threshold=None)`
 - `set_agc_hangtime(ssrc, seconds)`
 - `set_agc_recovery_rate(ssrc, db_per_sec)`
 - `set_agc_threshold(ssrc, threshold_db)`
@@ -286,20 +286,20 @@ for the full list — they mirror ka9q-radio's `status.h`.
 
 RTP output encoding (integer values match ka9q-radio's `rtp.h`):
 
-| Name | Value | Notes |
-|---|---|---|
-| `NO_ENCODING` | 0 | radiod default |
-| `S16LE` | 1 | Signed 16-bit little-endian PCM |
-| `S16BE` | 2 | Signed 16-bit big-endian PCM |
-| `OPUS` | 3 | Opus audio |
-| `F32LE` | 4 | 32-bit float LE (also `Encoding.F32`) |
-| `AX25` | 5 | Packet radio |
-| `F16LE` | 6 | 16-bit float LE (also `Encoding.F16`) |
-| `OPUS_VOIP` | 7 | Opus with `APPLICATION_VOIP` |
-| `F32BE` | 8 | 32-bit float BE |
-| `F16BE` | 9 | 16-bit float BE |
-| `MULAW` | 10 | μ-law |
-| `ALAW` | 11 | A-law |
+| Name | Value | Decoded by | Notes |
+|---|---|---|---|
+| `NO_ENCODING` | 0 | `parse_rtp_samples` | radiod default → treated as F32LE |
+| `S16LE` | 1 | `parse_rtp_samples` | Signed 16-bit little-endian PCM |
+| `S16BE` | 2 | `parse_rtp_samples` | Signed 16-bit big-endian PCM |
+| `OPUS` | 3 | `OpusDecoder` (extra) | Opus audio — needs `[opus]` install extra |
+| `F32LE` | 4 | `parse_rtp_samples` | 32-bit float LE (also `Encoding.F32`) |
+| `AX25` | 5 | (caller handles bytes) | Packet radio — framed protocol, not samples |
+| `F16LE` | 6 | `parse_rtp_samples` | 16-bit float LE (also `Encoding.F16`) |
+| `OPUS_VOIP` | 7 | `OpusDecoder` (extra) | Opus with `APPLICATION_VOIP` |
+| `F32BE` | 8 | `parse_rtp_samples` | 32-bit float BE |
+| `F16BE` | 9 | `parse_rtp_samples` | 16-bit float BE |
+| `MULAW` | 10 | `parse_rtp_samples` | G.711 µ-law (table-based, pure NumPy) |
+| `ALAW` | 11 | `parse_rtp_samples` | G.711 A-law (table-based, pure NumPy) |
 
 ### `DemodType`
 
@@ -417,6 +417,57 @@ Derived properties:
 
 ## Streams
 
+### `parse_rtp_samples()`
+
+Source: [stream.py](../ka9q/stream.py). Decodes one RTP payload to a
+NumPy sample array. Shared by `RadiodStream` and `MultiStream`.
+
+```python
+parse_rtp_samples(
+    payload: bytes,
+    encoding: int,        # any Encoding.* value
+    is_iq: bool,          # True → complex64 output; False → float32
+) -> np.ndarray | None
+```
+
+Covers every linear-PCM encoding radiod's `pt_from_info()` can grant:
+`NO_ENCODING`, `S16LE`, `S16BE`, `F32LE`, `F32BE`, `F16LE`, `F16BE`,
+`MULAW`, `ALAW`. G.711 µ-law / A-law use table-based NumPy decoders
+(no `audioop` dependency — that module is removed in Python 3.13).
+Unsupported encodings log a warning and fall back to F32LE.
+
+Returns `None` for `OPUS`, `OPUS_VOIP` (use `OpusDecoder` below), and
+`AX25` (framed protocol data, handle the bytes yourself).
+
+### `OpusDecoder`
+
+Source: [stream.py](../ka9q/stream.py). Optional Opus payload decoder
+for radiod's `OPUS` / `OPUS_VOIP` streams. Requires the `[opus]`
+install extra (`pip install ka9q-python[opus]`, which pulls
+`opuslib`).
+
+```python
+OpusDecoder(sample_rate: int = 48000, channels: int = 1)
+```
+
+- `decode(payload: bytes, *, fec: bool = False) -> np.ndarray` —
+  one Opus frame → float32 PCM, normalised to ±1.0. Stereo output is
+  interleaved L,R,L,R,…. Empty payload triggers one frame of
+  packet-loss concealment.
+- `sample_rate` / `channels` properties expose the codec config.
+
+Maintain one `OpusDecoder` instance per stream SSRC so the internal
+codec state — and therefore PLC — works correctly across packets.
+`sample_rate` must be one of 8000/12000/16000/24000/48000.
+
+```python
+from ka9q.stream import OpusDecoder
+
+dec = OpusDecoder(sample_rate=48000, channels=1)
+for payload in opus_payloads:
+    samples = dec.decode(payload)  # float32, mono
+```
+
 ### `RadiodStream`
 
 Source: [stream.py](../ka9q/stream.py). Continuous-sample consumer

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/docs/ARCHITECTURE.md

@@ -77,6 +77,17 @@ to handle out-of-order RTP. Hands each batch to an
 `on_samples(samples, quality)` callback. Does **not** heal radiod
 restarts — a restart produces a lasting silence.
 
+`stream.py` also exposes two payload-decoder helpers shared by every
+stream class:
+
+- `parse_rtp_samples(payload, encoding, is_iq)` — decodes every
+  linear-PCM encoding radiod emits (`S16LE/BE`, `F32LE/BE`,
+  `F16LE/BE`, `MULAW`, `ALAW`) to NumPy in pure Python, no
+  `audioop` (gone in Py 3.13).
+- `OpusDecoder(sample_rate, channels)` — decodes `OPUS` / `OPUS_VOIP`
+  via the optional `opuslib` dependency (`pip install ka9q-python[opus]`).
+  One instance per SSRC so codec state and PLC stay coherent.
+
 ### 3. `ManagedStream` ([managed_stream.py](../ka9q/managed_stream.py))
 
 High-level self-healing wrapper around `RadiodStream`. A background

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/docs/INSTALLATION.md

@@ -41,6 +41,18 @@ pip install -e ".[dev]"
 
 This includes pytest and other testing tools.
 
+### Optional Extras
+
+`ka9q-python` defines three optional dependency groups:
+
+| Extra | Adds | Needed for |
+|-------|------|------------|
+| `dev` | `pytest`, `pytest-cov` | running the test suite |
+| `tui` | `textual` | the `ka9q tui` interactive terminal UI |
+| `opus` | `opuslib` | decoding `OPUS` / `OPUS_VOIP` RTP payloads with `ka9q.stream.OpusDecoder` |
+
+Combine as needed, e.g. `pip install -e ".[dev,opus]"`.
+
 ## For Use in Other Applications
 
 ### In requirements.txt
@@ -98,7 +110,7 @@ python3 -c "import ka9q; print(f'ka9q version {ka9q.__version__} installed succe
 
 Expected output (version will match whatever is installed):
 ```
-ka9q version 3.9.0 installed successfully
+ka9q version 3.15.0 installed successfully
 ```
 
 After installation, the `ka9q` command-line tool is also on your `PATH`:
@@ -131,7 +143,8 @@ Package works with Python's built-in networking. Use IP addresses instead of `.l
 - `numpy >= 1.24.0`
 
 ### Optional (for enhanced functionality)
-- `textual` — required for `ka9q tui`. Not pulled in by the base install; install with `pip install textual` (or bundle it into your deployment requirements).
+- `textual` — required for `ka9q tui`. Install via the `[tui]` extra or `pip install textual` directly.
+- `opuslib` — required to decode `OPUS` / `OPUS_VOIP` RTP payloads via `ka9q.stream.OpusDecoder`. Install via the `[opus]` extra or `pip install opuslib`. (Linear-PCM encodings — `S16LE/BE`, `F32LE/BE`, `F16LE/BE`, `MULAW`, `ALAW` — are decoded in pure NumPy and need no extra dependency.)
 - `avahi-utils` (Linux) — faster mDNS hostname resolution
 - `control` from ka9q-radio — fallback path for channel discovery
 
@@ -187,11 +200,13 @@ pip uninstall ka9q
 ```bash
 pip install build
 python3 -m build
+# or, with uv:
+uv build
 ```
 
-This creates:
-- `dist/ka9q-1.0.0-py3-none-any.whl` (wheel)
-- `dist/ka9q-1.0.0.tar.gz` (source distribution)
+This creates (filenames track the current version in `pyproject.toml`):
+- `dist/ka9q_python-X.Y.Z-py3-none-any.whl` (wheel)
+- `dist/ka9q_python-X.Y.Z.tar.gz` (source distribution)
 
 ### Upload to PyPI (maintainers only)
 ```bash

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/docs/MULTI_STREAM.md

@@ -254,10 +254,16 @@ Based on the current source ([`ka9q/multi_stream.py`](../ka9q/multi_stream.py)):
 - **No `remove_channel()` in the public API.** To remove a channel,
   stop the `MultiStream`, rebuild it with the remaining channels, and
   start again. For long-lived recorders this has been acceptable.
-- **Opus encoded streams** — `parse_rtp_samples()` must understand
-  the encoding. S16LE/S16BE (1/2) and F32LE (4) are the well-tested
-  paths; if you need Opus, verify against
-  [`ka9q/stream.py`](../ka9q/stream.py).
+- **Linear-PCM encodings** are decoded by `parse_rtp_samples()` in
+  pure NumPy: `S16LE/BE`, `F32LE/BE`, `F16LE/BE`, `MULAW`, `ALAW`.
+  All radiod-emitted sample encodings work out of the box.
+- **Opus** (`OPUS`, `OPUS_VOIP`) is a framed codec, not raw samples
+  — `parse_rtp_samples()` returns `None` for those payloads. Wrap
+  the stream with `ka9q.stream.OpusDecoder` (requires the `[opus]`
+  install extra) to recover float32 PCM, keeping one decoder
+  instance per SSRC so packet-loss concealment works.
+- **AX25** (encoding 5) is framed protocol data, also not samples —
+  `parse_rtp_samples()` returns `None`. Handle the bytes yourself.
 - **`samples_per_packet=320` default** assumes the typical 12 kHz /
   26.67 ms RTP packetization used by radiod. If your channels run
   at a different packet cadence, set it explicitly.

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/ka9q/__init__.py

@@ -56,7 +56,15 @@ Lower-level usage (explicit control):
         )
         print(f"Created channel with SSRC: {ssrc}")
 """
-__version__ = '3.14.2'
+try:
+    from importlib.metadata import version as _pkg_version, PackageNotFoundError as _PkgNotFound
+    try:
+        __version__ = _pkg_version("ka9q-python")
+    except _PkgNotFound:
+        __version__ = "0.0.0+unknown"
+    del _pkg_version, _PkgNotFound
+except ImportError:
+    __version__ = "0.0.0+unknown"
 __author__ = 'Michael Hauan AC0G'
 
 from .control import RadiodControl, allocate_ssrc

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/ka9q/compat.py

@@ -12,4 +12,4 @@ Usage:
     print(f"Compatible with ka9q-radio at {KA9Q_RADIO_COMMIT}")
 """
 
-KA9Q_RADIO_COMMIT: str = "f78cff9cc8c7fa33ea49aac9176d9263c535a332"
+KA9Q_RADIO_COMMIT: str = "d555f1853422ecc551ac7e4064b9d9cfdb743764"

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/ka9q/control.py

@@ -973,23 +973,27 @@ class RadiodControl:
         logger.info(f"Setting sample rate for SSRC {ssrc} to {sample_rate} Hz")
         self.send_command(cmdbuffer)
     
-    def set_agc(self, ssrc: int, enable: bool, hangtime: Optional[float] = None, 
+    def set_agc(self, ssrc: int, enable: bool, hangtime: Optional[float] = None,
                 headroom: Optional[float] = None, recovery_rate: Optional[float] = None,
-                attack_rate: Optional[float] = None):
+                threshold: Optional[float] = None):
         """
-        Configure AGC (Automatic Gain Control) for a channel
-        
+        Configure AGC (Automatic Gain Control) for a channel.
+
+        radiod exposes four AGC knobs: enable, hangtime, headroom, recovery_rate,
+        and threshold. There is no separate "attack rate" — see radio_status.c
+        decode_radio_commands().
+
         Args:
             ssrc: SSRC of the channel
             enable: Enable/disable AGC (True=enabled, False=manual gain)
-            hangtime: AGC hang time in seconds (optional)
-            headroom: Target headroom in dB (optional)
-            recovery_rate: AGC recovery rate (optional)
-            attack_rate: AGC attack rate (optional)
+            hangtime: AGC hang time in seconds
+            headroom: Target headroom in dB (positive; radiod negates internally)
+            recovery_rate: AGC recovery rate in dB/sec
+            threshold: AGC threshold in dB
         """
         cmdbuffer = bytearray()
         cmdbuffer.append(CMD)
-        
+
         encode_int(cmdbuffer, StatusType.AGC_ENABLE, 1 if enable else 0)
         if hangtime is not None:
             encode_float(cmdbuffer, StatusType.AGC_HANGTIME, hangtime)
@@ -997,14 +1001,14 @@ class RadiodControl:
             encode_float(cmdbuffer, StatusType.HEADROOM, headroom)
         if recovery_rate is not None:
             encode_float(cmdbuffer, StatusType.AGC_RECOVERY_RATE, recovery_rate)
-        if attack_rate is not None:
-            encode_float(cmdbuffer, StatusType.AGC_ATTACK_RATE, attack_rate)
-        
+        if threshold is not None:
+            encode_float(cmdbuffer, StatusType.AGC_THRESHOLD, threshold)
+
         encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
         encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
         encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting AGC for SSRC {ssrc}: enable={enable}, hangtime={hangtime}, headroom={headroom}")
+
+        logger.info(f"Setting AGC for SSRC {ssrc}: enable={enable}")
         self.send_command(cmdbuffer)
     
     def set_gain(self, ssrc: int, gain_db: float):
@@ -1710,138 +1714,6 @@ class RadiodControl:
         logger.info(f"Setting LIFETIME for SSRC {ssrc} to {lifetime} frames")
         self.send_command(cmdbuffer)
 
-    def set_squelch(self, ssrc: int, open_threshold: Optional[float] = None,
-                    close_threshold: Optional[float] = None, snr_squelch: Optional[bool] = None):
-        """
-        Set squelch parameters for a channel
-        
-        Args:
-            ssrc: SSRC of the channel
-            open_threshold: Squelch open threshold in dB (optional)
-            close_threshold: Squelch close threshold in dB (optional)
-            snr_squelch: Enable SNR-based squelch (optional)
-        """
-        cmdbuffer = bytearray()
-        cmdbuffer.append(CMD)
-        
-        if open_threshold is not None:
-            encode_float(cmdbuffer, StatusType.SQUELCH_OPEN, open_threshold)
-        if close_threshold is not None:
-            encode_float(cmdbuffer, StatusType.SQUELCH_CLOSE, close_threshold)
-        if snr_squelch is not None:
-            encode_int(cmdbuffer, StatusType.SNR_SQUELCH, 1 if snr_squelch else 0)
-        
-        encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
-        encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
-        encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting squelch for SSRC {ssrc}")
-        self.send_command(cmdbuffer)
-
-    def set_pll(self, ssrc: int, enable: Optional[bool] = None, 
-                bandwidth: Optional[float] = None, square: Optional[bool] = None):
-        """
-        Set PLL parameters for a channel
-        
-        Args:
-            ssrc: SSRC of the channel
-            enable: Enable/disable PLL (optional)
-            bandwidth: PLL bandwidth in Hz (optional)
-            square: Enable square-wave PLL output (optional)
-        """
-        cmdbuffer = bytearray()
-        cmdbuffer.append(CMD)
-        
-        if enable is not None:
-            encode_int(cmdbuffer, StatusType.PLL_ENABLE, 1 if enable else 0)
-        if bandwidth is not None:
-            encode_float(cmdbuffer, StatusType.PLL_BW, bandwidth)
-        if square is not None:
-            encode_int(cmdbuffer, StatusType.PLL_SQUARE, 1 if square else 0)
-        
-        encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
-        encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
-        encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting PLL for SSRC {ssrc}")
-        self.send_command(cmdbuffer)
-
-    def set_output_channels(self, ssrc: int, channels: int):
-        """
-        Set number of output channels (mono/stereo)
-        
-        Args:
-            ssrc: SSRC of the channel
-            channels: Number of channels (1=mono, 2=stereo)
-        """
-        cmdbuffer = bytearray()
-        cmdbuffer.append(CMD)
-        
-        encode_int(cmdbuffer, StatusType.OUTPUT_CHANNELS, channels)
-        encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
-        encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
-        encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting output channels for SSRC {ssrc} to {channels}")
-        self.send_command(cmdbuffer)
-
-    def set_independent_sideband(self, ssrc: int, enable: bool):
-        """
-        Enable/disable independent sideband (ISB) mode
-        
-        Args:
-            ssrc: SSRC of the channel
-            enable: Enable ISB mode
-        """
-        cmdbuffer = bytearray()
-        cmdbuffer.append(CMD)
-        
-        encode_int(cmdbuffer, StatusType.INDEPENDENT_SIDEBAND, 1 if enable else 0)
-        encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
-        encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
-        encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting ISB for SSRC {ssrc} to {enable}")
-        self.send_command(cmdbuffer)
-
-    def set_envelope_detection(self, ssrc: int, enable: bool):
-        """
-        Enable/disable envelope detection for AM
-        
-        Args:
-            ssrc: SSRC of the channel
-            enable: Enable envelope detection
-        """
-        cmdbuffer = bytearray()
-        cmdbuffer.append(CMD)
-        
-        encode_int(cmdbuffer, StatusType.ENVELOPE, 1 if enable else 0)
-        encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
-        encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
-        encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting envelope detection for SSRC {ssrc} to {enable}")
-        self.send_command(cmdbuffer)
-
-    def set_opus_bitrate(self, ssrc: int, bitrate: int):
-        """
-        Set Opus codec bitrate
-        
-        Args:
-            ssrc: SSRC of the channel
-            bitrate: Bitrate in bits per second (6000-510000)
-        """
-        cmdbuffer = bytearray()
-        cmdbuffer.append(CMD)
-        
-        encode_int(cmdbuffer, StatusType.OPUS_BITRATE, bitrate)
-        encode_int(cmdbuffer, StatusType.OUTPUT_SSRC, ssrc)
-        encode_int(cmdbuffer, StatusType.COMMAND_TAG, secrets.randbits(31))
-        encode_eol(cmdbuffer)
-        
-        logger.info(f"Setting Opus bitrate for SSRC {ssrc} to {bitrate}")
-        self.send_command(cmdbuffer)
-    
     def _setup_status_listener(self):
         """Set up socket to listen for status responses"""
         # Create a separate socket for receiving status messages

{ka9q_python-3.14.2 → ka9q_python-3.15.1}/ka9q/multi_stream.py

@@ -201,12 +201,21 @@ class MultiStream:
         ssrc = channel_info.ssrc
         is_iq = preset.lower() in ("iq", "spectrum")
 
+        # Use the encoding radiod actually granted (channel_info.encoding)
+        # rather than the encoding we requested. radiod silently downgrades
+        # F32 → S16 for some IQ-channel configurations; storing the requested
+        # value caused parse_rtp_samples to decode upstream bytes with the
+        # wrong dtype and produce NaN-poisoned garbage. The granted encoding
+        # is authoritative. Fall back to the caller's value if channel_info
+        # doesn't carry an encoding (or carries 0 = "none/default").
+        granted_encoding = getattr(channel_info, 'encoding', 0) or encoding
+
         slot = _ChannelSlot(
             channel_info=channel_info,
             frequency_hz=frequency_hz,
             preset=preset,
             sample_rate=sample_rate,
-            encoding=encoding,
+            encoding=granted_encoding,
             is_iq=is_iq,
             resequencer=PacketResequencer(
                 buffer_size=self._resequence_buffer_size,