Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

10.1 KB
Raw Blame
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use cpal::{SampleFormat, SampleRate, StreamConfig, SupportedStreamConfig};
use gecko::audio::{AidBlock, AudioSink};
use ringbuf::HeapRb;
use ringbuf::traits::{Consumer, Observer, Producer, Split};
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};

type Frame = (i16, i16);

struct Resampler {
    consumer: ringbuf::HeapCons<Frame>,
    input_rate: Arc<AtomicU32>,
    host_rate: u32,
    prev: Frame,
    next: Frame,
    phase: f64,
    primed: bool,
}

impl Resampler {
    fn new(consumer: ringbuf::HeapCons<Frame>, input_rate: Arc<AtomicU32>, host_rate: u32) -> Self {
        Self {
            consumer,
            input_rate,
            host_rate,
            prev: (0, 0),
            next: (0, 0),
            phase: 0.0,
            primed: false,
        }
    }

    #[inline]
    fn next_frame(&mut self) -> Frame {
        if self.host_rate == 0 {
            return (0, 0);
        }

        let input_rate_u32 = self.input_rate.load(Ordering::Relaxed).max(1);
        if input_rate_u32 == self.host_rate {
            self.primed = false;
            return self.consumer.try_pop().unwrap_or((0, 0));
        }

        if !self.primed {
            let Some(prev) = self.consumer.try_pop() else {
                return (0, 0);
            };
            self.prev = prev;
            self.next = self.consumer.try_pop().unwrap_or(prev);
            self.phase = 0.0;
            self.primed = true;
        }

        let out = lerp_frame(self.prev, self.next, self.phase);
        let input_rate = input_rate_u32 as f64;
        self.phase += input_rate / self.host_rate as f64;

        while self.phase >= 1.0 {
            self.phase -= 1.0;
            self.prev = self.next;
            let Some(next) = self.consumer.try_pop() else {
                self.primed = false;
                break;
            };
            self.next = next;
        }

        out
    }
}

#[inline]
fn lerp_frame(a: Frame, b: Frame, t: f64) -> Frame {
    let l = a.0 as f64 + (b.0 as f64 - a.0 as f64) * t;
    let r = a.1 as f64 + (b.1 as f64 - a.1 as f64) * t;
    (l.round() as i16, r.round() as i16)
}

pub struct CpalBackend {
    pub sink: CpalAudioSink,
    pub stream: cpal::Stream,
}

pub struct CpalAudioSink {
    producer: ringbuf::HeapProd<Frame>,
    overflow_counter: Arc<AtomicU64>,
    sample_rate: Arc<AtomicU32>,
    throttle_threshold: usize,
}

impl AudioSink for CpalAudioSink {
    fn set_sample_rate(&mut self, sample_rate: u32) {
        let old = self.sample_rate.swap(sample_rate, Ordering::Relaxed);
        if old != sample_rate {
            tracing::info!(
                old_sample_rate = old,
                new_sample_rate = sample_rate,
                "Updated CPAL input sample rate"
            );
        }
    }

    #[inline(always)]
    fn push_stereo_i16(&mut self, left: i16, right: i16) {
        if self.producer.try_push((left, right)).is_err() {
            self.overflow_counter.fetch_add(1, Ordering::Relaxed);
        }
    }

    #[inline(always)]
    fn push_stereo_block(&mut self, frames: &AidBlock) {
        let pushed = self.producer.push_slice(frames);
        if pushed < frames.len() {
            let dropped = (frames.len() - pushed) as u64;
            self.overflow_counter.fetch_add(dropped, Ordering::Relaxed);
        }
    }

    #[inline]
    fn should_throttle(&self) -> bool {
        self.producer.occupied_len() >= self.throttle_threshold
    }
}

pub fn open(emulated_rate: u32) -> Result<CpalBackend, String> {
    let host = cpal::default_host();
    let device = host
        .default_output_device()
        .ok_or_else(|| "no default output audio device".to_string())?;

    let device_name = device
        .description()
        .map(|d| d.name().to_string())
        .unwrap_or_else(|_| "<unknown>".into());
    let supported = pick_supported_config(&device, emulated_rate)?;
    let sample_format = supported.sample_format();
    let host_rate = supported.sample_rate();
    let host_channels = supported.channels() as usize;
    let config: StreamConfig = supported.into();

    if host_rate != emulated_rate {
        tracing::warn!(
            host_rate,
            emulated_rate,
            "Audio device does not support the emulated sample rate; resampling live audio"
        );
    }

    let cap_frames = (emulated_rate.max(host_rate) as usize / 2).max(1024);
    let throttle_threshold = (cap_frames / 4).max(1);
    let rb = HeapRb::<Frame>::new(cap_frames);
    let (producer, consumer) = rb.split();
    let overflow_counter = Arc::new(AtomicU64::new(0));
    let input_rate = Arc::new(AtomicU32::new(emulated_rate));
    let mut resampler = Resampler::new(consumer, input_rate.clone(), host_rate);

    tracing::info!(
        device = %device_name,
        host_rate,
        host_channels,
        emulated_rate,
        ?sample_format,
        ringbuf_capacity_frames = cap_frames,
        throttle_threshold_frames = throttle_threshold,
        "Opened CPAL output"
    );

    let err_fn = |err| tracing::error!(?err, "CPAL stream error");

    let stream = match sample_format {
        SampleFormat::F32 => device
            .build_output_stream(
                &config,
                move |out: &mut [f32], _| {
                    write_f32(&mut resampler, out, host_channels);
                },
                err_fn,
                None,
            )
            .map_err(|e| format!("build_output_stream f32: {e}"))?,
        SampleFormat::I16 => device
            .build_output_stream(
                &config,
                move |out: &mut [i16], _| {
                    write_i16(&mut resampler, out, host_channels);
                },
                err_fn,
                None,
            )
            .map_err(|e| format!("build_output_stream i16: {e}"))?,
        SampleFormat::U16 => device
            .build_output_stream(
                &config,
                move |out: &mut [u16], _| {
                    write_u16(&mut resampler, out, host_channels);
                },
                err_fn,
                None,
            )
            .map_err(|e| format!("build_output_stream u16: {e}"))?,
        SampleFormat::U8 => device
            .build_output_stream(
                &config,
                move |out: &mut [u8], _| {
                    write_u8(&mut resampler, out, host_channels);
                },
                err_fn,
                None,
            )
            .map_err(|e| format!("build_output_stream u8: {e}"))?,
        other => return Err(format!("unsupported CPAL sample format: {other:?}")),
    };

    stream.play().map_err(|e| format!("stream.play: {e}"))?;

    Ok(CpalBackend {
        sink: CpalAudioSink {
            producer,
            overflow_counter,
            sample_rate: input_rate,
            throttle_threshold,
        },
        stream,
    })
}

fn config_score(cfg: &SupportedStreamConfig) -> u32 {
    let fmt_score = match cfg.sample_format() {
        SampleFormat::F32 => 0,
        SampleFormat::I16 => 1,
        SampleFormat::U16 => 2,
        SampleFormat::U8 => 3,
        _ => 1000,
    };
    let chan_score: u32 = if cfg.channels() == 2 { 0 } else { 10 };
    fmt_score + chan_score
}

fn pick_supported_config(device: &cpal::Device, desired_rate: u32) -> Result<SupportedStreamConfig, String> {
    let configs = device
        .supported_output_configs()
        .map_err(|e| format!("supported_output_configs: {e}"))?;

    let target_rate: SampleRate = desired_rate;
    let mut best_at_rate: Option<SupportedStreamConfig> = None;

    for range in configs {
        if range.min_sample_rate() <= target_rate && range.max_sample_rate() >= target_rate {
            let candidate = range.with_sample_rate(target_rate);
            match &best_at_rate {
                None => best_at_rate = Some(candidate),
                Some(prev) if config_score(&candidate) < config_score(prev) => {
                    best_at_rate = Some(candidate);
                }
                _ => {}
            }
        }
    }

    if let Some(cfg) = best_at_rate {
        return Ok(cfg);
    }

    device
        .default_output_config()
        .map_err(|e| format!("default_output_config: {e}"))
}

#[inline]
fn write_i16(resampler: &mut Resampler, out: &mut [i16], host_channels: usize) {
    if host_channels == 0 {
        return;
    }

    for slot in out.chunks_mut(host_channels) {
        let (l, r) = resampler.next_frame();

        if !slot.is_empty() {
            slot[0] = l;
        }

        if slot.len() >= 2 {
            slot[1] = r;
        }

        for s in slot.iter_mut().skip(2) {
            *s = 0;
        }
    }
}

#[inline]
fn write_f32(resampler: &mut Resampler, out: &mut [f32], host_channels: usize) {
    if host_channels == 0 {
        return;
    }

    let scale = 1.0 / 32768.0;
    for slot in out.chunks_mut(host_channels) {
        let (l, r) = resampler.next_frame();

        if !slot.is_empty() {
            slot[0] = l as f32 * scale;
        }

        if slot.len() >= 2 {
            slot[1] = r as f32 * scale;
        }

        for s in slot.iter_mut().skip(2) {
            *s = 0.0;
        }
    }
}

#[inline]
fn write_u16(resampler: &mut Resampler, out: &mut [u16], host_channels: usize) {
    if host_channels == 0 {
        return;
    }

    for slot in out.chunks_mut(host_channels) {
        let (l, r) = resampler.next_frame();
        let lu = (l as u16) ^ 0x8000;
        let ru = (r as u16) ^ 0x8000;

        if !slot.is_empty() {
            slot[0] = lu;
        }

        if slot.len() >= 2 {
            slot[1] = ru;
        }

        for s in slot.iter_mut().skip(2) {
            *s = 0x8000;
        }
    }
}

#[inline]
fn write_u8(resampler: &mut Resampler, out: &mut [u8], host_channels: usize) {
    if host_channels == 0 {
        return;
    }

    for slot in out.chunks_mut(host_channels) {
        let (l, r) = resampler.next_frame();
        let lu = ((l >> 8) as u8) ^ 0x80;
        let ru = ((r >> 8) as u8) ^ 0x80;

        if !slot.is_empty() {
            slot[0] = lu;
        }

        if slot.len() >= 2 {
            slot[1] = ru;
        }

        for s in slot.iter_mut().skip(2) {
            *s = 0x80;
        }
    }
}