Something went wrong. Try again.
Real-time terminal equalizer for raw PCM pipes — Rockbox 10-band EQ + bass/treble
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397//! Remote [`Controller`]: the TUI talking to another equalizer process//! over its gRPC control API (unix socket or TCP).//!//! The TUI thread is synchronous, so the tonic client lives on a small//! background tokio runtime. Edits are applied optimistically to a local//! mirror (so sliders move instantly) and queued to the server in order;//! a `WatchState` stream keeps the mirror authoritative — including edits//! made by other clients or the server's own TUI.
use std::sync::atomic::{AtomicUsize, Ordering};use std::sync::{Arc, Mutex};use std::time::Duration;
use anyhow::{Context, Result};use hyper_util::rt::TokioIo;use tokio::sync::mpsc;use tonic::Request;use tonic::service::interceptor::InterceptedService;use tonic::transport::{Channel, Endpoint, Uri};
use crate::api::equalizer::v1 as pb;use crate::api::equalizer::v1::equalizer_service_client::EqualizerServiceClient;use crate::control::{Controller, EqSnapshot, PlayStatus};use crate::equalizer::{GAIN_MAX_TENTHS, GAIN_MIN_TENTHS, TONE_MAX_DB, TONE_MIN_DB};use crate::settings::{EQ_BANDS, EqBand, default_socket_path};use crate::ui::StreamInfo;
/// Adds `authorization: Bearer <token>` to every call when a token is set/// (required by remote servers' TCP endpoint, ignored on unix sockets).#[derive(Clone)]struct ClientAuth { header: Option<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>,}
impl tonic::service::Interceptor for ClientAuth { fn call(&mut self, mut request: Request<()>) -> Result<Request<()>, tonic::Status> { if let Some(header) = &self.header { request .metadata_mut() .insert("authorization", header.clone()); } Ok(request) }}
type Client = EqualizerServiceClient<InterceptedService<Channel, ClientAuth>>;
/// Local copy of the server state the TUI reads every frame.struct Mirror { enabled: bool, bands: Vec<EqBand>, bass: i32, treble: i32, play_state: u8, server_error: Option<String>, frames_played: u64, peak_l: i32, peak_r: i32, /// Transport problem (lost stream, failed RPC); shown in place of the /// server error until the connection recovers. conn_error: Option<String>,}
enum Cmd { SetEnabled(bool), AdjustBand(usize, i32), AdjustTone(i32, i32), SetGainsDb([i32; EQ_BANDS]), Reset, Save,}
pub struct RemoteController { mirror: Arc<Mutex<Mirror>>, cmds: mpsc::UnboundedSender<Cmd>, /// Commands sent but not yet acknowledged; while nonzero, watch /// updates skip the EQ fields so a stale snapshot can't briefly undo /// an optimistic local edit. pending: Arc<AtomicUsize>, /// Keeps the client runtime (and its background tasks) alive for the /// controller's lifetime. _rt: tokio::runtime::Runtime,}
/// Dial `addr` and fetch the initial state. `addr` forms: "" (the default/// local socket), "unix:PATH", a bare path, "host:port", or an/// "http://host:port" URL.pub fn connect(addr: &str, token: Option<String>) -> Result<(RemoteController, StreamInfo)> { let rt = tokio::runtime::Builder::new_multi_thread() .worker_threads(1) .enable_all() .build() .context("failed to start client runtime")?;
let header = match &token { Some(t) => Some( format!("Bearer {t}") .parse() .context("token contains characters not allowed in a header")?, ), None => None, }; let auth = ClientAuth { header };
let channel = rt .block_on(dial(addr)) .with_context(|| format!("cannot connect to {}", describe(addr)))?; let mut client = EqualizerServiceClient::with_interceptor(channel, auth);
let initial = rt .block_on(client.get_state(pb::GetStateRequest {})) .with_context(|| format!("GetState failed on {}", describe(addr)))? .into_inner();
let stream = initial.stream.clone().unwrap_or_default(); let info = StreamInfo { input: format!("{} ⇄ {}", describe(addr), stream.input), format: stream.format, in_rate: stream.in_rate, out_rate: stream.out_rate, device: stream.device, };
let mirror = Arc::new(Mutex::new(Mirror { enabled: false, bands: Vec::new(), bass: 0, treble: 0, play_state: 0, server_error: None, frames_played: 0, peak_l: 0, peak_r: 0, conn_error: None, })); apply_state(&mut mirror.lock().unwrap(), &initial, true);
let pending = Arc::new(AtomicUsize::new(0)); let (tx, rx) = mpsc::unbounded_channel();
rt.spawn(watch_loop( client.clone(), Arc::clone(&mirror), Arc::clone(&pending), )); rt.spawn(command_loop( client, rx, Arc::clone(&mirror), Arc::clone(&pending), ));
Ok(( RemoteController { mirror, cmds: tx, pending, _rt: rt, }, info, ))}
/// Human-readable target for status/error messages.fn describe(addr: &str) -> String { if addr.is_empty() { default_socket_path().display().to_string() } else { addr.strip_prefix("unix:").unwrap_or(addr).to_string() }}
async fn dial(addr: &str) -> Result<Channel> { let unix_path = if addr.is_empty() { Some(default_socket_path()) } else if let Some(path) = addr.strip_prefix("unix:") { Some(path.into()) } else if addr.contains('/') { Some(addr.into()) } else { None };
if let Some(path) = unix_path { // The URI is ignored for unix transports but an Endpoint needs one. let channel = Endpoint::try_from("http://[::1]:50051")? .connect_with_connector(tower::service_fn(move |_: Uri| { let path = path.clone(); async move { Ok::<_, std::io::Error>(TokioIo::new( tokio::net::UnixStream::connect(path).await?, )) } })) .await?; return Ok(channel); }
let url = if addr.starts_with("http://") || addr.starts_with("https://") { addr.to_string() } else { format!("http://{addr}") }; Ok(Endpoint::try_from(url)? .connect_timeout(Duration::from_secs(5)) .connect() .await?)}
/// Copy a wire state into the mirror. Telemetry is always taken; the EQ/// fields only when `eq_too` (callers skip them while local edits are in/// flight, so a stale snapshot can't briefly undo an optimistic edit).fn apply_state(mirror: &mut Mirror, state: &pb::State, eq_too: bool) { if eq_too { mirror.enabled = state.enabled; mirror.bands = state .bands .iter() .map(|b| EqBand { cutoff: b.cutoff_hz, q: b.q_tenths, gain: b.gain_tenths_db, }) .collect(); mirror.bass = state.bass_db; mirror.treble = state.treble_db; } mirror.play_state = state.playback as u8; mirror.server_error = (!state.error.is_empty()).then(|| state.error.clone()); mirror.frames_played = state.frames_played; mirror.peak_l = state.peak_l; mirror.peak_r = state.peak_r;}
/// Follow `WatchState`, reconnecting with a short backoff so a restarted/// server picks the TUI back up.async fn watch_loop(mut client: Client, mirror: Arc<Mutex<Mirror>>, pending: Arc<AtomicUsize>) { loop { match client.watch_state(pb::WatchStateRequest {}).await { Ok(response) => { let mut stream = response.into_inner(); loop { match stream.message().await { Ok(Some(state)) => { let mut m = mirror.lock().unwrap(); m.conn_error = None; let settled = pending.load(Ordering::Acquire) == 0; apply_state(&mut m, &state, settled); } Ok(None) => break, Err(err) => { mirror.lock().unwrap().conn_error = Some(format!("connection lost: {err}")); break; } } } } Err(err) => { mirror.lock().unwrap().conn_error = Some(format!("connection lost: {err}")); } } tokio::time::sleep(Duration::from_secs(1)).await; }}
async fn command_loop( mut client: Client, mut rx: mpsc::UnboundedReceiver<Cmd>, mirror: Arc<Mutex<Mirror>>, pending: Arc<AtomicUsize>,) { while let Some(cmd) = rx.recv().await { let result = match cmd { Cmd::SetEnabled(enabled) => client .set_enabled(pb::SetEnabledRequest { enabled }) .await .map(drop), Cmd::AdjustBand(band, delta) => client .adjust_band(pb::AdjustBandRequest { band: band as u32, delta_tenths_db: delta, }) .await .map(drop), Cmd::AdjustTone(bass, treble) => client .adjust_tone(pb::AdjustToneRequest { bass_delta_db: bass, treble_delta_db: treble, }) .await .map(drop), Cmd::SetGainsDb(gains_db) => client .set_band_gains(pb::SetBandGainsRequest { gains_tenths_db: gains_db.iter().map(|g| g * 10).collect(), }) .await .map(drop), Cmd::Reset => client.reset_gains(pb::ResetGainsRequest {}).await.map(drop), Cmd::Save => client.save(pb::SaveRequest {}).await.map(drop), }; pending.fetch_sub(1, Ordering::AcqRel); if let Err(status) = result { mirror.lock().unwrap().conn_error = Some(format!("rpc failed: {status}")); } }}
impl RemoteController { fn send(&self, cmd: Cmd) { self.pending.fetch_add(1, Ordering::AcqRel); if self.cmds.send(cmd).is_err() { self.pending.fetch_sub(1, Ordering::AcqRel); } }}
impl Controller for RemoteController { fn snapshot(&self) -> EqSnapshot { let m = self.mirror.lock().unwrap(); EqSnapshot { enabled: m.enabled, bands: m.bands.clone(), bass: m.bass, treble: m.treble, } }
fn status(&self) -> PlayStatus { let m = self.mirror.lock().unwrap(); PlayStatus { state: m.play_state, error: m.conn_error.clone().or_else(|| m.server_error.clone()), frames_played: m.frames_played, peak_l: m.peak_l, peak_r: m.peak_r, } }
fn set_enabled(&self, enabled: bool) { self.mirror.lock().unwrap().enabled = enabled; self.send(Cmd::SetEnabled(enabled)); }
fn adjust_band(&self, band: usize, delta_tenths: i32) { { let mut m = self.mirror.lock().unwrap(); if let Some(b) = m.bands.get_mut(band) { b.gain = (b.gain + delta_tenths).clamp(GAIN_MIN_TENTHS, GAIN_MAX_TENTHS); } } self.send(Cmd::AdjustBand(band, delta_tenths)); }
fn adjust_bass(&self, delta_db: i32) { { let mut m = self.mirror.lock().unwrap(); m.bass = (m.bass + delta_db).clamp(TONE_MIN_DB, TONE_MAX_DB); } self.send(Cmd::AdjustTone(delta_db, 0)); }
fn adjust_treble(&self, delta_db: i32) { { let mut m = self.mirror.lock().unwrap(); m.treble = (m.treble + delta_db).clamp(TONE_MIN_DB, TONE_MAX_DB); } self.send(Cmd::AdjustTone(0, delta_db)); }
fn set_band_gains_db(&self, gains_db: &[i32; EQ_BANDS]) { { let mut m = self.mirror.lock().unwrap(); for (b, g) in m.bands.iter_mut().zip(gains_db) { b.gain = (g * 10).clamp(GAIN_MIN_TENTHS, GAIN_MAX_TENTHS); } } self.send(Cmd::SetGainsDb(*gains_db)); }
fn reset_gains(&self) { { let mut m = self.mirror.lock().unwrap(); for b in m.bands.iter_mut() { b.gain = 0; } m.bass = 0; m.treble = 0; } self.send(Cmd::Reset); }
fn save(&self) { self.send(Cmd::Save); }}