@tmustier/pi-nes 0.2.34 → 0.2.36

package/extensions/nes/native/nes-core/Cargo.toml

@@ -12,6 +12,11 @@ libc = "0.2"
 nes_rust = { path = "vendor/nes_rust" }
 napi = { version = "2", features = ["napi8"] }
 napi-derive = "2"
+cpal = { version = "0.17.1", optional = true }
+ringbuf = { version = "0.4.8", optional = true }
+
+[features]
+audio-cpal = ["cpal", "ringbuf"]
 
 [build-dependencies]
 napi-build = "2"

package/extensions/nes/native/nes-core/index.d.ts

@@ -32,6 +32,7 @@ export class NativeNes {
   stepFrame(): void;
   refreshFramebuffer(): void;
   setVideoFilter(mode: number): void;
+  setAudioEnabled(enabled: boolean): boolean;
   pressButton(button: number): void;
   releaseButton(button: number): void;
   hasBatteryBackedRam(): boolean;

package/extensions/nes/native/nes-core/native.d.ts

@@ -34,6 +34,7 @@ export declare class NativeNes {
   stepFrame(): void
   refreshFramebuffer(): void
   setVideoFilter(mode: number): void
+  setAudioEnabled(enabled: boolean): boolean
   pressButton(button: number): void
   releaseButton(button: number): void
   hasBatteryBackedRam(): boolean

package/extensions/nes/native/nes-core/package.json

@@ -6,7 +6,9 @@
   "types": "index.d.ts",
   "scripts": {
     "build": "napi build --release --dts native.d.ts",
-    "build:debug": "napi build --dts native.d.ts"
+    "build:debug": "napi build --dts native.d.ts",
+    "build:audio": "napi build --release --features audio-cpal --dts native.d.ts",
+    "build:audio:debug": "napi build --features audio-cpal --dts native.d.ts"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.2"

package/extensions/nes/native/nes-core/src/audio_cpal.rs

@@ -0,0 +1,217 @@
+use std::sync::{Arc, Mutex};
+
+use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
+use cpal::{SampleFormat, StreamConfig};
+use nes_rust::audio::Audio;
+use ringbuf::{traits::{Consumer, Producer, Split}, HeapCons, HeapProd, HeapRb};
+
+const TARGET_SAMPLE_RATE: u32 = 44_100;
+const RING_BUFFER_CAPACITY: usize = 44_100 * 2;
+
+#[derive(Clone)]
+pub struct CpalAudio {
+	inner: Arc<Mutex<CpalAudioInner>>,
+}
+
+struct CpalAudioInner {
+	producer: HeapProd<f32>,
+	consumer: HeapCons<f32>,
+	stream: Option<cpal::Stream>,
+	last_sample: f32,
+	channels: u16,
+}
+
+impl CpalAudio {
+	pub fn new() -> Self {
+		let ring = HeapRb::<f32>::new(RING_BUFFER_CAPACITY);
+		let (producer, consumer) = ring.split();
+		Self {
+			inner: Arc::new(Mutex::new(CpalAudioInner {
+				producer,
+				consumer,
+				stream: None,
+				last_sample: 0.0,
+				channels: 2,
+			})),
+		}
+	}
+
+	pub fn set_enabled(&self, enabled: bool) -> bool {
+		if enabled {
+			self.start_stream()
+		} else {
+			self.stop_stream();
+			true
+		}
+	}
+
+	fn stop_stream(&self) {
+		if let Ok(mut inner) = self.inner.lock() {
+			inner.stream.take();
+		}
+	}
+
+	fn start_stream(&self) -> bool {
+		{
+			if let Ok(inner) = self.inner.lock() {
+				if inner.stream.is_some() {
+					return true;
+				}
+			}
+		}
+
+		let host = cpal::default_host();
+		let device = match host.default_output_device() {
+			Some(device) => device,
+			None => return false,
+		};
+
+		let config = select_output_config(&device).or_else(|| device.default_output_config().ok());
+		let config = match config {
+			Some(config) => config,
+			None => return false,
+		};
+
+		let sample_format = config.sample_format();
+		let stream_config: StreamConfig = config.clone().into();
+		let channels = stream_config.channels;
+		let inner = self.inner.clone();
+
+		let stream = match sample_format {
+			SampleFormat::F32 => device.build_output_stream(
+				&stream_config,
+				move |data: &mut [f32], _| fill_output_f32(data, channels, &inner),
+				log_stream_error,
+				None,
+			),
+			SampleFormat::I16 => device.build_output_stream(
+				&stream_config,
+				move |data: &mut [i16], _| fill_output_i16(data, channels, &inner),
+				log_stream_error,
+				None,
+			),
+			SampleFormat::U16 => device.build_output_stream(
+				&stream_config,
+				move |data: &mut [u16], _| fill_output_u16(data, channels, &inner),
+				log_stream_error,
+				None,
+			),
+			_ => return false,
+		};
+
+		let stream = match stream {
+			Ok(stream) => stream,
+			Err(_) => return false,
+		};
+
+		if stream.play().is_err() {
+			return false;
+		}
+
+		if let Ok(mut inner) = self.inner.lock() {
+			inner.channels = channels;
+			inner.stream = Some(stream);
+		}
+
+		true
+	}
+}
+
+impl Audio for CpalAudio {
+	fn push(&mut self, value: f32) {
+		if let Ok(mut inner) = self.inner.lock() {
+			let _ = inner.producer.try_push(value);
+		}
+	}
+
+	fn copy_sample_buffer(&mut self, sample_buffer: &mut [f32]) {
+		if let Ok(mut inner) = self.inner.lock() {
+			for sample in sample_buffer.iter_mut() {
+				*sample = next_sample(&mut inner);
+			}
+		}
+	}
+}
+
+fn select_output_config(device: &cpal::Device) -> Option<cpal::SupportedStreamConfig> {
+	let configs = device.supported_output_configs().ok()?;
+	let mut best: Option<(i32, cpal::SupportedStreamConfig)> = None;
+
+	for config in configs {
+		let min = config.min_sample_rate();
+		let max = config.max_sample_rate();
+		if TARGET_SAMPLE_RATE < min || TARGET_SAMPLE_RATE > max {
+			continue;
+		}
+		let score = score_config(&config);
+		let config = config.with_sample_rate(TARGET_SAMPLE_RATE);
+		if best.as_ref().map(|(best_score, _)| score > *best_score).unwrap_or(true) {
+			best = Some((score, config));
+		}
+	}
+
+	best.map(|(_, config)| config)
+}
+
+fn score_config(config: &cpal::SupportedStreamConfigRange) -> i32 {
+	let mut score = 0;
+	match config.sample_format() {
+		SampleFormat::F32 => score += 100,
+		SampleFormat::I16 => score += 60,
+		SampleFormat::U16 => score += 50,
+		_ => score += 0,
+	}
+	if config.channels() >= 2 {
+		score += 10;
+	}
+	score
+}
+
+fn fill_output_f32(output: &mut [f32], channels: u16, inner: &Arc<Mutex<CpalAudioInner>>) {
+	if let Ok(mut inner) = inner.lock() {
+		for frame in output.chunks_mut(channels as usize) {
+			let sample = next_sample(&mut inner);
+			for out in frame.iter_mut() {
+				*out = sample;
+			}
+		}
+	}
+}
+
+fn fill_output_i16(output: &mut [i16], channels: u16, inner: &Arc<Mutex<CpalAudioInner>>) {
+	if let Ok(mut inner) = inner.lock() {
+		for frame in output.chunks_mut(channels as usize) {
+			let sample = next_sample(&mut inner);
+			let value = (sample.clamp(-1.0, 1.0) * i16::MAX as f32) as i16;
+			for out in frame.iter_mut() {
+				*out = value;
+			}
+		}
+	}
+}
+
+fn fill_output_u16(output: &mut [u16], channels: u16, inner: &Arc<Mutex<CpalAudioInner>>) {
+	if let Ok(mut inner) = inner.lock() {
+		for frame in output.chunks_mut(channels as usize) {
+			let sample = next_sample(&mut inner);
+			let normalized = (sample.clamp(-1.0, 1.0) + 1.0) * 0.5;
+			let value = (normalized * u16::MAX as f32) as u16;
+			for out in frame.iter_mut() {
+				*out = value;
+			}
+		}
+	}
+}
+
+fn next_sample(inner: &mut CpalAudioInner) -> f32 {
+	if let Some(sample) = inner.consumer.try_pop() {
+		inner.last_sample = sample;
+		sample
+	} else {
+		inner.last_sample
+	}
+}
+
+fn log_stream_error(error: cpal::StreamError) {
+	eprintln!("NES audio stream error: {error}");
+}

package/extensions/nes/native/nes-core/src/lib.rs

@@ -1,14 +1,53 @@
 use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
+use nes_rust::audio::Audio;
 use nes_rust::button::Button;
+#[cfg(not(feature = "audio-cpal"))]
 use nes_rust::default_audio::DefaultAudio;
 use nes_rust::default_input::DefaultInput;
 use nes_rust::display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH};
 use nes_rust::rom::Rom;
 use nes_rust::Nes;
 
+#[cfg(feature = "audio-cpal")]
+mod audio_cpal;
+#[cfg(feature = "audio-cpal")]
+use audio_cpal::CpalAudio;
+
 const FRAME_BYTE_LEN: usize = (SCREEN_WIDTH * SCREEN_HEIGHT * 3) as usize;
 
+enum AudioBackend {
+	#[cfg(feature = "audio-cpal")]
+	Cpal(CpalAudio),
+	#[cfg(not(feature = "audio-cpal"))]
+	Default,
+}
+
+impl AudioBackend {
+	fn set_enabled(&self, enabled: bool) -> bool {
+		match self {
+			#[cfg(feature = "audio-cpal")]
+			AudioBackend::Cpal(audio) => audio.set_enabled(enabled),
+			#[cfg(not(feature = "audio-cpal"))]
+			AudioBackend::Default => false,
+		}
+	}
+}
+
+fn create_audio_backend() -> (Box<dyn Audio>, AudioBackend) {
+	#[cfg(feature = "audio-cpal")]
+	{
+		let audio = CpalAudio::new();
+		return (Box::new(audio.clone()), AudioBackend::Cpal(audio));
+	}
+
+	#[cfg(not(feature = "audio-cpal"))]
+	{
+		let audio = DefaultAudio::new();
+		return (Box::new(audio), AudioBackend::Default);
+	}
+}
+
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum VideoFilterMode {
 	Off,
@@ -96,6 +135,7 @@ pub struct NativeNes {
 	framebuffer: Vec<u8>,
 	filter_buffer: Vec<u8>,
 	video_filter: VideoFilterMode,
+	audio_backend: AudioBackend,
 }
 
 #[napi]
@@ -104,13 +144,14 @@ impl NativeNes {
 	pub fn new() -> Self {
 		let input = Box::new(DefaultInput::new());
 		let display = Box::new(NativeDisplay::new());
-		let audio = Box::new(DefaultAudio::new());
+		let (audio, audio_backend) = create_audio_backend();
 		let nes = Nes::new(input, display, audio);
 		Self {
 			nes,
 			framebuffer: vec![0; FRAME_BYTE_LEN],
 			filter_buffer: vec![0; FRAME_BYTE_LEN],
 			video_filter: VideoFilterMode::Off,
+			audio_backend,
 		}
 	}
 
@@ -149,6 +190,11 @@ impl NativeNes {
 		};
 	}
 
+	#[napi]
+	pub fn set_audio_enabled(&mut self, enabled: bool) -> bool {
+		self.audio_backend.set_enabled(enabled)
+	}
+
 	#[napi]
 	pub fn press_button(&mut self, button: u8) {
 		if let Some(mapped) = map_button(button) {

package/extensions/nes/nes-core.ts

@@ -61,6 +61,7 @@ interface NativeNesInstance {
 	stepFrame(): void;
 	refreshFramebuffer(): void;
 	setVideoFilter(mode: number): void;
+	setAudioEnabled(enabled: boolean): boolean;
 	pressButton(button: number): void;
 	releaseButton(button: number): void;
 	hasBatteryBackedRam(): boolean;
@@ -118,15 +119,16 @@ class NativeNesCore implements NesCore {
 	private hasSram = false;
 
 	constructor(enableAudio: boolean, videoFilter: VideoFilterMode) {
-		this.audioWarning = enableAudio
-			? "Audio output is disabled (no safe dependency available)."
-			: null;
 		const module = getNativeModule();
 		if (!module) {
 			throw new Error("Native NES core addon is not available.");
 		}
 		this.nes = new module.NativeNes();
 		this.nes.setVideoFilter(NATIVE_VIDEO_FILTER_MAP[videoFilter]);
+		const audioEnabled = this.nes.setAudioEnabled(enableAudio);
+		this.audioWarning = enableAudio && !audioEnabled
+			? "Audio output unavailable. Rebuild the native core with --features audio-cpal."
+			: null;
 		this.frameBuffer = this.nes.getFramebuffer();
 	}
 
@@ -192,6 +194,7 @@ class NativeNesCore implements NesCore {
 
 	dispose(): void {
 		// No explicit native teardown required; napi instance is GC-managed.
+		this.nes.setAudioEnabled(false);
 		this.hasSram = false;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmustier/pi-nes",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "NES emulator extension for pi",
   "keywords": [
     "pi-package",

package/spec.md

@@ -76,7 +76,7 @@ pi-nes/
   - `pixelScale` (float, e.g. 1.0)
   - `keybindings` (button-to-keys map, e.g. `{ "a": ["z"] }`)
 
-Note: audio output is currently disabled; setting `enableAudio` will show a warning.
+Note: audio output is opt-in; requires a native core built with `audio-cpal` and `enableAudio: true`.
 
 ## Milestones
 1. Skeleton extension + `/nes` command + overlay renderer