Peg frame limit to audio playback

Author: Grarak

src/core/graphics/gpu.rs

@@ -11,12 +11,11 @@ use crate::core::CpuType;
 use crate::core::CpuType::ARM9;
 use crate::logging::debug_println;
 use bilge::prelude::*;
-use std::intrinsics::{likely, unlikely};
+use std::intrinsics::unlikely;
 use std::ptr::NonNull;
 use std::sync::atomic::{AtomicU16, Ordering};
 use std::sync::Arc;
-use std::thread;
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
 pub const DISPLAY_WIDTH: usize = 256;
 pub const DISPLAY_HEIGHT: usize = 192;
@@ -38,17 +37,10 @@ impl FrameRateCounter {
         }
     }
 
-    fn on_frame_ready(&mut self, limit_frame: bool) {
+    fn on_frame_ready(&mut self) {
         self.frame_counter += 1;
         let now = Instant::now();
-        if likely(limit_frame) {
-            let diff = now.duration_since(self.last_frame).as_millis();
-            if unlikely(diff < 16) {
-                thread::sleep(Duration::from_millis(16 - diff as u64));
-            }
-            self.last_frame = Instant::now();
-        }
-        if now.duration_since(self.last_update).as_millis() >= 1000 {
+        if unlikely(now.duration_since(self.last_update).as_millis() >= 1000) {
             self.fps.store(self.frame_counter, Ordering::Relaxed);
             // #[cfg(target_os = "linux")]
             eprintln!("{}", self.frame_counter);
@@ -90,7 +82,6 @@ pub struct Gpu {
     pub pow_cnt1: u16,
     pub disp_cap_cnt: u32,
     frame_rate_counter: FrameRateCounter,
-    pub frame_limit: bool,
     pub arm7_hle: bool,
     pub v_count: u16,
     pub gpu_2d_regs_a: Gpu2DRegisters<{ A }>,
@@ -106,7 +97,6 @@ impl Gpu {
             pow_cnt1: 0,
             disp_cap_cnt: 0,
             frame_rate_counter: FrameRateCounter::new(fps),
-            frame_limit: false,
             arm7_hle: false,
             v_count: 0,
             gpu_2d_regs_a: Gpu2DRegisters::default(),
@@ -204,7 +194,7 @@ impl Gpu {
                 for i in 0..2 {
                     gpu.disp_stat[i].set_v_blank_flag(u1::new(0));
                 }
-                gpu.frame_rate_counter.on_frame_ready(gpu.frame_limit);
+                gpu.frame_rate_counter.on_frame_ready();
             }
             263 => {
                 gpu.v_count = 0;

src/core/spu.rs

@@ -18,28 +18,36 @@ const SAMPLE_BUFFER_SIZE: usize = SAMPLE_RATE * PRESENTER_AUDIO_BUF_SIZE / PRESE
 pub struct SoundSampler {
     samples: Mutex<VecDeque<HeapMemU32<{ SAMPLE_BUFFER_SIZE }>>>,
     cond_var: Condvar,
+    framelimit: bool,
 }
 
 impl SoundSampler {
-    pub fn new() -> SoundSampler {
+    pub fn new(framelimit: bool) -> SoundSampler {
         SoundSampler {
             samples: Mutex::new(VecDeque::new()),
             cond_var: Condvar::new(),
+            framelimit,
         }
     }
 
     fn push(&self, samples: &[u32]) {
-        let mut queue = self.samples.lock().unwrap();
-        if queue.len() == 2 {
-            queue.swap(0, 1);
-            let s = queue.back_mut().unwrap();
-            s.copy_from_slice(samples);
-        } else {
+        {
+            let mut queue = self.samples.lock().unwrap();
+            let mut queue = if queue.len() == 4 {
+                if self.framelimit {
+                    self.cond_var.wait_while(queue, |queue| queue.len() == 4).unwrap()
+                } else {
+                    queue.pop_front();
+                    queue
+                }
+            } else {
+                queue
+            };
             let mut s = HeapMemU32::new();
             s.copy_from_slice(samples);
             queue.push_back(s);
-            self.cond_var.notify_one();
         }
+        self.cond_var.notify_one();
     }
 
     pub fn consume(&self, ret: &mut [u32; PRESENTER_AUDIO_BUF_SIZE]) {
@@ -48,6 +56,7 @@ impl SoundSampler {
             let mut samples = self.cond_var.wait_while(samples, |samples| samples.is_empty()).unwrap();
             samples.pop_front().unwrap()
         };
+        self.cond_var.notify_one();
         for i in 0..PRESENTER_AUDIO_BUF_SIZE {
             ret[i] = samples[i * SAMPLE_BUFFER_SIZE / PRESENTER_AUDIO_BUF_SIZE];
         }
@@ -123,13 +132,14 @@ pub struct MainSoundCnt {
 #[derive(Copy, Clone, Default)]
 pub struct SpuChannel {
     cnt: SoundCnt,
+    volume: u8,
     sad: u32,
     tmr: u16,
     pnt: u16,
     len: u32,
     snd_cap_cnt: u8,
     sad_current: u32,
-    tmr_current: u16,
+    tmr_current: u32,
     adpcm_value: i32,
     adpcm_loop_value: i32,
     adpcm_index: i32,
@@ -161,6 +171,7 @@ pub struct Spu {
     pub audio_enabled: bool,
     pub channels: [SpuChannel; CHANNEL_COUNT],
     main_sound_cnt: MainSoundCnt,
+    master_volume: u8,
     sound_bias: u16,
     duty_cycles: [i32; 6],
     noise_values: [u16; 2],
@@ -174,6 +185,7 @@ impl Spu {
             audio_enabled: false,
             channels: [SpuChannel::default(); CHANNEL_COUNT],
             main_sound_cnt: MainSoundCnt::from(0),
+            master_volume: 0,
             sound_bias: 0,
             duty_cycles: [0; 6],
             noise_values: [0; 2],
@@ -203,6 +215,11 @@ impl Spu {
 
         mask &= 0xFF7F837F;
         self.channels[channel].cnt = ((u32::from(self.channels[channel].cnt) & !mask) | (value & mask)).into();
+        let mut volume = u8::from(self.channels[channel].cnt.volume_mul());
+        if volume == 127 {
+            volume += 1;
+        }
+        self.channels[channel].volume = volume;
 
         if was_disabled
             && bool::from(self.channels[channel].cnt.start_status())
@@ -246,6 +263,11 @@ impl Spu {
 
         mask &= 0xBF7F;
         self.main_sound_cnt = ((u16::from(self.main_sound_cnt) & !mask) | (value & mask)).into();
+        let mut volume = u8::from(self.main_sound_cnt.master_volume());
+        if volume == 127 {
+            volume += 1;
+        }
+        self.master_volume = volume;
 
         if was_disabled && bool::from(self.main_sound_cnt.master_enable()) {
             for i in 0..CHANNEL_COUNT {
@@ -280,7 +302,7 @@ impl Spu {
     fn start_channel(&mut self, channel_num: usize, emu: &mut Emu) {
         let channel = &mut self.channels[channel_num];
         channel.sad_current = channel.sad;
-        channel.tmr_current = channel.tmr;
+        channel.tmr_current = channel.tmr as u32;
 
         match channel.cnt.get_format() {
             SoundChannelFormat::ImaAdpcm => {
@@ -381,7 +403,13 @@ impl Spu {
             for i in 0..CHANNEL_COUNT {
                 get_channel_mut!(emu, i).cnt.set_start_status(u1::new(0));
             }
-            get_cm_mut!(emu).schedule(512 * 10, EventType::SpuSample);
+            let spu = get_spu_mut!(emu);
+            spu.samples_buffer.push(0);
+            if unlikely(spu.samples_buffer.len() == SAMPLE_BUFFER_SIZE) {
+                spu.sound_sampler.push(spu.samples_buffer.as_slice());
+                spu.samples_buffer.clear();
+            }
+            get_cm_mut!(emu).schedule(512 * 2, EventType::SpuSample);
             return;
         }
 
@@ -416,25 +444,15 @@ impl Spu {
                 }
             };
 
-            {
-                let channel = get_channel_mut!(emu, i);
-                channel.tmr_current = channel.tmr_current.wrapping_add(512);
-            }
-
-            let mut overflow = get_channel!(emu, i).tmr_current < 512;
-            while overflow {
-                {
-                    let channel = get_channel_mut!(emu, i);
-                    channel.tmr_current = channel.tmr_current.wrapping_add(channel.tmr);
-                }
-                overflow = get_channel!(emu, i).tmr_current < get_channel!(emu, i).tmr;
+            let mut tmr_current = get_channel!(emu, i).tmr_current.wrapping_add(512);
+            let tmr = get_channel!(emu, i).tmr;
+            while tmr_current >> 16 != 0 {
+                tmr_current = tmr as u32 + (tmr_current - 0x10000);
 
                 match format {
                     SoundChannelFormat::Pcm8 | SoundChannelFormat::Pcm16 => Self::next_sample_pcm(get_channel_mut!(emu, i)),
                     SoundChannelFormat::ImaAdpcm => Self::next_sample_adpcm(get_channel_mut!(emu, i), emu),
-                    SoundChannelFormat::PsgNoise => {
-                        get_spu_mut!(emu).next_sample_psg(i);
-                    }
+                    SoundChannelFormat::PsgNoise => get_spu_mut!(emu).next_sample_psg(i),
                 }
 
                 let channel = get_channel_mut!(emu, i);
@@ -454,19 +472,15 @@ impl Spu {
                     }
                 }
             }
+            get_channel_mut!(emu, i).tmr_current = tmr_current;
 
             let channel = get_channel!(emu, i);
-            let mut volume_div = u8::from(channel.cnt.volume_div());
-            if volume_div == 3 {
-                volume_div += 1;
-            }
-            data <<= 4 - volume_div;
+            let volume_div = u8::from(channel.cnt.volume_div());
+            const VOLUME_DIVS: [u8; 4] = [4, 3, 2, 0];
+            data <<= VOLUME_DIVS[volume_div as usize];
 
-            let mut volume_mul = u8::from(channel.cnt.volume_mul()) as i64;
-            if volume_mul == 127 {
-                volume_mul += 1;
-            }
-            data = (data << 7) * volume_mul / 128;
+            let volume_mul = channel.volume as i64;
+            data = ((data << 7) * volume_mul) >> 7;
 
             let mut panning = u8::from(channel.cnt.panning()) as i64;
             if panning == 127 {
@@ -511,12 +525,9 @@ impl Spu {
             _ => unsafe { unreachable_unchecked() },
         };
 
-        let mut master_vol = u8::from(spu.main_sound_cnt.master_volume()) as i64;
-        if master_vol == 127 {
-            master_vol += 1;
-        }
-        let sample_left = (sample_left * master_vol / 128) >> 8;
-        let sample_right = (sample_right * master_vol / 128) >> 8;
+        let master_volume = spu.master_volume as i64;
+        let sample_left = ((sample_left * master_volume) >> 7) >> 8;
+        let sample_right = ((sample_right * master_volume) >> 7) >> 8;
 
         let sample_left = (sample_left >> 6) + spu.sound_bias as i64;
         let sample_right = (sample_right >> 6) + spu.sound_bias as i64;

src/main.rs

@@ -149,7 +149,6 @@ fn run_cpu(
     }
 
     Gpu::initialize_schedule(get_cm_mut!(emu));
-    common.gpu.frame_limit = emu.settings.framelimit();
     common.gpu.gpu_renderer = Some(gpu_renderer);
 
     get_spu_mut!(emu).audio_enabled = emu.settings.audio();
@@ -295,27 +294,21 @@ pub fn actual_main() {
     let touch_points = Arc::new(AtomicU16::new(0));
     let touch_points_clone = touch_points.clone();
 
-    let sound_sampler = Arc::new(SoundSampler::new());
+    let sound_sampler = Arc::new(SoundSampler::new(settings.framelimit()));
     let sound_sampler_clone = sound_sampler.clone();
 
     let presenter_audio = presenter.get_presenter_audio();
-    let audio_thread = if settings.audio() {
-        Some(
-            thread::Builder::new()
-                .name("audio".to_owned())
-                .spawn(move || {
-                    set_thread_prio_affinity(ThreadPriority::Default, ThreadAffinity::Core0);
-                    let mut audio_buffer = HeapMemU32::<{ PRESENTER_AUDIO_BUF_SIZE }>::new();
-                    loop {
-                        sound_sampler.consume(audio_buffer.deref_mut());
-                        presenter_audio.play(audio_buffer.deref());
-                    }
-                })
-                .unwrap(),
-        )
-    } else {
-        None
-    };
+    let audio_thread = thread::Builder::new()
+        .name("audio".to_owned())
+        .spawn(move || {
+            set_thread_prio_affinity(ThreadPriority::Default, ThreadAffinity::Core0);
+            let mut audio_buffer = HeapMemU32::<{ PRESENTER_AUDIO_BUF_SIZE }>::new();
+            loop {
+                sound_sampler.consume(audio_buffer.deref_mut());
+                presenter_audio.play(audio_buffer.deref());
+            }
+        })
+        .unwrap();
 
     let gpu_renderer = UnsafeCell::new(GpuRenderer::new());
     let gpu_renderer_ptr = gpu_renderer.get() as u32;
@@ -350,8 +343,6 @@ pub fn actual_main() {
         gpu_renderer.render_loop(&mut presenter, &fps, &last_save_time);
     }
 
-    if let Some(audio_thread) = audio_thread {
-        audio_thread.join().unwrap();
-    }
+    audio_thread.join().unwrap();
     cpu_thread.join().unwrap();
 }

src/presenter/linux.rs

@@ -14,7 +14,7 @@ use sdl2::{keyboard, EventPump};
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
-use std::slice;
+use std::{slice, thread};
 
 #[derive(Clone)]
 pub struct PresenterAudio {
@@ -29,9 +29,11 @@ impl PresenterAudio {
     }
 
     pub fn play(&self, buffer: &[u32; PRESENTER_AUDIO_BUF_SIZE]) {
-        self.audio_queue.clear();
         let raw = unsafe { slice::from_raw_parts(buffer.as_slice().as_ptr() as *const i16, PRESENTER_AUDIO_BUF_SIZE * 2) };
         self.audio_queue.queue_audio(raw).unwrap();
+        while self.audio_queue.size() != 0 {
+            thread::yield_now();
+        }
     }
 }
 

src/presenter/vita.rs

@@ -76,7 +76,7 @@ impl PresenterAudio {
     fn new() -> Self {
         unsafe {
             PresenterAudio {
-                audio_port: sceAudioOutOpenPort(SCE_AUDIO_OUT_PORT_TYPE_MAIN, PRESENTER_AUDIO_BUF_SIZE as _, PRESENTER_AUDIO_SAMPLE_RATE as _, SCE_AUDIO_OUT_MODE_STEREO),
+                audio_port: sceAudioOutOpenPort(SCE_AUDIO_OUT_PORT_TYPE_BGM, PRESENTER_AUDIO_BUF_SIZE as _, PRESENTER_AUDIO_SAMPLE_RATE as _, SCE_AUDIO_OUT_MODE_STEREO),
             }
         }
     }