rdsclock 0.2.0__tar.gz → 0.2.2__tar.gz

{rdsclock-0.2.0 → rdsclock-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdsclock
-Version: 0.2.0
+Version: 0.2.2
 Summary: Passive RDS Clock-Time receiver for FM via RTL-SDR, with multi-source consensus for GPS-denied environments
 Author-email: Mateusz Klatt <mateusz@klatt.ie>
 License-Expression: Apache-2.0
@@ -26,6 +26,8 @@ Provides-Extra: audio
 Requires-Dist: sounddevice>=0.4.6; extra == "audio"
 Provides-Extra: plot
 Requires-Dist: matplotlib>=3.7.0; extra == "plot"
+Provides-Extra: fast
+Requires-Dist: numba>=0.60.0; extra == "fast"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"
 Requires-Dist: pytest-timeout>=2.1.0; extra == "dev"
@@ -265,11 +267,13 @@ the local antenna picks up.
 
 ## Status
 
-- **0.2.0** — current release. First version that decodes real FM
-  broadcasts (earlier 0.1.x worked only on synthetic IQ — see the
-  0.2.0 entry in [`CHANGELOG.md`](CHANGELOG.md)). Pre-1.0; the CLI
-  and on-disk formats may still change.
-- 236 tests including a real-IQ regression backed by a 6 s capture
+- **0.2.2** — current release. Operator-facing polish: 250 kS/s SDR
+  captures can now play at 48 kHz audio via rational resampling, and
+  Programme Service names are displayed only after validation so
+  dynamic-PS stations do not show mixed scrolling fragments. Decoder
+  group counts and PI codes remain locked to the 0.2.1 baseline.
+  Pre-1.0; the CLI and on-disk formats may still change.
+- 240+ tests including a real-IQ regression backed by a 6 s capture
   of Polskie Radio Trójka 98.8 from Warsaw; line coverage **100 %**
   (tracked by SonarCloud).
 

{rdsclock-0.2.0 → rdsclock-0.2.2}/README.md

@@ -229,11 +229,13 @@ the local antenna picks up.
 
 ## Status
 
-- **0.2.0** — current release. First version that decodes real FM
-  broadcasts (earlier 0.1.x worked only on synthetic IQ — see the
-  0.2.0 entry in [`CHANGELOG.md`](CHANGELOG.md)). Pre-1.0; the CLI
-  and on-disk formats may still change.
-- 236 tests including a real-IQ regression backed by a 6 s capture
+- **0.2.2** — current release. Operator-facing polish: 250 kS/s SDR
+  captures can now play at 48 kHz audio via rational resampling, and
+  Programme Service names are displayed only after validation so
+  dynamic-PS stations do not show mixed scrolling fragments. Decoder
+  group counts and PI codes remain locked to the 0.2.1 baseline.
+  Pre-1.0; the CLI and on-disk formats may still change.
+- 240+ tests including a real-IQ regression backed by a 6 s capture
   of Polskie Radio Trójka 98.8 from Warsaw; line coverage **100 %**
   (tracked by SonarCloud).
 

{rdsclock-0.2.0 → rdsclock-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rdsclock"
-version = "0.2.0"
+version = "0.2.2"
 description = "Passive RDS Clock-Time receiver for FM via RTL-SDR, with multi-source consensus for GPS-denied environments"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -36,6 +36,9 @@ audio = [
 plot = [
     "matplotlib>=3.7.0",
 ]
+fast = [
+    "numba>=0.60.0",
+]
 dev = [
     "pytest>=7.4.0",
     "pytest-timeout>=2.1.0",

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock/__init__.py

@@ -19,4 +19,4 @@ Modules:
                      scan / recon / demo.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock/audio.py

@@ -10,7 +10,7 @@ audio sink is needed; the rest of the package works without it.
 """
 
 import numpy as np
-from scipy.signal import firwin, lfilter, lfilter_zi
+from scipy.signal import firwin, lfilter, lfilter_zi, resample_poly
 
 from .rtl_tcp import RtlTcpClient
 
@@ -33,12 +33,11 @@ def design_audio_filter(
 ) -> tuple[np.ndarray, int]:
     """Design the mono-audio LPF used during decimation from ``fs_in`` to ``fs_out``.
 
-    Returns ``(taps, decimation_factor)``. ``fs_in`` must be an integer
-    multiple of ``fs_out``.
+    Returns ``(taps, decimation_factor)``. Integer SDR/audio ratios return the
+    real decimation factor; rational ratios return ``1`` so callers can apply
+    polyphase resampling after the same low-pass stage.
     """
-    if fs_in % fs_out != 0:
-        raise ValueError(f"SDR sample rate ({fs_in}) must be a multiple of audio rate ({fs_out})")
-    decim = fs_in // fs_out
+    decim = fs_in // fs_out if fs_in % fs_out == 0 else 1
     nyq = fs_in / 2.0
     taps = firwin(numtaps=numtaps, cutoff=cutoff_hz / nyq).astype(np.float32)
     return taps, decim
@@ -53,13 +52,15 @@ def fm_audio_from_iq(
 ) -> np.ndarray:
     """Convert an IQ buffer into a mono audio float32 buffer at ``fs_out``.
 
-    Steps: FM phase demodulation → LPF (cutoff = ``cutoff_hz``) → decimation
-    to ``fs_out`` → optional peak normalisation to ±0.5 to avoid clipping.
+    Steps: FM phase demodulation → LPF (cutoff = ``cutoff_hz``) → rate
+    conversion to ``fs_out`` → optional peak normalisation to ±0.5 to avoid
+    clipping. Integer SDR/audio ratios use the fast FIR decimation path;
+    rational ratios use polyphase resampling after the same LPF stage.
     """
     taps, decim = design_audio_filter(fs_in, fs_out, cutoff_hz=cutoff_hz)
     fm = fm_demod(iq)
     audio, _ = lfilter(taps, 1.0, fm), None
-    audio = audio[::decim]
+    audio = audio[::decim] if fs_in % fs_out == 0 else resample_poly(audio, fs_out, fs_in)
     if normalise:
         peak = float(np.max(np.abs(audio)) + 1e-6)
         audio = (audio / peak) * 0.5
@@ -88,8 +89,10 @@ def play_iq_live(
         ) from exc
 
     chunk_samples = chunk_samples or fs_sdr // 10  # 100 ms per block
-    taps, decim = design_audio_filter(fs_sdr, fs_audio)
-    zi = lfilter_zi(taps, 1.0)
+    integer_decim = fs_sdr % fs_audio == 0
+    if integer_decim:
+        taps, decim = design_audio_filter(fs_sdr, fs_audio)
+        zi = lfilter_zi(taps, 1.0)
 
     sd.default.samplerate = fs_audio
     sd.default.channels = 1
@@ -117,11 +120,14 @@ def play_iq_live(
             try:
                 while True:
                     iq = client.read_iq(chunk_samples, settle_s=0.0)
-                    fm = fm_demod(iq)
-                    audio, zi = lfilter(taps, 1.0, fm, zi=zi)
-                    audio = audio[::decim]
-                    peak = float(np.max(np.abs(audio)) + 1e-6)
-                    audio = (audio / peak) * 0.5
+                    if integer_decim:
+                        fm = fm_demod(iq)
+                        audio, zi = lfilter(taps, 1.0, fm, zi=zi)
+                        audio = audio[::decim]
+                        peak = float(np.max(np.abs(audio)) + 1e-6)
+                        audio = (audio / peak) * 0.5
+                    else:
+                        audio = fm_audio_from_iq(iq, fs_in=fs_sdr, fs_out=fs_audio)
                     stream.write(audio.astype("float32"))
             except KeyboardInterrupt:
                 print("\nInterrupted by operator (Ctrl+C).")
@@ -151,20 +157,7 @@ def play_iq_file(
     if len(iq) == 0 or np.max(np.abs(iq[:1000])) > 100:
         iq = dsp.read_iq_u8(path)
 
-    # If the file was captured at the standard 250 kS/s, decimate by 5 to
-    # reach 50 kS/s, then by ~1.04 to 48 kHz. We keep it simple: design a
-    # filter using a chosen integer ratio and accept whatever audio rate
-    # the file allows.
-    if fs_in % fs_audio == 0:
-        audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=fs_audio)
-    else:
-        # Fall back: drop to the largest fs_audio divisor of fs_in.
-        from math import gcd
-
-        target = gcd(fs_in, fs_audio)
-        audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=target)
-        fs_audio = target
-
+    audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=fs_audio)
     duration_s = len(audio) / fs_audio
     print(f"Playing {path}: {duration_s:.1f}s of audio @ {fs_audio} Hz (Ctrl+C to stop)…")
     try:

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock/dsp.py

@@ -8,6 +8,11 @@ for FM-demodulated baseband).
 import numpy as np
 from scipy.signal import filtfilt, firwin, lfilter, resample_poly
 
+try:
+    from numba import njit as _numba_njit
+except ImportError:  # pragma: no cover - optional acceleration dependency
+    _numba_njit = None
+
 # RDS / FM constants
 FM_CHANNEL_BW_HZ = 100_000  # half-width of an FM channel (~200 kHz total)
 RDS_CARRIER_HZ = 57_000
@@ -165,9 +170,7 @@ def symbol_lpf(x: np.ndarray, fs: float, cutoff: float = SYMBOL_LPF_HZ) -> np.nd
     return filtfilt(taps, [1.0], x)
 
 
-def costas_loop_bpsk(samples: np.ndarray, alpha: float = 0.3, beta: float = 0.005) -> np.ndarray:
-    """Second-order Costas loop for BPSK. Stabilises carrier phase."""
-    samples = np.asarray(samples, dtype=np.complex64)
+def _costas_loop_bpsk_python(samples: np.ndarray, alpha: float, beta: float) -> np.ndarray:
     out = np.empty_like(samples)
     phase = 0.0
     freq = 0.0
@@ -184,6 +187,19 @@ def costas_loop_bpsk(samples: np.ndarray, alpha: float = 0.3, beta: float = 0.00
     return out
 
 
+_COSTAS_LOOP_BPSK_NUMBA = (
+    _numba_njit(cache=True)(_costas_loop_bpsk_python) if _numba_njit is not None else None
+)
+
+
+def costas_loop_bpsk(samples: np.ndarray, alpha: float = 0.3, beta: float = 0.005) -> np.ndarray:
+    """Second-order Costas loop for BPSK. Stabilises carrier phase."""
+    samples = np.asarray(samples, dtype=np.complex64)
+    if _COSTAS_LOOP_BPSK_NUMBA is not None:
+        return _COSTAS_LOOP_BPSK_NUMBA(samples, alpha, beta)  # pragma: no cover
+    return _costas_loop_bpsk_python(samples, alpha, beta)
+
+
 def agc(samples: np.ndarray, eps: float = 1e-9) -> np.ndarray:
     """Normalize complex baseband amplitude by its mean magnitude."""
     samples = np.asarray(samples, dtype=np.complex64)

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock/rds_blocks.py

@@ -41,23 +41,40 @@ OFFSET_BY_NAME = {
 GROUP_BLOCKS = 4
 GROUP_BITS = BLOCK_BITS * GROUP_BLOCKS  # 104
 
+_BLOCK_WORD_MASK = (1 << CRC_BITS) - 1
+_DATA_WORD_MASK = (1 << DATA_BITS) - 1
+_CRC_TOP_BIT = 1 << CRC_BITS
+_CRC_POLY_WITH_TOP_BIT = CRC_POLY | _CRC_TOP_BIT
+_BLOCK_WEIGHTS = (1 << np.arange(BLOCK_BITS - 1, -1, -1, dtype=np.uint32)).astype(np.uint32)
 
-def crc10(dataword: int) -> int:
-    """Compute the 10-bit RDS CRC of a 16-bit dataword.
 
-    Standard shift-register implementation: feed 16 data bits into
-    a 10-bit register tapped by ``CRC_POLY``, then flush 10 zero bits.
-    """
-    reg = 0
+def _build_crc10_table() -> np.ndarray:
+    datawords = np.arange(1 << DATA_BITS, dtype=np.uint32)
+    reg = np.zeros_like(datawords)
     for i in range(DATA_BITS - 1, -1, -1):
-        reg = (reg << 1) | ((dataword >> i) & 1)
-        if reg & (1 << CRC_BITS):
-            reg ^= CRC_POLY | (1 << CRC_BITS)
+        reg = (reg << 1) | ((datawords >> i) & 1)
+        reg = np.where((reg & _CRC_TOP_BIT) != 0, reg ^ _CRC_POLY_WITH_TOP_BIT, reg)
     for _ in range(CRC_BITS):
         reg <<= 1
-        if reg & (1 << CRC_BITS):
-            reg ^= CRC_POLY | (1 << CRC_BITS)
-    return reg & ((1 << CRC_BITS) - 1)
+        reg = np.where((reg & _CRC_TOP_BIT) != 0, reg ^ _CRC_POLY_WITH_TOP_BIT, reg)
+    return (reg & _BLOCK_WORD_MASK).astype(np.uint16)
+
+
+_CRC10_TABLE = _build_crc10_table()
+
+
+def _crc10_many(datawords: np.ndarray) -> np.ndarray:
+    return _CRC10_TABLE[np.asarray(datawords, dtype=np.uint32) & _DATA_WORD_MASK]
+
+
+def crc10(dataword: int) -> int:
+    """Compute the 10-bit RDS CRC of a 16-bit dataword.
+
+    Table-driven equivalent of the standard shift-register implementation:
+    feed 16 data bits into a 10-bit register tapped by ``CRC_POLY``, then
+    flush 10 zero bits.
+    """
+    return int(_CRC10_TABLE[int(dataword) & _DATA_WORD_MASK])
 
 
 def encode_block(dataword: int, offset_word: int) -> int:
@@ -73,7 +90,7 @@ def block_dataword(block26: int) -> int:
 
 
 def block_checkword(block26: int) -> int:
-    return block26 & ((1 << CRC_BITS) - 1)
+    return block26 & _BLOCK_WORD_MASK
 
 
 def block_valid(block26: int, block_no: int, version_b: bool | None = None) -> bool:
@@ -120,12 +137,30 @@ def blocks_to_bits(blocks: Iterable[int]) -> np.ndarray:
 
 def bits_to_word(bits: Sequence[int]) -> int:
     """Pack a bit sequence into an int (MSB first)."""
+    bit_array = np.asarray(bits, dtype=np.uint8)
+    if bit_array.size == BLOCK_BITS:
+        return int(_bits_to_words_26(bit_array))
     word = 0
-    for b in bits:
+    for b in bit_array:
         word = (word << 1) | (int(b) & 1)
     return word
 
 
+def _bits_to_words_26(bit_windows: np.ndarray, assume_binary: bool = False) -> np.ndarray:
+    bit_windows = np.asarray(bit_windows, dtype=np.uint8)
+    if not assume_binary:
+        bit_windows = np.bitwise_and(bit_windows, 1)
+    return bit_windows @ _BLOCK_WEIGHTS
+
+
+def _coerce_bits(bits: np.ndarray) -> np.ndarray:
+    if not isinstance(bits, np.ndarray):
+        bits = np.asarray(bits, dtype=np.uint8)
+    if bits.dtype != np.uint8:
+        bits = bits.astype(np.uint8)
+    return np.bitwise_and(bits, 1)
+
+
 def find_groups_in_bitstream(bits: np.ndarray) -> list[bytearray]:
     """Slide over a bitstream and extract groups of 4 consecutively valid blocks.
 
@@ -135,52 +170,57 @@ def find_groups_in_bitstream(bits: np.ndarray) -> list[bytearray]:
 
     Returns a list of 8-byte bytearrays (4 × big-endian 16-bit datawords).
     """
-    if not isinstance(bits, np.ndarray):
-        bits = np.asarray(bits, dtype=np.uint8)
-    if bits.dtype != np.uint8:
-        bits = bits.astype(np.uint8)
-
+    bits = _coerce_bits(bits)
     n = len(bits)
     groups: list[bytearray] = []
-    i = 0
-    while i + GROUP_BITS <= n:
-        # Block A
-        w0 = bits_to_word(bits[i : i + BLOCK_BITS])
-        if not block_valid(w0, 0):
-            i += 1
-            continue
-        # Block B (validated against offset B)
-        w1 = bits_to_word(bits[i + BLOCK_BITS : i + 2 * BLOCK_BITS])
-        if not block_valid(w1, 1):
-            i += 1
-            continue
-        # Derive version from block B (bit 11 of the dataword)
-        b_data = block_dataword(w1)
-        version_b = bool((b_data >> 11) & 0x1)
-        # Block C: require the matching offset (C or C')
-        w2 = bits_to_word(bits[i + 2 * BLOCK_BITS : i + 3 * BLOCK_BITS])
-        if not block_valid(w2, 2, version_b=version_b):
-            i += 1
-            continue
-        # Block D
-        w3 = bits_to_word(bits[i + 3 * BLOCK_BITS : i + 4 * BLOCK_BITS])
-        if not block_valid(w3, 3):
-            i += 1
-            continue
-        buf = bytearray(8)
-        for idx, word in enumerate((w0, w1, w2, w3)):
-            dw = block_dataword(word)
-            buf[idx * 2] = (dw >> 8) & 0xFF
-            buf[idx * 2 + 1] = dw & 0xFF
-        groups.append(buf)
-        i += GROUP_BITS
+    if n < GROUP_BITS:
+        return groups
+
+    windows = np.lib.stride_tricks.sliding_window_view(bits, BLOCK_BITS)
+    words = _bits_to_words_26(windows, assume_binary=True)
+    data = (words >> CRC_BITS) & _DATA_WORD_MASK
+    check = words & _BLOCK_WORD_MASK
+    expected = _crc10_many(data)
+
+    valid_a = (check ^ OFFSET_A) == expected
+    valid_b = (check ^ OFFSET_B) == expected
+    valid_c = (check ^ OFFSET_C) == expected
+    valid_c_prime = (check ^ OFFSET_C_PRIME) == expected
+    valid_d = (check ^ OFFSET_D) == expected
+
+    start_count = n - GROUP_BITS + 1
+    block_b_data = data[BLOCK_BITS : BLOCK_BITS + start_count]
+    version_b = ((block_b_data >> 11) & 1).astype(bool)
+    block_c_valid = np.where(
+        version_b,
+        valid_c_prime[2 * BLOCK_BITS : 2 * BLOCK_BITS + start_count],
+        valid_c[2 * BLOCK_BITS : 2 * BLOCK_BITS + start_count],
+    )
+    group_starts = np.flatnonzero(
+        valid_a[:start_count]
+        & valid_b[BLOCK_BITS : BLOCK_BITS + start_count]
+        & block_c_valid
+        & valid_d[3 * BLOCK_BITS : 3 * BLOCK_BITS + start_count]
+    )
+
+    next_scan_start = 0
+    group_offsets = np.array([0, BLOCK_BITS, 2 * BLOCK_BITS, 3 * BLOCK_BITS], dtype=np.intp)
+    for start in group_starts:
+        group_start = int(start)
+        if group_start >= next_scan_start:
+            buf = bytearray(8)
+            for idx, dw_raw in enumerate(data[group_start + group_offsets]):
+                dw = int(dw_raw)
+                buf[idx * 2] = (dw >> 8) & 0xFF
+                buf[idx * 2 + 1] = dw & 0xFF
+            groups.append(buf)
+            next_scan_start = group_start + GROUP_BITS
     return groups
 
 
 def count_valid_blocks(bits: np.ndarray) -> int:
     """Diagnostic: count 26-bit windows that pass CRC for any block position 0..3."""
-    if not isinstance(bits, np.ndarray):
-        bits = np.asarray(bits, dtype=np.uint8)
+    bits = _coerce_bits(bits)
     total = 0
     for i in range(0, len(bits) - BLOCK_BITS + 1, BLOCK_BITS):
         word = bits_to_word(bits[i : i + BLOCK_BITS])

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock/rds_groups.py

@@ -13,6 +13,7 @@ Supported types:
     4A       — Clock-Time
 """
 
+from collections import deque
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -31,6 +32,10 @@ class StationInfo:
     pi: int | None = None
     pty: int | None = None
     ps_chars: list[str] = field(default_factory=lambda: [" "] * PS_LEN)
+    _ps_candidate: list[str] = field(default_factory=lambda: [" "] * PS_LEN)
+    _ps_segments_seen: int = 0
+    _ps_history: deque[str] = field(default_factory=lambda: deque(maxlen=4))
+    _ps_stable_count: int = 0
     rt_chars: list[str] = field(default_factory=lambda: [" "] * RT_LEN)
     rt_ab_flag: int | None = None
     clock_times: list[ClockTime] = field(default_factory=list)
@@ -38,8 +43,25 @@ class StationInfo:
 
     @property
     def ps_name(self) -> str:
+        """Validated Programme Service name.
+
+        Dynamic-PS stations often scroll text through the PS field. This value
+        remains empty until the same complete 8-character frame has been seen
+        in two consecutive PS completion cycles, then exposes the validated
+        frame with the historical right-padding stripped.
+        """
         return "".join(self.ps_chars).rstrip()
 
+    @property
+    def validated_ps_name(self) -> str:
+        """Alias for :attr:`ps_name`, explicit about the validation semantics."""
+        return self.ps_name
+
+    @property
+    def latest_ps_candidate(self) -> str:
+        """Most recently received complete 8-character PS frame, without validation."""
+        return self._ps_history[-1] if self._ps_history else ""
+
     @property
     def rt_text(self) -> str:
         text = "".join(self.rt_chars)
@@ -83,8 +105,23 @@ def parse_group(group_bytes: Sequence[int], info: StationInfo) -> StationInfo:
     if group_type == 0:
         seg = b & 0x3  # 2-bit segment address (0..3)
         # Block D carries two PS characters
-        info.ps_chars[seg * 2] = _safe_char((d >> 8) & 0xFF)
-        info.ps_chars[seg * 2 + 1] = _safe_char(d & 0xFF)
+        bit = 1 << seg
+        if not info._ps_segments_seen & bit:
+            info._ps_candidate[seg * 2] = _safe_char((d >> 8) & 0xFF)
+            info._ps_candidate[seg * 2 + 1] = _safe_char(d & 0xFF)
+            info._ps_segments_seen |= bit
+        if info._ps_segments_seen == 0b1111:
+            candidate = "".join(info._ps_candidate)
+            previous = info._ps_history[-1] if info._ps_history else None
+            info._ps_history.append(candidate)
+            if candidate == previous:
+                info._ps_stable_count += 1
+            else:
+                info._ps_stable_count = 1
+            if info._ps_stable_count >= 2:
+                info.ps_chars[:] = list(candidate)
+            info._ps_candidate = [" "] * PS_LEN
+            info._ps_segments_seen = 0
 
     elif group_type == 2:
         ab_flag = (b >> 4) & 0x1

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdsclock
-Version: 0.2.0
+Version: 0.2.2
 Summary: Passive RDS Clock-Time receiver for FM via RTL-SDR, with multi-source consensus for GPS-denied environments
 Author-email: Mateusz Klatt <mateusz@klatt.ie>
 License-Expression: Apache-2.0
@@ -26,6 +26,8 @@ Provides-Extra: audio
 Requires-Dist: sounddevice>=0.4.6; extra == "audio"
 Provides-Extra: plot
 Requires-Dist: matplotlib>=3.7.0; extra == "plot"
+Provides-Extra: fast
+Requires-Dist: numba>=0.60.0; extra == "fast"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"
 Requires-Dist: pytest-timeout>=2.1.0; extra == "dev"
@@ -265,11 +267,13 @@ the local antenna picks up.
 
 ## Status
 
-- **0.2.0** — current release. First version that decodes real FM
-  broadcasts (earlier 0.1.x worked only on synthetic IQ — see the
-  0.2.0 entry in [`CHANGELOG.md`](CHANGELOG.md)). Pre-1.0; the CLI
-  and on-disk formats may still change.
-- 236 tests including a real-IQ regression backed by a 6 s capture
+- **0.2.2** — current release. Operator-facing polish: 250 kS/s SDR
+  captures can now play at 48 kHz audio via rational resampling, and
+  Programme Service names are displayed only after validation so
+  dynamic-PS stations do not show mixed scrolling fragments. Decoder
+  group counts and PI codes remain locked to the 0.2.1 baseline.
+  Pre-1.0; the CLI and on-disk formats may still change.
+- 240+ tests including a real-IQ regression backed by a 6 s capture
   of Polskie Radio Trójka 98.8 from Warsaw; line coverage **100 %**
   (tracked by SonarCloud).
 

{rdsclock-0.2.0 → rdsclock-0.2.2}/src/rdsclock.egg-info/requires.txt

@@ -11,5 +11,8 @@ pytest-cov>=4.1.0
 ruff>=0.5.0
 black>=24.0
 
+[fast]
+numba>=0.60.0
+
 [plot]
 matplotlib>=3.7.0

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_audio.py

@@ -41,9 +41,10 @@ class TestDesignAudioFilter:
         assert taps.dtype == np.float32
         assert len(taps) == 129  # default numtaps
 
-    def test_rejects_non_integer_ratio(self):
-        with pytest.raises(ValueError):
-            design_audio_filter(1_000_000, 48_000)
+    def test_non_integer_ratio_returns_filter_without_decimation(self):
+        taps, decim = design_audio_filter(1_000_000, 48_000)
+        assert decim == 1
+        assert taps.dtype == np.float32
 
 
 class TestFmAudioFromIq:
@@ -65,6 +66,18 @@ class TestFmAudioFromIq:
         # Normalisation pushes peak to 0.5.
         assert np.max(np.abs(audio)) == pytest.approx(0.5, rel=0.01)
 
+    def test_rational_resampling_ratio_succeeds(self):
+        fs_in = 250_000
+        fs_out = 48_000
+        n = np.arange(fs_in // 10)
+        iq = np.exp(1j * 2 * np.pi * 1_000 * n / fs_in).astype(np.complex64)
+
+        audio = fm_audio_from_iq(iq, fs_in=fs_in, fs_out=fs_out)
+
+        expected_len = len(iq) * fs_out / fs_in
+        assert abs(len(audio) - expected_len) <= 2
+        assert audio.dtype == np.float32
+
     def test_skip_normalisation(self):
         fs_in = 1_200_000
         n = np.arange(fs_in // 2)

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_coverage_edges.py

@@ -160,7 +160,7 @@ def test_audio_play_file_complex64_and_u8_paths(tmp_path, monkeypatch):
     u8_path = tmp_path / "u8-ish.iq"
     np.full(512, 200 + 0j, dtype=np.complex64).tofile(u8_path)
     play_iq_file(str(u8_path), fs_in=50_000, fs_audio=48_000)
-    assert sd.play_calls[-1][1] == 2_000
+    assert sd.play_calls[-1][1] == 48_000
 
 
 def test_audio_play_file_keyboard_interrupt_stops(tmp_path, monkeypatch, capsys):
@@ -207,6 +207,31 @@ def test_audio_play_live_streams_until_keyboard_interrupt(
     assert "Interrupted" in capsys.readouterr().out
 
 
+def test_audio_play_live_supports_rational_audio_rate(monkeypatch, capsys):
+    sd = _FakeSoundDevice()
+    clients: list[_FakeAudioClient] = []
+
+    class RecordingClient(_FakeAudioClient):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            clients.append(self)
+
+    monkeypatch.setitem(sys.modules, "sounddevice", sd)
+    monkeypatch.setattr("rdsclock.audio.RtlTcpClient", RecordingClient)
+
+    play_iq_live(
+        95.5,
+        fs_sdr=50_000,
+        fs_audio=48_000,
+        chunk_samples=256,
+    )
+
+    assert ("sample_rate", 50_000) in clients[0].calls
+    assert sd.stream_writes
+    assert sd.stream_writes[0].dtype == np.float32
+    assert "Interrupted" in capsys.readouterr().out
+
+
 @pytest.mark.parametrize("func,args", [(play_iq_file, ("x.iq",)), (play_iq_live, (95.5,))])
 def test_audio_play_requires_sounddevice(func, args, monkeypatch):
     real_import = builtins.__import__

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_coverage_extra.py

@@ -171,7 +171,7 @@ class TestAudioPlaybackCoverage:
         ):
             audio.play_iq_file("recording.iq", fs_in=250_000, fs_audio=48_000)
 
-        fm_audio_from_iq.assert_called_once_with(iq, fs_in=250_000, fs_out=2_000)
+        fm_audio_from_iq.assert_called_once_with(iq, fs_in=250_000, fs_out=48_000)
         sd_stop.assert_called_once()
 
 

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_dsp.py

@@ -78,6 +78,19 @@ class TestCostas:
         # After a short transient, the signal still has constant phase
         assert np.max(np.abs(np.imag(out[20:]))) < 1.0
 
+    def test_python_fallback_matches_public_wrapper(self, monkeypatch):
+        samples = np.array([1 + 0j, 0.5 + 0.2j, -1 + 0.1j], dtype=np.complex64)
+        monkeypatch.setattr(dsp, "_COSTAS_LOOP_BPSK_NUMBA", None)
+        wrapper = dsp.costas_loop_bpsk(samples, alpha=0.1, beta=0.002)
+        direct = dsp._costas_loop_bpsk_python(samples, alpha=0.1, beta=0.002)
+        np.testing.assert_array_equal(wrapper, direct)
+
+    def test_python_fallback_wraps_phase_both_directions(self):
+        positive = np.array([1 + 1j, 1 + 0j], dtype=np.complex64)
+        negative = np.array([1 - 1j, 1 + 0j], dtype=np.complex64)
+        assert dsp._costas_loop_bpsk_python(positive, alpha=4.0, beta=0.0).shape == positive.shape
+        assert dsp._costas_loop_bpsk_python(negative, alpha=4.0, beta=0.0).shape == negative.shape
+
 
 class TestBiphaseRecovery:
     def test_agc_normalizes_mean_magnitude(self):

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_rds_blocks.py

@@ -10,6 +10,8 @@ from rdsclock.rds_blocks import (
     OFFSET_C,
     OFFSET_C_PRIME,
     OFFSETS,
+    _bits_to_words_26,
+    _crc10_many,
     bits_to_word,
     block_dataword,
     block_valid,
@@ -25,6 +27,19 @@ from rdsclock.rds_blocks import (
 )
 
 
+def _crc10_reference(dataword: int) -> int:
+    reg = 0
+    for i in range(DATA_BITS - 1, -1, -1):
+        reg = (reg << 1) | ((dataword >> i) & 1)
+        if reg & (1 << 10):
+            reg ^= 0x5B9 | (1 << 10)
+    for _ in range(10):
+        reg <<= 1
+        if reg & (1 << 10):
+            reg ^= 0x5B9 | (1 << 10)
+    return reg & ((1 << 10) - 1)
+
+
 class TestCrc10:
     def test_zero_input(self):
         assert crc10(0) == 0
@@ -45,6 +60,16 @@ class TestCrc10:
         b = crc10(0x1235)
         assert a != b
 
+    def test_matches_shift_register_for_full_u16_space(self):
+        expected = np.fromiter(
+            (_crc10_reference(v) for v in range(1 << DATA_BITS)),
+            dtype=np.uint16,
+            count=1 << DATA_BITS,
+        )
+        actual = _crc10_many(np.arange(1 << DATA_BITS, dtype=np.uint32))
+        np.testing.assert_array_equal(actual, expected)
+        assert crc10(0x1FFFF) == int(expected[-1])
+
 
 class TestEncodeBlock:
     def test_roundtrip(self):
@@ -116,6 +141,14 @@ class TestBitstream:
         bits = [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0]
         assert bits_to_word(bits) == 0xCCCC
 
+    def test_bits_to_word_26_uses_vectorized_weights(self):
+        bits = np.array(
+            [1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1],
+            dtype=np.uint8,
+        )
+        assert bits_to_word(bits) == 0b10110010101011100101101001
+        np.testing.assert_array_equal(_bits_to_words_26(bits[None, :]), [bits_to_word(bits)])
+
     def test_find_groups_in_clean_bitstream(self):
         # Encode 3 groups with different data, then find them all.
         all_blocks = []
@@ -152,6 +185,9 @@ class TestBitstream:
             a, _, _, _ = group_bytes_to_words(g)
             assert a in (0xBABE, 0xCAFE)
 
+    def test_find_groups_short_stream_returns_empty(self):
+        assert find_groups_in_bitstream(np.zeros(GROUP_BITS - 1, dtype=np.uint8)) == []
+
 
 class TestDifferential:
     def test_roundtrip(self):

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_rds_groups.py

@@ -14,30 +14,80 @@ from rdsclock.rds_groups import (
 )
 
 
+def _validated_ps_groups(pi: int, ps_name: str) -> list[bytearray]:
+    groups = encode_ps_groups(pi=pi, ps_name=ps_name)
+    return groups + groups
+
+
 class TestPsParsing:
     def test_single_segment(self):
         g = encode_group_0a(pi=0xABCD, ps_segment_index=0, ps_chars="RM")
         info = StationInfo()
         parse_group(g, info)
         assert info.pi == 0xABCD
-        assert info.ps_name == "RM"
+        assert info.ps_name == ""
+        assert info.latest_ps_candidate == ""
 
     def test_all_segments(self):
-        groups = encode_ps_groups(pi=0x3F44, ps_name="RMF FM  ")
+        groups = _validated_ps_groups(pi=0x3F44, ps_name="RMF FM  ")
         info = parse_groups(groups)
         assert info.pi == 0x3F44
         assert info.ps_name == "RMF FM"
+        assert info.validated_ps_name == "RMF FM"
+        assert info.latest_ps_candidate == "RMF FM  "
 
     def test_short_name_padded(self):
-        groups = encode_ps_groups(pi=0x1234, ps_name="ABC")
+        groups = _validated_ps_groups(pi=0x1234, ps_name="ABC")
         info = parse_groups(groups)
         assert info.ps_name == "ABC"
 
     def test_full_eight_chars(self):
-        groups = encode_ps_groups(pi=0x4321, ps_name="RadioZET")
+        groups = _validated_ps_groups(pi=0x4321, ps_name="RadioZET")
         info = parse_groups(groups)
         assert info.ps_name == "RadioZET"
 
+    def test_single_rotation_is_only_latest_candidate(self):
+        groups = encode_ps_groups(pi=0x3001, ps_name="JEDYNKA ")
+        info = parse_groups(groups)
+        assert info.ps_name == ""
+        assert info.latest_ps_candidate == "JEDYNKA "
+        assert info._ps_stable_count == 1
+
+    def test_static_ps_validates_after_two_rotations(self):
+        groups = _validated_ps_groups(pi=0x3001, ps_name="JEDYNKA ")
+        info = parse_groups(groups)
+        assert info.ps_name == "JEDYNKA"
+        assert info.validated_ps_name == "JEDYNKA"
+        assert info.latest_ps_candidate == "JEDYNKA "
+
+    def test_dynamic_ps_requires_consecutive_matching_completions(self):
+        plus = encode_ps_groups(pi=0x3002, ps_name="+PLUS+  ")
+        web = encode_ps_groups(pi=0x3002, ps_name="WWW.RPL ")
+        info = parse_groups(plus + web + plus)
+        assert info.ps_name == ""
+        assert info.latest_ps_candidate == "+PLUS+  "
+        assert info._ps_stable_count == 1
+
+        for group in plus:
+            parse_group(group, info)
+
+        assert info.ps_name == "+PLUS+"
+        assert info.latest_ps_candidate == "+PLUS+  "
+        assert list(info._ps_history) == ["+PLUS+  ", "WWW.RPL ", "+PLUS+  ", "+PLUS+  "]
+
+    def test_duplicate_segment_does_not_overwrite_candidate_rotation(self):
+        groups = [
+            encode_group_0a(pi=0x3003, ps_segment_index=0, ps_chars="JE"),
+            encode_group_0a(pi=0x3003, ps_segment_index=0, ps_chars="XX"),
+            encode_group_0a(pi=0x3003, ps_segment_index=1, ps_chars="DY"),
+            encode_group_0a(pi=0x3003, ps_segment_index=2, ps_chars="NK"),
+            encode_group_0a(pi=0x3003, ps_segment_index=3, ps_chars="A "),
+        ]
+        info = parse_groups(groups + groups)
+        assert info.ps_name == "JEDYNKA"
+        assert info.latest_ps_candidate == "JEDYNKA "
+        assert info._ps_segments_seen == 0
+
     def test_group_count(self):
         groups = encode_ps_groups(pi=0x1111, ps_name="HELLO   ")
         info = parse_groups(groups)

{rdsclock-0.2.0 → rdsclock-0.2.2}/tests/test_synth.py

@@ -35,7 +35,7 @@ class TestBitstreamSynth:
         bits = rds_groups_to_bits(ps, differential=False)  # no differential coding for simplicity
         groups = find_groups_in_bitstream(bits)
         assert len(groups) >= len(ps)
-        info = parse_groups(groups[: len(ps)])
+        info = parse_groups(groups[: len(ps)] + groups[: len(ps)])
         assert info.pi == 0xCAFE
         assert info.ps_name == "HELLO"