chore: Release lemur version 0.15.0

Cargo.lock

@@ -2034,7 +2034,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "lemur"
-version = "0.14.0"
+version = "0.15.0"
 dependencies = [
  "anyhow",
  "atoi",

Cargo.toml

@@ -4,7 +4,7 @@ description = "An emulator for the Virtual Boy."
 repository = "https://git.virtual-boy.com/PVB/lemur"
 publish = false
 license = "MIT"
-version = "0.14.0"
+version = "0.15.0"
 edition = "2024"
 
 [dependencies]

src/app.rs

@@ -424,6 +424,9 @@ impl ApplicationHandler<UserEvent> for Application {
                 {
                     self.controllers.handle_key_event(&event);
                 }
+                WindowEvent::DroppedFile(path) => {
+                    self.app.handle_dropped_file(viewport_id, path);
+                }
                 WindowEvent::Focused(new_focused) => {
                     self.focused = new_focused.then_some(viewport_id);
                 }
@@ -464,6 +467,9 @@ impl ApplicationHandler<UserEvent> for Application {
                     self.controllers.handle_gamepad_event(&event);
                 }
             }
+            UserEvent::LowBattery(sim_id, pwr) => {
+                self.controllers.handle_low_battery(sim_id, pwr);
+            }
             UserEvent::Quit(sim_id) => match sim_id {
                 SimId::Player1 => event_loop.exit(),
                 SimId::Player2 => self.app.close(ChildWindow::Player2),
@@ -670,6 +676,7 @@ impl ViewportManager {
 pub enum UserEvent {
     GamepadEvent(gilrs::Event),
     Quit(SimId),
+    LowBattery(SimId, bool),
     RequestRedraw(ViewportId, Instant),
 }
 

src/audio.rs

@@ -1,12 +1,16 @@
 use std::time::Duration;
 
-use anyhow::{Result, bail};
+use anyhow::{Context, Result, bail};
 use audioadapter_buffers::direct::InterleavedSlice;
-use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use cpal::{
+    Device, FromSample, Sample, SampleFormat, SizedSample, StreamConfig,
+    traits::{DeviceTrait, HostTrait, StreamTrait},
+};
+use itertools::Itertools;
 use rubato::{Adjustable as _, Resampler};
 use tracing::warn;
 
-pub struct Audio {
+struct CpalAudio {
     #[allow(unused)]
     stream: cpal::Stream,
     sampler: rubato::Async<f32>,
@@ -17,19 +21,31 @@ pub struct Audio {
 
 const VB_FREQUENCY: usize = 41700;
 
-impl Audio {
-    pub fn init() -> Result<Self> {
+impl CpalAudio {
+    fn init() -> Result<Self> {
         let host = cpal::default_host();
-        let Some(device) = host.default_output_device() else {
-            bail!("No output device available");
-        };
+        let device = host
+            .default_output_device()
+            .context("no output device available")?;
         let default_rate = device.default_output_config()?.sample_rate();
-        let Some(config) = device.supported_output_configs()?.find(|c| {
-            c.channels() == 2 && c.sample_format().is_float() && c.contains_rate(default_rate)
-        }) else {
-            bail!("No suitable output config available");
-        };
-        let mut config = config.with_sample_rate(default_rate).config();
+
+        let supported_config = device
+            .supported_output_configs()?
+            .filter(|c| {
+                c.contains_rate(default_rate)
+                    && matches!(
+                        c.sample_format(),
+                        SampleFormat::F32
+                            | SampleFormat::F64
+                            | SampleFormat::I32
+                            | SampleFormat::I16
+                    )
+            })
+            .max_by(|a, b| a.cmp_default_heuristics(b))
+            .context("no suitable output config available")?
+            .with_sample_rate(default_rate);
+        let mut config = supported_config.config();
+
         let resample_ratio = config.sample_rate as f64 / VB_FREQUENCY as f64;
         let chunk_size = (834.0 * resample_ratio) as usize;
         let sampler = rubato::Async::new_poly(
@@ -42,6 +58,23 @@ impl Audio {
         )?;
         config.buffer_size = cpal::BufferSize::Fixed(sampler.output_frames_max() as u32);
 
+        match supported_config.sample_format() {
+            SampleFormat::F32 if config.channels == 2 => {
+                Self::new_f32_stereo(device, config, sampler)
+            }
+            SampleFormat::F32 => Self::new::<f32>(device, config, sampler),
+            SampleFormat::F64 => Self::new::<f64>(device, config, sampler),
+            SampleFormat::I32 => Self::new::<i32>(device, config, sampler),
+            SampleFormat::I16 => Self::new::<i16>(device, config, sampler),
+            _ => bail!("unsupported sample format"),
+        }
+    }
+
+    fn new_f32_stereo(
+        device: Device,
+        config: StreamConfig,
+        sampler: rubato::Async<f32>,
+    ) -> Result<Self> {
         let input_buffer = Vec::with_capacity(sampler.nbr_channels() * sampler.input_frames_max());
         let output_buffer = vec![0.0; sampler.nbr_channels() * sampler.output_frames_max()];
         let (sample_sink, mut sample_source) =
@@ -79,7 +112,60 @@ impl Audio {
         })
     }
 
-    pub fn update(&mut self, mut samples: &[f32]) {
+    fn new<S: SizedSample + FromSample<f32>>(
+        device: Device,
+        config: StreamConfig,
+        sampler: rubato::Async<f32>,
+    ) -> Result<Self> {
+        let input_buffer = Vec::with_capacity(sampler.nbr_channels() * sampler.input_frames_max());
+        let output_buffer = vec![0.0; sampler.nbr_channels() * sampler.output_frames_max()];
+        let (sample_sink, mut sample_source) =
+            rtrb::RingBuffer::new(sampler.output_frames_max() * 4);
+
+        let channels = config.channels as usize;
+
+        let stream = device.build_output_stream(
+            config,
+            move |data: &mut [S], _| {
+                let requested = data.len() * 2 / channels;
+                let chunk = match sample_source.read_chunk(requested) {
+                    Ok(c) => c,
+                    Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
+                        sample_source.read_chunk(n).unwrap()
+                    }
+                };
+                let (first, second) = chunk.as_slices();
+
+                let new_samples = first
+                    .iter()
+                    .chain(second)
+                    .map(|s: &f32| (*s).to_sample())
+                    .chunks(2);
+                let buffer = data.iter_mut().chunks(channels);
+                for (dst, samples) in buffer.into_iter().zip(&new_samples) {
+                    // channels beyond the first two are zeroed
+                    let src = samples.chain(std::iter::repeat(S::EQUILIBRIUM));
+                    for (d, s) in dst.zip(src) {
+                        *d = s;
+                    }
+                }
+
+                chunk.commit_all();
+            },
+            move |error| warn!(%error, "stream error"),
+            None,
+        )?;
+        stream.play()?;
+        Ok(Self {
+            stream,
+            sampler,
+            input_buffer,
+            output_buffer,
+            sample_sink,
+        })
+    }
+
+    fn update(&mut self, mut samples: &[f32]) {
         while self.input_buffer.len() + samples.len() >= self.sampler.input_frames_next() * 2 {
             let samples_needed =
                 (self.sampler.input_frames_next() * 2).saturating_sub(self.input_buffer.len());
@@ -117,9 +203,64 @@ impl Audio {
         }
     }
 
-    pub fn set_speed(&mut self, speed: f64) -> Result<()> {
+    fn set_speed(&mut self, speed: f64) -> Result<()> {
         self.sampler
             .set_resample_ratio_relative(1.0 / speed, false)?;
         Ok(())
     }
 }
+
+struct NoAudio {
+    speed: f64,
+}
+
+impl NoAudio {
+    fn new() -> Self {
+        Self { speed: 1.0 }
+    }
+
+    fn update(&mut self, samples: &[f32]) {
+        let samples = (samples.len() / 2) as f64;
+        let elapsed = Duration::from_secs_f64(samples / (VB_FREQUENCY as f64 * self.speed));
+        std::thread::sleep(elapsed);
+    }
+
+    fn set_speed(&mut self, speed: f64) -> Result<()> {
+        self.speed = speed;
+        Ok(())
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+enum AudioInner {
+    Cpal(CpalAudio),
+    None(NoAudio),
+}
+
+pub struct Audio(AudioInner);
+
+impl Audio {
+    pub fn init() -> Self {
+        match CpalAudio::init() {
+            Ok(a) => Self(AudioInner::Cpal(a)),
+            Err(e) => {
+                warn!("could not play audio: {e}");
+                Self(AudioInner::None(NoAudio::new()))
+            }
+        }
+    }
+
+    pub fn update(&mut self, samples: &[f32]) {
+        match &mut self.0 {
+            AudioInner::Cpal(a) => a.update(samples),
+            AudioInner::None(a) => a.update(samples),
+        }
+    }
+
+    pub fn set_speed(&mut self, speed: f64) -> Result<()> {
+        match &mut self.0 {
+            AudioInner::Cpal(a) => a.set_speed(speed),
+            AudioInner::None(a) => a.set_speed(speed),
+        }
+    }
+}

src/config.rs

@@ -141,6 +141,10 @@ pub struct SimConfig {
     #[serde(default = "default_audio_enabled")]
     pub audio_enabled: bool,
     #[serde(default)]
+    pub low_battery: bool,
+    #[serde(default)]
+    pub watch_rom: bool,
+    #[serde(default)]
     pub position: Option<Pos2>,
 }
 
@@ -154,6 +158,8 @@ impl SimConfig {
             colors: COLOR_PRESETS[0],
             dimensions: DisplayMode::Anaglyph.proportions() + Vec2::new(0.0, 22.0),
             audio_enabled: true,
+            low_battery: false,
+            watch_rom: false,
             position: None,
         }
     }

src/controller.rs

@@ -77,6 +77,15 @@ impl Controller {
         self.update_state(pressed, released)
     }
 
+    pub fn low_battery(&mut self, pwr: bool) -> Option<VBKey> {
+        let (pressed, released) = if pwr {
+            (VBKey::PWR, VBKey::empty())
+        } else {
+            (VBKey::empty(), VBKey::PWR)
+        };
+        self.update_state(pressed, released)
+    }
+
     fn update_state(&mut self, pressed: VBKey, released: VBKey) -> Option<VBKey> {
         let old_state = self.state;
         self.state = self.state.union(pressed).difference(released);
@@ -133,6 +142,14 @@ impl ControllerManager {
             }
         }
     }
+
+    pub fn handle_low_battery(&mut self, sim_id: SimId, pwr: bool) {
+        let controller = &mut self.controllers[sim_id.to_index()];
+        if let Some(pressed) = controller.low_battery(pwr) {
+            self.client
+                .send_command(EmulatorCommand::SetKeys(controller.sim_id, pressed));
+        }
+    }
 }
 
 fn axis_presses(value: f32, pair_value: f32, neg: VBKey, pos: VBKey) -> (VBKey, VBKey) {

src/emulator.rs

@@ -138,7 +138,7 @@ impl EmulatorBuilder {
             self.audio_on,
             self.watch_rom,
             self.linked,
-        )?;
+        );
         if let Some(path) = self.rom {
             emulator.load_cart(SimId::Player1, &path)?;
         }
@@ -178,11 +178,11 @@ impl Emulator {
         audio_on: Arc<[AtomicBool; 2]>,
         watch_rom: Arc<[AtomicBool; 2]>,
         linked: Arc<AtomicBool>,
-    ) -> Result<Self> {
-        Ok(Self {
+    ) -> Self {
+        Self {
             sims: vec![],
             carts: [None, None],
-            audio: Audio::init()?,
+            audio: Audio::init(),
             commands,
             sim_state,
             state,
@@ -198,7 +198,7 @@ impl Emulator {
             eye_contents: [vec![0u8; 384 * 224 * 2], vec![0u8; 384 * 224 * 2]],
             audio_samples: Vec::with_capacity(EXPECTED_FRAME_SIZE),
             buffer: vec![],
-        })
+        }
     }
 
     pub fn reload_cart(&mut self, sim_id: SimId) -> Result<()> {

src/filepicker.rs

@@ -1,3 +1,5 @@
+#[cfg(target_os = "linux")]
+use std::fmt::Write as _;
 use std::{
     path::PathBuf,
     sync::{Arc, Weak},
@@ -49,6 +51,23 @@ pub struct FileDialogBuilder {
 
 impl FileDialogBuilder {
     pub fn add_filter(self, name: impl Into<String>, extensions: &[impl ToString]) -> Self {
+        #[cfg(target_os = "linux")]
+        let exts = extensions
+            .iter()
+            .map(|ext| {
+                let mut normalized = String::new();
+                for char in ext.to_string().chars() {
+                    if char.is_ascii_lowercase() {
+                        let _ = write!(&mut normalized, "[{char}{}]", char.to_ascii_uppercase());
+                    } else {
+                        normalized.push(char);
+                    }
+                }
+                normalized
+            })
+            .collect::<Vec<_>>();
+        #[cfg(target_os = "linux")]
+        let extensions = &exts;
         Self {
             dialog: self.dialog.add_filter(name, extensions),
             ..self

src/window.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{path::PathBuf, sync::Arc};
 
 pub use about::AboutWindow;
 use egui::{Ui, ViewportBuilder};
@@ -47,6 +47,10 @@ pub trait AppWindow {
         let _ = event;
         false
     }
+    fn handle_dropped_file(&mut self, path: PathBuf) -> bool {
+        let _ = path;
+        false
+    }
 }
 
 pub struct InitArgs<'a> {

src/window/game.rs

@@ -1,5 +1,6 @@
 use std::{
     ops::{Deref, DerefMut},
+    path::PathBuf,
     sync::{Arc, Mutex, atomic::AtomicBool, mpsc},
     time::Duration,
 };
@@ -71,6 +72,8 @@ impl GameWindow {
         sim_id: SimId,
     ) -> Self {
         let config = SimConfig::load(&persistence, sim_id);
+        let _ = proxy.send_event(UserEvent::LowBattery(sim_id, config.low_battery));
+        client.send_command(EmulatorCommand::WatchRom(sim_id, config.watch_rom));
         let toasts = Toasts::new()
             .with_anchor(Anchor::BottomLeft)
             .with_margin((10.0, 10.0).into())
@@ -214,6 +217,10 @@ impl GameWindow {
         self.handle_event(viewport_id, |window| window.handle_gamepad_event(event))
     }
 
+    pub fn handle_dropped_file(&mut self, viewport_id: ViewportId, path: PathBuf) -> bool {
+        self.handle_event(viewport_id, |window| window.handle_dropped_file(path))
+    }
+
     fn handle_event<F, R>(&mut self, viewport_id: ViewportId, cb: F) -> R
     where
         F: FnOnce(&mut dyn AppWindow) -> R,
@@ -327,6 +334,7 @@ impl GameWindow {
             }
             let watch_rom = self.client.is_rom_watched(self.sim_id);
             if ui.selectable_button(watch_rom, "Watch ROM").clicked() {
+                self.update_config(|c| c.watch_rom = !watch_rom);
                 self.client
                     .send_command(EmulatorCommand::WatchRom(self.sim_id, !watch_rom));
             }
@@ -384,6 +392,14 @@ impl GameWindow {
             {
                 pollster::block_on(self.take_screenshot());
             }
+            ui.separator();
+            let low_battery = self.config.low_battery;
+            if ui.selectable_button(low_battery, "Low Battery").clicked() {
+                self.update_config(|c| c.low_battery = !low_battery);
+                let _ = self
+                    .proxy
+                    .send_event(UserEvent::LowBattery(self.sim_id, !low_battery));
+            }
         });
         ui.menu_button("Options", |ui| self.show_options_menu(ui));
         ui.menu_button("Multiplayer", |ui| {
@@ -765,6 +781,12 @@ impl AppWindow for GameWindow {
         }
         self.file_picker.set_window(args.window);
     }
+
+    fn handle_dropped_file(&mut self, path: PathBuf) -> bool {
+        self.client
+            .send_command(EmulatorCommand::LoadGame(self.sim_id, path));
+        true
+    }
 }
 
 impl Drop for GameWindow {