feat(tui): implement SomaFM terminal radio player
This commit is contained in:
beefcarver committed
1 parent
941e45a20f
commit
237de2efe9
21 files changed
+4937
No files matched your search
@@ -0,0 +1,534 @@
|
||||
"""Spectrum analyser.
|
||||
|
||||
The audio you hear is played by mpv. The *synced* mode captures the real
|
||||
PulseAudio/PipeWire monitor of the sink mpv is playing to (``parec``), so the
|
||||
bars follow exactly what leaves the speakers (status ``SYNC``).
|
||||
|
||||
If that is unavailable we fall back to a muted second ffmpeg decode of the
|
||||
stream (status ``FFT``; it can drift relative to playback), and finally to a
|
||||
synthesized show (``SIM``) so the UI stays alive.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import math
|
||||
import os
|
||||
import select
|
||||
import shutil
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .api import USER_AGENT
|
||||
|
||||
SAMPLE_RATE = 44100
|
||||
FFT_SIZE = 2048
|
||||
READ_BYTES = 4096 # 2048 mono s16le samples
|
||||
BAND_COUNT = 72
|
||||
WAVE_POINTS = 192
|
||||
MIN_FREQ = 35.0
|
||||
MAX_FREQ = 16000.0
|
||||
SOURCE_MODES = ("auto", "monitor", "stream", "sim")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Frame:
|
||||
bands: tuple[float, ...]
|
||||
peaks: tuple[float, ...]
|
||||
wave: tuple[float, ...]
|
||||
level: float
|
||||
status: str # "monitor" | "live" | "sim" | "idle" | "off"
|
||||
|
||||
@property
|
||||
def is_live(self) -> bool:
|
||||
return self.status in ("monitor", "live")
|
||||
|
||||
@property
|
||||
def label(self) -> str:
|
||||
return {
|
||||
"monitor": "SYNC",
|
||||
"live": "FFT",
|
||||
"sim": "SIM",
|
||||
"idle": "IDLE",
|
||||
"off": "OFF",
|
||||
}.get(self.status, self.status.upper())
|
||||
|
||||
|
||||
class SpectrumEngine:
|
||||
def __init__(
|
||||
self,
|
||||
bands: int = BAND_COUNT,
|
||||
sample_rate: int = SAMPLE_RATE,
|
||||
fft_size: int = FFT_SIZE,
|
||||
wave_points: int = WAVE_POINTS,
|
||||
ffmpeg_path: str | None = None,
|
||||
source_mode: str = "auto",
|
||||
) -> None:
|
||||
self.band_count = bands
|
||||
self.sample_rate = sample_rate
|
||||
self.fft_size = fft_size
|
||||
self.wave_points = wave_points
|
||||
self.source_mode = source_mode if source_mode in SOURCE_MODES else "auto"
|
||||
self._ffmpeg = ffmpeg_path if ffmpeg_path is not None else shutil.which("ffmpeg")
|
||||
self._parec = shutil.which("parec")
|
||||
self._pactl = shutil.which("pactl")
|
||||
|
||||
self._window = np.hanning(fft_size).astype(np.float32)
|
||||
self._groups = self._make_groups()
|
||||
self._history = np.zeros(fft_size, dtype=np.float32)
|
||||
self._levels = np.zeros(bands, dtype=np.float32)
|
||||
self._peaks = np.zeros(bands, dtype=np.float32)
|
||||
self._wave = np.zeros(wave_points, dtype=np.float32)
|
||||
self._level = 0.0
|
||||
self._gain = -24.0
|
||||
self._status = "idle"
|
||||
|
||||
self._url: str | None = None
|
||||
self._proc: subprocess.Popen[bytes] | None = None
|
||||
self._capture_kind: str | None = None
|
||||
self._monitor_failed = False
|
||||
self._monitor_device_cache: str | None = None
|
||||
self._lock = threading.Lock()
|
||||
self._stop = threading.Event()
|
||||
self._thread: threading.Thread | None = None
|
||||
self._rng = np.random.default_rng()
|
||||
self._sim_phase = 0.0
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# public API
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
@property
|
||||
def ffmpeg_available(self) -> bool:
|
||||
return bool(self._ffmpeg)
|
||||
|
||||
@property
|
||||
def monitor_available(self) -> bool:
|
||||
return bool(self._parec) and not self._monitor_failed
|
||||
|
||||
def start(self) -> None:
|
||||
if self._thread is not None:
|
||||
return
|
||||
self._thread = threading.Thread(
|
||||
target=self._run, name="somafm-spectrum", daemon=True
|
||||
)
|
||||
self._thread.start()
|
||||
|
||||
def set_source(self, url: str | None) -> None:
|
||||
"""Start analysing playback, or idle when ``url`` is ``None``.
|
||||
|
||||
The URL is only a fallback source for the stream tap. A monitor
|
||||
capture is tied to the actual audio output, so it deliberately keeps
|
||||
running when the station changes underneath it.
|
||||
"""
|
||||
url = url or None
|
||||
with self._lock:
|
||||
changed = url != self._url
|
||||
self._url = url
|
||||
kind = self._capture_kind
|
||||
if url is None:
|
||||
self._status = "idle"
|
||||
if changed and (url is None or kind != "monitor"):
|
||||
self._kill_proc()
|
||||
|
||||
def snapshot(self) -> Frame:
|
||||
with self._lock:
|
||||
return Frame(
|
||||
bands=tuple(float(v) for v in self._levels),
|
||||
peaks=tuple(float(v) for v in self._peaks),
|
||||
wave=tuple(float(v) for v in self._wave),
|
||||
level=float(self._level),
|
||||
status=self._status,
|
||||
)
|
||||
|
||||
def stop(self) -> None:
|
||||
self._stop.set()
|
||||
self._kill_proc()
|
||||
thread = self._thread
|
||||
if thread is not None and thread.is_alive():
|
||||
thread.join(timeout=2.0)
|
||||
self._thread = None
|
||||
with self._lock:
|
||||
self._status = "off"
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# internals
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _make_groups(self) -> list[tuple[int, int]]:
|
||||
freqs = np.fft.rfftfreq(self.fft_size, 1.0 / self.sample_rate)
|
||||
top = min(MAX_FREQ, self.sample_rate / 2 - 100)
|
||||
edges = np.geomspace(MIN_FREQ, top, self.band_count + 1)
|
||||
groups: list[tuple[int, int]] = []
|
||||
last = len(freqs) - 1
|
||||
for index in range(self.band_count):
|
||||
lo = int(np.searchsorted(freqs, edges[index], side="left"))
|
||||
hi = int(np.searchsorted(freqs, edges[index + 1], side="left"))
|
||||
lo = min(max(lo, 0), last)
|
||||
hi = min(max(hi, lo + 1), len(freqs))
|
||||
groups.append((lo, hi))
|
||||
return groups
|
||||
|
||||
def _read_url(self) -> str | None:
|
||||
with self._lock:
|
||||
return self._url
|
||||
|
||||
def _kill_proc(self) -> None:
|
||||
with self._lock:
|
||||
proc = self._proc
|
||||
self._proc = None
|
||||
self._capture_kind = None
|
||||
if proc is not None:
|
||||
with contextlib.suppress(OSError):
|
||||
proc.kill()
|
||||
with contextlib.suppress(Exception):
|
||||
proc.wait(timeout=1)
|
||||
|
||||
def _use_monitor(self) -> bool:
|
||||
if self._monitor_failed:
|
||||
return False
|
||||
if self.source_mode == "sim":
|
||||
return False
|
||||
if self.source_mode == "stream":
|
||||
return False
|
||||
return bool(self._parec)
|
||||
|
||||
def _monitor_device(self) -> str:
|
||||
override = os.environ.get("SOMAFM_SPECTRUM_DEVICE", "").strip()
|
||||
if override:
|
||||
return override
|
||||
if self._monitor_device_cache is not None:
|
||||
return self._monitor_device_cache
|
||||
if self._pactl:
|
||||
try:
|
||||
result = subprocess.run(
|
||||
[self._pactl, "get-default-sink"],
|
||||
stdin=subprocess.DEVNULL,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.DEVNULL,
|
||||
text=True,
|
||||
timeout=1.0,
|
||||
check=False,
|
||||
)
|
||||
sink = result.stdout.strip()
|
||||
if result.returncode == 0 and sink:
|
||||
self._monitor_device_cache = f"{sink}.monitor"
|
||||
return self._monitor_device_cache
|
||||
except (OSError, subprocess.SubprocessError):
|
||||
pass
|
||||
self._monitor_device_cache = "@DEFAULT_MONITOR@"
|
||||
return self._monitor_device_cache
|
||||
|
||||
def _monitor_command(self) -> list[str] | None:
|
||||
if not self._parec:
|
||||
return None
|
||||
return [
|
||||
self._parec,
|
||||
f"--device={self._monitor_device()}",
|
||||
"--format=s16le",
|
||||
"--rate=44100",
|
||||
"--channels=1",
|
||||
"--raw",
|
||||
"--latency-msec=30",
|
||||
"--client-name=somafm-tui",
|
||||
]
|
||||
|
||||
def _spawn(
|
||||
self, command: list[str], kind: str
|
||||
) -> subprocess.Popen[bytes] | None:
|
||||
try:
|
||||
proc = subprocess.Popen(
|
||||
command,
|
||||
stdin=subprocess.DEVNULL,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.DEVNULL,
|
||||
bufsize=0,
|
||||
start_new_session=True,
|
||||
)
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
with self._lock:
|
||||
self._proc = proc
|
||||
self._capture_kind = kind
|
||||
self._status = "monitor" if kind == "monitor" else "live"
|
||||
return proc
|
||||
|
||||
def _stop_proc(self, proc: subprocess.Popen[bytes]) -> None:
|
||||
with self._lock:
|
||||
if self._proc is proc:
|
||||
self._proc = None
|
||||
self._capture_kind = None
|
||||
with contextlib.suppress(OSError):
|
||||
proc.kill()
|
||||
with contextlib.suppress(Exception):
|
||||
proc.wait(timeout=1)
|
||||
|
||||
def _run(self) -> None:
|
||||
while not self._stop.is_set():
|
||||
url = self._read_url()
|
||||
if not url:
|
||||
self._idle_frame()
|
||||
self._stop.wait(0.05)
|
||||
continue
|
||||
|
||||
if self.source_mode == "sim":
|
||||
self._simulate_for(url, 0.05)
|
||||
continue
|
||||
|
||||
if self._use_monitor():
|
||||
command = self._monitor_command()
|
||||
proc = self._spawn(command, "monitor") if command else None
|
||||
if proc is not None:
|
||||
self._capture(
|
||||
proc, url, stop_on_url_change=False, status="monitor"
|
||||
)
|
||||
self._stop_proc(proc)
|
||||
if self._stop.is_set():
|
||||
break
|
||||
if self._read_url() is None:
|
||||
continue
|
||||
# The monitor device failed (or vanished). Use the stream
|
||||
# tap for the rest of the session.
|
||||
self._monitor_failed = True
|
||||
with self._lock:
|
||||
self._status = "sim"
|
||||
continue
|
||||
self._monitor_failed = True
|
||||
|
||||
if not self._ffmpeg:
|
||||
self._simulate_for(url, 0.05)
|
||||
continue
|
||||
|
||||
proc = self._spawn(self._command(url), "stream")
|
||||
if proc is None:
|
||||
with self._lock:
|
||||
self._status = "sim"
|
||||
self._simulate_for(url, 0.06, duration=5.0)
|
||||
continue
|
||||
self._capture(proc, url, stop_on_url_change=True, status="live")
|
||||
self._stop_proc(proc)
|
||||
|
||||
if self._stop.is_set():
|
||||
break
|
||||
if self._read_url() == url:
|
||||
with self._lock:
|
||||
self._status = "sim"
|
||||
self._simulate_for(url, 0.06, duration=12.0)
|
||||
|
||||
def _command(self, url: str) -> list[str]:
|
||||
return [
|
||||
self._ffmpeg or "ffmpeg",
|
||||
"-hide_banner",
|
||||
"-loglevel",
|
||||
"error",
|
||||
"-nostdin",
|
||||
"-reconnect",
|
||||
"1",
|
||||
"-reconnect_streamed",
|
||||
"1",
|
||||
"-reconnect_at_eof",
|
||||
"1",
|
||||
"-reconnect_delay_max",
|
||||
"5",
|
||||
"-fflags",
|
||||
"nobuffer",
|
||||
"-flags",
|
||||
"low_delay",
|
||||
"-probesize",
|
||||
"32768",
|
||||
"-analyzeduration",
|
||||
"0",
|
||||
"-user_agent",
|
||||
USER_AGENT,
|
||||
"-i",
|
||||
url,
|
||||
"-map",
|
||||
"0:a:0",
|
||||
"-vn",
|
||||
"-ac",
|
||||
"1",
|
||||
"-ar",
|
||||
str(self.sample_rate),
|
||||
"-f",
|
||||
"s16le",
|
||||
"-acodec",
|
||||
"pcm_s16le",
|
||||
"-",
|
||||
]
|
||||
|
||||
def _capture(
|
||||
self,
|
||||
proc: subprocess.Popen[bytes],
|
||||
url: str,
|
||||
*,
|
||||
stop_on_url_change: bool,
|
||||
status: str,
|
||||
) -> bool:
|
||||
"""Read PCM until playback stops, the source changes, or the process dies."""
|
||||
stdout = proc.stdout
|
||||
if stdout is None:
|
||||
return False
|
||||
fd = stdout.fileno()
|
||||
got_data = False
|
||||
buffer = bytearray()
|
||||
while not self._stop.is_set():
|
||||
current = self._read_url()
|
||||
if current is None:
|
||||
break
|
||||
if stop_on_url_change and current != url:
|
||||
break
|
||||
|
||||
# A monitor can go quiet if the device disappears; don't block the
|
||||
# analyser thread forever. os.read returns whatever is available
|
||||
# (instead of waiting for a full 4 KiB), which keeps latency low.
|
||||
if status == "monitor" and os.name == "posix":
|
||||
try:
|
||||
ready, _, _ = select.select([fd], [], [], 2.0)
|
||||
except (OSError, ValueError):
|
||||
ready = [fd]
|
||||
if not ready:
|
||||
break
|
||||
|
||||
try:
|
||||
data = os.read(fd, READ_BYTES)
|
||||
except OSError:
|
||||
break
|
||||
if not data:
|
||||
break
|
||||
buffer.extend(data)
|
||||
# Process fixed-size blocks so attack/decay smoothing is tied to
|
||||
# time (~46 ms per block), regardless of how the pipe fragments.
|
||||
while len(buffer) >= READ_BYTES:
|
||||
block = bytes(buffer[:READ_BYTES])
|
||||
del buffer[:READ_BYTES]
|
||||
got_data = True
|
||||
self.feed_pcm(block, status)
|
||||
return got_data
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# signal processing
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def feed_pcm(self, data: bytes, status: str = "live") -> None:
|
||||
"""Feed raw little-endian mono s16 PCM (also used by the tests)."""
|
||||
if not data or len(data) < 2:
|
||||
return
|
||||
usable = len(data) - (len(data) % 2)
|
||||
try:
|
||||
samples = np.frombuffer(data[:usable], dtype="<i2")
|
||||
except ValueError:
|
||||
return
|
||||
if samples.size == 0:
|
||||
return
|
||||
self._process(samples.astype(np.float32) / 32768.0, status)
|
||||
|
||||
def _process(self, samples: np.ndarray, status: str = "live") -> None:
|
||||
size = self.fft_size
|
||||
if samples.size >= size:
|
||||
self._history[:] = samples[-size:]
|
||||
else:
|
||||
count = samples.size
|
||||
self._history[:-count] = self._history[count:]
|
||||
self._history[-count:] = samples
|
||||
chunk = self._history
|
||||
|
||||
spectrum = np.abs(np.fft.rfft(chunk * self._window))
|
||||
spectrum /= size * 0.5
|
||||
db = 20.0 * np.log10(spectrum + 1e-9)
|
||||
values = np.array(
|
||||
[db[lo:hi].max() for lo, hi in self._groups], dtype=np.float32
|
||||
)
|
||||
|
||||
peak_db = float(values.max())
|
||||
self._gain = max(peak_db, self._gain - 0.35)
|
||||
floor = self._gain - 42.0
|
||||
norm = np.clip((values - floor) / 42.0, 0.0, 1.0) ** 1.4
|
||||
|
||||
rms = float(np.sqrt(np.mean(np.square(chunk)) + 1e-12))
|
||||
level = float(np.clip((20.0 * math.log10(rms + 1e-9) + 55.0) / 45.0, 0.0, 1.0))
|
||||
wave = self._downsample(chunk)
|
||||
self._apply(norm.astype(np.float32), wave, level, status)
|
||||
|
||||
def _downsample(self, samples: np.ndarray) -> np.ndarray:
|
||||
target = self.wave_points
|
||||
if samples.size < target:
|
||||
padded = np.zeros(target, dtype=np.float32)
|
||||
padded[-samples.size :] = samples
|
||||
samples = padded
|
||||
step = max(1, samples.size // target)
|
||||
trimmed = samples[samples.size - step * target :]
|
||||
try:
|
||||
folded = trimmed.reshape(target, step).mean(axis=1)
|
||||
except ValueError:
|
||||
return np.zeros(target, dtype=np.float32)
|
||||
peak = float(np.max(np.abs(folded)))
|
||||
if peak > 1e-4:
|
||||
folded = folded / peak
|
||||
return np.clip(folded, -1.0, 1.0).astype(np.float32)
|
||||
|
||||
def _apply(
|
||||
self, values: np.ndarray, wave: np.ndarray, level: float, status: str
|
||||
) -> None:
|
||||
with self._lock:
|
||||
self._levels = np.maximum(values, self._levels * 0.65).astype(np.float32)
|
||||
self._peaks = np.maximum(values, self._peaks - 0.04).astype(np.float32)
|
||||
self._wave = (self._wave * 0.55 + wave * 0.45).astype(np.float32)
|
||||
self._level = float(self._level * 0.5 + level * 0.5)
|
||||
self._status = status
|
||||
|
||||
def _idle_frame(self) -> None:
|
||||
with self._lock:
|
||||
self._levels = (self._levels * 0.86).astype(np.float32)
|
||||
self._peaks = np.maximum(self._peaks - 0.02, 0.0).astype(np.float32)
|
||||
self._wave = (self._wave * 0.8).astype(np.float32)
|
||||
self._level *= 0.9
|
||||
self._status = "idle"
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# simulation
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _simulate_for(
|
||||
self, url: str, delay: float, duration: float | None = None
|
||||
) -> None:
|
||||
deadline = None if duration is None else time.monotonic() + duration
|
||||
while not self._stop.is_set():
|
||||
if self._read_url() != url:
|
||||
return
|
||||
self._simulate_step()
|
||||
if self._stop.wait(delay):
|
||||
return
|
||||
if deadline is not None and time.monotonic() >= deadline:
|
||||
return
|
||||
|
||||
def _simulate_step(self) -> None:
|
||||
self._sim_phase += 0.16
|
||||
t = self._sim_phase
|
||||
index = np.linspace(0.0, 1.0, self.band_count, dtype=np.float32)
|
||||
|
||||
humps = np.exp(-((index - 0.16) ** 2) / 0.020) * 0.58
|
||||
humps += np.exp(-((index - 0.46) ** 2) / 0.055) * 0.34
|
||||
humps += np.exp(-((index - 0.80) ** 2) / 0.130) * 0.20
|
||||
|
||||
motion = 0.55 + 0.45 * np.sin(t * 1.9 + index * 11.0)
|
||||
noise = self._rng.random(self.band_count, dtype=np.float32) * 0.22
|
||||
beat_phase = (t * 0.55) % 1.0
|
||||
beat = math.exp(-(beat_phase / 0.16)) * 0.28 * np.exp(-(index**2) / 0.03)
|
||||
|
||||
values = np.clip((humps * motion + noise + beat), 0.02, 1.0)
|
||||
values = np.clip(values * (1.15 - 0.25 * index), 0.0, 1.0).astype(np.float32)
|
||||
|
||||
points = np.linspace(0.0, 2.0 * math.pi * 7.0, self.wave_points)
|
||||
wave = 0.42 * np.sin(points + t * 3.0) * (0.6 + 0.4 * math.sin(t * 0.7))
|
||||
wave += 0.20 * np.sin(points * 1.9 + t * 4.3)
|
||||
wave += self._rng.normal(0.0, 0.05, self.wave_points)
|
||||
wave = np.clip(wave, -1.0, 1.0).astype(np.float32)
|
||||
|
||||
level = float(
|
||||
min(1.0, 0.32 + 0.14 * math.sin(t * 1.7) + 0.25 * math.exp(-(beat_phase / 0.2)))
|
||||
)
|
||||
self._apply(values, wave, level, "sim")
|
||||
Reference in new issue
Block a user