chore: Release lemur version 0.10.2

Cargo.toml

@@ -4,12 +4,13 @@ description = "An emulator for the Virtual Boy."
 repository = "https://git.virtual-boy.com/PVB/lemur"
 publish = false
 license = "MIT"
-version = "0.10.0"
+version = "0.10.2"
 edition = "2024"
 
 [dependencies]
 anyhow = "1"
 atoi = "2"
+audioadapter-buffers = "2"
 atomic = "0.6"
 bitflags = { version = "2", features = ["serde"] }
 bytemuck = { version = "1", features = ["derive"] }
@@ -24,7 +25,7 @@ egui-wgpu = { version = "0.33", features = ["winit"] }
 fxprof-processed-profile = "0.8"
 fixed = { version = "1.28", features = ["num-traits"] }
 gilrs = { version = "0.11", features = ["serde-serialize"] }
-gimli = "0.32"
+gimli = "0.33"
 hex = "0.4"
 image = { version = "0.25", default-features = false, features = ["png"] }
 itertools = "0.14"
@@ -36,9 +37,9 @@ object = "0.38"
 oneshot = "0.1"
 pollster = "0.4"
 rand = "0.9"
-rfd = { version = "0.15", default-features = false, features = ["xdg-portal", "async-std"]}
+rfd = "0.17"
 rtrb = "0.3"
-rubato = "0.16"
+rubato = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thread-priority = "3"

build.Dockerfile

@@ -16,7 +16,7 @@ RUN apt-get update && \
     ln -s $(which ld64.lld-21) /usr/bin/ld64.lld && \
     SDK_VERSION=14.5 UNATTENDED=1 ENABLE_COMPILER_RT_INSTALL=1 TARGET_DIR=/osxcross ./build.sh
 
-FROM rust:1.91-bookworm
+FROM rust:1.93-bookworm
 ADD --chmod=644 "https://apt.llvm.org/llvm-snapshot.gpg.key" /etc/apt/trusted.gpg.d/apt.llvm.org.asc
 COPY llvm.sources /etc/apt/sources.list.d/llvm.sources
 RUN rustup target add x86_64-pc-windows-msvc && \

src/app.rs

@@ -382,7 +382,8 @@ impl WgpuState {
         });
 
         let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
-            power_preference: wgpu::PowerPreference::HighPerformance,
+            power_preference:
+                wgpu::PowerPreference::from_env().unwrap_or(wgpu::PowerPreference::LowPower),
             compatible_surface: None,
             force_fallback_adapter: false,
         }))
@@ -439,7 +440,7 @@ impl Viewport {
         egui_extras::install_image_loaders(&ctx);
 
         let wgpu_config = egui_wgpu::WgpuConfiguration {
-            present_mode: wgpu::PresentMode::AutoNoVsync,
+            present_mode: wgpu::PresentMode::AutoVsync,
             wgpu_setup: egui_wgpu::WgpuSetup::Existing(egui_wgpu::WgpuSetupExisting {
                 instance: wgpu.instance.clone(),
                 adapter: wgpu.adapter.clone(),

src/audio.rs

@@ -1,17 +1,17 @@
 use std::time::Duration;
 
 use anyhow::{Result, bail};
+use audioadapter_buffers::direct::InterleavedSlice;
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-use itertools::Itertools;
+use rubato::Resampler;
-use rubato::{FastFixedOut, Resampler};
 use tracing::error;
 
 pub struct Audio {
     #[allow(unused)]
     stream: cpal::Stream,
-    sampler: FastFixedOut<f32>,
+    sampler: rubato::Async<f32>,
-    input_buffer: Vec<Vec<f32>>,
+    input_buffer: Vec<f32>,
-    output_buffer: Vec<Vec<f32>>,
+    output_buffer: Vec<f32>,
     sample_sink: rtrb::Producer<f32>,
 }
 
@@ -32,17 +32,18 @@ impl Audio {
         let mut config = config.with_max_sample_rate().config();
         let resample_ratio = config.sample_rate.0 as f64 / VB_FREQUENCY as f64;
         let chunk_size = (834.0 * resample_ratio) as usize;
-        let sampler = FastFixedOut::new(
+        let sampler = rubato::Async::new_poly(
             resample_ratio,
             64.0,
             rubato::PolynomialDegree::Cubic,
             chunk_size,
             2,
+            rubato::FixedAsync::Output,
         )?;
         config.buffer_size = cpal::BufferSize::Fixed(sampler.output_frames_max() as u32);
 
-        let input_buffer = sampler.input_buffer_allocate(true);
+        let input_buffer = Vec::with_capacity(sampler.nbr_channels() * sampler.input_frames_max());
-        let output_buffer = sampler.output_buffer_allocate(true);
+        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);
 
@@ -78,34 +79,38 @@ impl Audio {
         })
     }
 
-    pub fn update(&mut self, samples: &[f32]) {
+    pub fn update(&mut self, mut samples: &[f32]) {
-        for sample in samples.chunks_exact(2) {
+        while self.input_buffer.len() + samples.len() >= self.sampler.input_frames_next() * 2 {
-            for (channel, value) in self.input_buffer.iter_mut().zip(sample) {
+            let samples_needed =
-                channel.push(*value);
+                (self.sampler.input_frames_next() * 2).saturating_sub(self.input_buffer.len());
-            }
+            let (current_samples, future_samples) = samples.split_at(samples_needed);
-            if self.input_buffer[0].len() >= self.sampler.input_frames_next() {
+            self.input_buffer.extend_from_slice(current_samples);
-                let (_, output_samples) = self
+            samples = future_samples;
-                    .sampler
+
-                    .process_into_buffer(&self.input_buffer, &mut self.output_buffer, None)
+            let buffer_in =
+                InterleavedSlice::new(&self.input_buffer, 2, self.sampler.input_frames_next())
                     .unwrap();
-
+            let mut buffer_out = InterleavedSlice::new_mut(
-                let chunk = match self.sample_sink.write_chunk_uninit(output_samples * 2) {
+                &mut self.output_buffer,
-                    Ok(c) => c,
+                2,
-                    Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
+                self.sampler.output_frames_next(),
-                        self.sample_sink.write_chunk_uninit(n).unwrap()
+            )
-                    }
+            .unwrap();
-                };
+            let (_, output_samples) = self
-                let interleaved = self.output_buffer[0]
+                .sampler
-                    .iter()
+                .process_into_buffer(&buffer_in, &mut buffer_out, None)
-                    .interleave(self.output_buffer[1].iter())
+                .unwrap();
-                    .cloned();
+            let chunk = match self.sample_sink.write_chunk_uninit(output_samples * 2) {
-                chunk.fill_from_iter(interleaved);
+                Ok(c) => c,
-
+                Err(rtrb::chunks::ChunkError::TooFewSlots(n)) => {
-                for channel in &mut self.input_buffer {
+                    self.sample_sink.write_chunk_uninit(n).unwrap()
-                    channel.clear();
                 }
-            }
+            };
+            chunk.fill_from_iter(self.output_buffer[..output_samples * 2].iter().copied());
+
+            self.input_buffer.clear();
         }
+        self.input_buffer.extend_from_slice(samples);
 
         while self.sample_sink.slots() < self.sampler.output_frames_max() * 2 {
             std::thread::sleep(Duration::from_micros(500));

src/emulator/game_info.rs

@@ -245,9 +245,12 @@ impl ParseContext<'_> {
     }
 }
 
-fn parse_inline(ctx: &mut ParseContext, node: gimli::EntriesTreeNode<Reader>) -> Result<()> {
+fn parse_inline<'a>(
+    ctx: &mut ParseContext<'a>,
+    node: gimli::EntriesTreeNode<'a, '_, Reader<'a>>,
+) -> Result<()> {
     if node.entry().tag() == gimli::DW_TAG_inlined_subroutine
-        && let Some(attr) = node.entry().attr_value(gimli::DW_AT_abstract_origin)?
+        && let Some(attr) = node.entry().attr_value(gimli::DW_AT_abstract_origin)
         && let Some(name) = ctx.name_attr(attr)?
     {
         let name = Arc::new(name);

src/input.rs

@@ -683,7 +683,7 @@ impl ShortcutProvider {
                 else {
                     return true;
                 };
-                if shortcut.logical_key != *key || !shortcut.modifiers.contains(*modifiers) {
+                if *key != shortcut.logical_key || !modifiers.contains(shortcut.modifiers) {
                     return true;
                 }
                 if matches!(command, Command::FastForward(_)) {