diff --git a/examples/ffmpeg_recorder.rs b/examples/ffmpeg_recorder.rs index 2469dd6..31cd8ff 100644 --- a/examples/ffmpeg_recorder.rs +++ b/examples/ffmpeg_recorder.rs @@ -205,7 +205,7 @@ static bool ffmpeg_init_config(struct ff_config_param *params, audio_encoder.set_time_base(Rational::new(1, 60)); audio_output.set_time_base(Rational::new(1, 60)); - let mut audio_encoder = audio_encoder.open_as(acodec).unwrap(); + let audio_encoder = audio_encoder.open_as(acodec).unwrap(); //audio_output.set_parameters(&audio_encoder); let audio_filter = audio_filter(&audio_encoder, av_info.timing.sample_rate).unwrap(); @@ -359,7 +359,7 @@ static bool ffmpeg_init_config(struct ff_config_param *params, } - pub fn load_game(&self, rom: impl AsRef) { + pub fn load_game(&mut self, rom: impl AsRef) { let path = rom.as_ref(); let mut data = None; let mut v = Vec::new(); diff --git a/examples/sdl2_emulator.rs b/examples/sdl2_emulator.rs index 0ae554a..6493e9f 100644 --- a/examples/sdl2_emulator.rs +++ b/examples/sdl2_emulator.rs @@ -167,7 +167,7 @@ impl MyEmulator { } } - pub fn load_game(&self, rom: impl AsRef) { + pub fn load_game(&mut self, rom: impl AsRef) { let path = rom.as_ref(); let mut data = None; let mut v = Vec::new(); diff --git a/src/components/ffmpeg.rs b/src/components/ffmpeg.rs new file mode 100644 index 0000000..13893c7 --- /dev/null +++ b/src/components/ffmpeg.rs @@ -0,0 +1,519 @@ +extern crate ffmpeg_next as ffmpeg; + +use std::collections::VecDeque; +use std::io::Read; +use std::path::{Path, PathBuf}; +use std::pin::Pin; + +use structopt::StructOpt; +use failure::Fallible; + +use crate::prelude::*; + +use ffmpeg::{ChannelLayout, Packet, codec, filter, format, frame, media}; +use ffmpeg::util::rational::Rational; + +struct MyEmulator { + retro: LibretroWrapper, + sys_info: SystemInfo, + av_info: SystemAvInfo, + audio_buf: Vec<(i16, i16)>, + video_pixel_format: format::Pixel, + prev_video_frame: Option, + video_frames: VecDeque, + video_encoder: ffmpeg::encoder::Video, + audio_encoder: ffmpeg::encoder::Audio, + video_filter: filter::Graph, + audio_filter: filter::Graph, + sys_path: Option, + frame_properties_locked: bool, + octx: ffmpeg::format::context::Output, + frame: u64, +} + +fn video_filter( + video_encoder: &ffmpeg::encoder::video::Video, + av_info: &SystemAvInfo, + pix_fmt: PixelFormat, +) -> Result { + let mut vfilter = filter::Graph::new(); + let pix_fmt = match pix_fmt { + PixelFormat::ARGB1555 => if cfg!(target_endian = "big") { "rgb555be" } else { "rgb555le" }, + PixelFormat::ARGB8888 => "argb", + PixelFormat::RGB565 => if cfg!(target_endian = "big") { "rgb565be" } else { "rgb565le" }, + }; + let pixel_aspect = av_info.geometry.aspect_ratio / (av_info.geometry.base_width as f32 / av_info.geometry.base_height as f32); + let fps = if av_info.timing.fps == 0.0 { 60.0 } else { av_info.timing.fps }; + let args = format!( + "width={}:height={}:pix_fmt={}:frame_rate={}:pixel_aspect={}:time_base=1/{}", + av_info.geometry.base_width, + av_info.geometry.base_height, + pix_fmt, + fps, + pixel_aspect, + fps, + ); + eprintln!("đŸŽĨ filter args: {}", args); + vfilter.add(&filter::find("buffer").unwrap(), "in", &args)?; + //scale? + vfilter.add(&filter::find("buffersink").unwrap(), "out", "")?; + + { + let mut out = vfilter.get("out").unwrap(); + out.set_pixel_format(video_encoder.format()); + } + + vfilter.output("in", 0)? + .input("out", 0)? + .parse("null")?; // passthrough filter for video + + vfilter.validate()?; + // human-readable filter graph + eprintln!("{}", vfilter.dump()); + + Ok(vfilter) +} + +fn audio_filter( + audio_encoder: &ffmpeg::codec::encoder::Audio, + sample_rate: f64, +) -> Result { + let mut afilter = filter::Graph::new(); + let sample_rate = if sample_rate == 0.0 { 32040.0 } else { sample_rate }; + let args = format!("sample_rate={}:sample_fmt=s16:channel_layout=stereo:time_base=1/60", sample_rate); + eprintln!("🔊 filter args: {}", args); + afilter.add(&filter::find("abuffer").unwrap(), "in", &args)?; + //aresample? + afilter.add(&filter::find("abuffersink").unwrap(), "out", "")?; + + { + let mut out = afilter.get("out").unwrap(); + out.set_sample_format(audio_encoder.format()); + out.set_channel_layout(audio_encoder.channel_layout()); + out.set_sample_rate(audio_encoder.rate()); + } + + afilter.output("in", 0)? + .input("out", 0)? + .parse("anull")?; + afilter.validate()?; + // human-readable filter graph + eprintln!("{}", afilter.dump()); + + if let Some(codec) = audio_encoder.codec() { + if !codec + .capabilities() + .contains(ffmpeg::codec::capabilities::Capabilities::VARIABLE_FRAME_SIZE) + { + eprintln!("setting constant frame size {}", audio_encoder.frame_size()); + afilter + .get("out") + .unwrap() + .sink() + .set_frame_size(audio_encoder.frame_size()); + } + } + + Ok(afilter) +} + +impl MyEmulator { + pub fn new( + core_path: impl AsRef, + sys_path: &Option>, + video_path: impl AsRef, + mut octx: ffmpeg::format::context::Output, + ) -> Pin> { + let lib = libloading::Library::new(core_path.as_ref()).unwrap(); + let raw_retro = retro::loading::LibretroApi::from_library(lib).unwrap(); + let retro = retro::wrapper::LibretroWrapper::from(raw_retro); + + let sys_info = retro.get_system_info(); + let mut av_info = retro.get_system_av_info(); + + let fps_int = av_info.timing.fps.round() as i32; + let fps_int = if fps_int == 0 { 60 } else { fps_int }; + + let detected_vcodec = octx.format().codec(&video_path, media::Type::Video); + //let detected_acodec = octx.format().codec(&video_path, media::Type::Audio); +let wavname = Path::new("out.wav"); + let detected_acodec = octx.format().codec(&wavname, media::Type::Audio); + + let vcodec = ffmpeg::encoder::find(detected_vcodec).unwrap().video().unwrap(); + let acodec = ffmpeg::encoder::find(detected_acodec).unwrap().audio().unwrap(); + + let mut video_output = octx.add_stream(vcodec).unwrap(); + video_output.set_time_base(Rational::new(1, 60)); + let mut video_encoder = video_output.codec().encoder().video().unwrap(); + + video_encoder.set_bit_rate(2560000); + video_encoder.set_format(video_encoder.codec().unwrap().video().unwrap().formats().unwrap().nth(0).unwrap()); + + video_encoder.set_time_base(Rational::new(1, 60)); + video_encoder.set_frame_rate(Some(Rational::new(fps_int, 1))); + + //video_encoder.set_frame_rate(av_info.timing.fps.into()); + + if av_info.geometry.base_height == 0 && av_info.geometry.base_width == 0 { + av_info.geometry.base_width = 320; + av_info.geometry.base_height = 224; + av_info.geometry.aspect_ratio = 4.33; + } + if av_info.timing.sample_rate == 0.0 { + av_info.timing.sample_rate = 44100.0; + } + video_encoder.set_width(av_info.geometry.base_width); + video_encoder.set_height(av_info.geometry.base_height); + //video_encoder.set_aspect_ratio(av_info.geometry.aspect_ratio as f64); + + let pix_fmt = PixelFormat::ARGB1555; // temporary until env call is made + let video_filter = video_filter(&video_encoder, &av_info, pix_fmt).unwrap(); + + let video_encoder = video_encoder.open_as(vcodec).unwrap(); + //video_output.set_parameters(&video_encoder); + + let mut audio_output = octx.add_stream(acodec).unwrap(); + let mut audio_encoder = audio_output.codec().encoder().audio().unwrap(); + + //let mut video_encoder = octx.add_stream(vcodec).unwrap().codec().encoder().video().unwrap(); + /* + let mut audio_output = octx.add_stream(acodec).unwrap(); + let mut audio_encoder = audio_output.codec().encoder().audio().unwrap(); + */ + /* + retroarch inits +static bool ffmpeg_init_config(struct ff_config_param *params, + if (!ffmpeg_init_muxer_pre(handle)) + if (!ffmpeg_init_video(handle)) + av_frame_alloc + */ + + + audio_encoder.set_bit_rate(640000); + audio_encoder.set_max_bit_rate(990000); + + //audio_encoder.set_rate(44100); + audio_encoder.set_rate(av_info.timing.sample_rate.round() as i32); + audio_encoder.set_channels(2); + audio_encoder.set_channel_layout(ChannelLayout::STEREO); + audio_encoder.set_format(audio_encoder.codec().unwrap().audio().unwrap().formats().unwrap().nth(0).unwrap()); + audio_encoder.set_time_base(Rational::new(1, 60)); + audio_output.set_time_base(Rational::new(1, 60)); + + let mut audio_encoder = audio_encoder.open_as(acodec).unwrap(); + //audio_output.set_parameters(&audio_encoder); + + let audio_filter = audio_filter(&audio_encoder, av_info.timing.sample_rate).unwrap(); + + //audio_encoder.set_rate(av_info.timing.sample_rate.round() as i32); + + octx.write_header().unwrap(); + ffmpeg::format::context::output::dump(&octx, 0, None); + + let emu = MyEmulator { + retro, + sys_info, + av_info: av_info.clone(), + audio_buf: Default::default(), + video_pixel_format: format::Pixel::RGB555, + prev_video_frame: None, + video_frames: Default::default(), + video_encoder, + audio_encoder, + video_filter, + audio_filter, + sys_path: sys_path.as_ref().map(|x| x.as_ref().to_path_buf()), + frame_properties_locked: false, + octx, + frame: 0 + }; + + let mut pin_emu = Box::pin(emu); + retro::wrapper::set_handler(pin_emu.as_mut()); + pin_emu.retro.init(); + pin_emu.set_system_av_info(&av_info); + pin_emu + } + + fn receive_and_write_packets(&mut self, encoder: EncoderToWriteFrom) + { + let stream_index = match encoder { + EncoderToWriteFrom::Video => 0, + EncoderToWriteFrom::Audio => 1, + }; + let mut encoded_packet = ffmpeg::Packet::empty(); + loop + { + match match encoder { + EncoderToWriteFrom::Video => self.video_encoder.receive_packet(&mut encoded_packet), + EncoderToWriteFrom::Audio => self.audio_encoder.receive_packet(&mut encoded_packet), + } { + Ok(..) => { + //if encoded_packet.size() > 0 { + encoded_packet.set_stream(stream_index); + eprintln!("đŸ“Ļ Writing packet, pts {:?} dts {:?} size {}", encoded_packet.pts(), encoded_packet.dts(), encoded_packet.size()); + if stream_index == 0 { + encoded_packet.rescale_ts(Rational(1, 60), self.octx.stream(stream_index).unwrap().time_base()); + } + eprintln!("đŸ“Ļ rescaled , pts {:?} dts {:?} size {}", encoded_packet.pts(), encoded_packet.dts(), encoded_packet.size()); + + match encoded_packet.write_interleaved(&mut self.octx) { + Ok(..) => eprintln!("Write OK"), + Err(e) => eprintln!("Error writing: {}", e), + } + //encoded_packet.write_interleaved(&mut self.octx).unwrap(); // AAA + //} + //else { + //eprintln!("Did not try to write 0-length packet"); + //} + }, + Err(e) => { + eprintln!("Error writing packet: {:?}", e); + break; + } + } + } + } + + pub fn run(&mut self, frame: i64) { + self.frame += 1; + self.retro.run(); + + match self.video_frames.pop_front() { + Some(mut vframe) => { + vframe.set_pts(Some(frame)); + eprintln!("🎞 queue frame pts {:?}", vframe.pts()); + self.video_filter.get("in").unwrap().source().add(&vframe).unwrap(); + let mut filtered_vframe = frame::Video::empty(); + + loop { + match self.video_filter.get("out").unwrap().sink().frame(&mut filtered_vframe) { + Ok(..) => { + eprintln!("đŸŽĨ Got filtered video frame {}x{} pts {:?}", filtered_vframe.width(), filtered_vframe.height(), filtered_vframe.pts()); + if self.video_filter.get("in").unwrap().source().failed_requests() > 0 { + println!("đŸŽĨ failed to put filter input frame"); + } + //filtered_vframe.set_pts(Some(frame)); + self.video_encoder.send_frame(&filtered_vframe).unwrap(); + + self.receive_and_write_packets(EncoderToWriteFrom::Video); + }, + Err(e) => { + eprintln!("Error getting filtered video frame: {:?}", e); + break; + } + } + } + + let mut aframe = frame::Audio::new( + format::Sample::I16(format::sample::Type::Packed), + self.audio_buf.len(), + ChannelLayout::STEREO + ); + if aframe.planes() > 0 { + aframe.set_channels(2); + aframe.set_rate(44100); + aframe.set_pts(Some(frame)); + let aplane: &mut [(i16, i16)] = aframe.plane_mut(0); + eprintln!("Audio buffer length {} -> {}", self.audio_buf.len(), aplane.len()); + aplane.copy_from_slice(self.audio_buf.as_ref()); + //eprintln!("src: {:?}, dest: {:?}", self.audio_buf, aplane); + self.audio_buf.clear(); + + eprintln!("frame audio: {:?}", aframe); + + eprintln!("🎞 queue frame pts {:?}", aframe.pts()); + self.audio_filter.get("in").unwrap().source().add(&aframe).unwrap(); + + let mut filtered_aframe = frame::Audio::empty(); + loop { + match self.audio_filter.get("out").unwrap().sink().frame(&mut filtered_aframe) { + Ok(..) => { + eprintln!("🔊 Got filtered audio frame {:?} pts {:?}", filtered_aframe, filtered_aframe.pts()); + if self.audio_filter.get("in").unwrap().source().failed_requests() > 0 { + println!("đŸŽĨ failed to put filter input frame"); + } + //let faplane: &[f32] = filtered_aframe.plane(0); + //filtered_aframe.set_pts(Some(frame)); + + self.audio_encoder.send_frame(&filtered_aframe).unwrap(); + self.receive_and_write_packets(EncoderToWriteFrom::Audio); + }, + Err(e) => { + eprintln!("Error getting filtered audio frame: {:?}", e); + break; + } + } + } + } + }, + None => println!("Video not ready during frame {}", self.frame) + } + + + + } + + pub fn load_game(&self, rom: impl AsRef) { + let path = rom.as_ref(); + let mut data = None; + let mut v = Vec::new(); + if !self.sys_info.need_fullpath { + if let Ok(mut f) = std::fs::File::open(path) { + if f.read_to_end(&mut v).is_ok() { + data = Some(v.as_ref()); + } + } + } + self.retro + .load_game(Some(path), data, None) + .unwrap(); + } + + pub fn end(&mut self) { + self.video_encoder.send_eof(); + self.receive_and_write_packets(EncoderToWriteFrom::Video); + self.audio_encoder.send_eof(); + self.receive_and_write_packets(EncoderToWriteFrom::Audio); + self.octx.write_trailer().unwrap(); + } + + pub fn unserialize(&mut self, state: impl AsRef) -> Fallible<()> { + let path = state.as_ref(); + let mut v = Vec::new(); + if let Ok(mut f) = std::fs::File::open(path) { + if f.read_to_end(&mut v).is_ok(){ + return self.retro.unserialize(v.as_ref()); + } + } + Err(failure::err_msg("Couldn't read file to unserialize")) + } +} + +impl retro::wrapper::LibretroWrapperAccess for MyEmulator { + fn libretro_core(&mut self) -> &mut LibretroWrapper { + &mut self.retro + } +} + +impl retro::wrapper::RetroCallbacks for MyEmulator { + fn video_refresh(&mut self, data: &[u8], width: u32, height: u32, pitch: u32) { + let mut vframe = frame::Video::new(self.video_pixel_format, width, height); + + let stride = vframe.stride(0); + let pitch = pitch as usize; + + let vplane = vframe.data_mut(0); + if data.len() == vplane.len() && pitch == stride { + vplane.copy_from_slice(&data); + } else { + for y in 0..(height as usize) { + let ffbegin = y * stride; + let lrbegin = y * pitch; + let min = usize::min(stride, pitch); + vplane[ffbegin..(ffbegin + min)].copy_from_slice( + &data[lrbegin..(lrbegin + min)] + ); + } + } + + //vframe.set_pts(Some(self.frame as i64)); + + self.prev_video_frame.replace(vframe.clone()); + self.video_frames.push_back(vframe); + } + + fn video_refresh_dupe(&mut self, width: u32, height: u32, _pitch: u32) { + if let Some(frame) = &self.prev_video_frame { + self.video_frames.push_back(frame.clone()); + } else { + let vframe = frame::Video::new(self.video_pixel_format, width, height); + self.video_frames.push_back(vframe); + } + } + + fn audio_sample(&mut self, left: i16, right: i16) { + self.audio_buf.push((left, right)); + } + + fn audio_sample_batch(&mut self, stereo_pcm: &[i16]) -> usize { + let left_iter = stereo_pcm.iter().step_by(2).cloned(); + let right_iter = stereo_pcm.iter().skip(1).step_by(2).cloned(); + self.audio_buf.extend(Iterator::zip(left_iter, right_iter)); + stereo_pcm.len() + } + + fn get_system_directory(&mut self) -> Option { + self.sys_path.clone() + } + + fn set_pixel_format(&mut self, format: PixelFormat) -> bool { + if self.frame_properties_locked { + return true; + } + + self.video_pixel_format = match format { + PixelFormat::ARGB1555 => format::Pixel::RGB555, + PixelFormat::ARGB8888 => format::Pixel::RGB32, + PixelFormat::RGB565 => format::Pixel::RGB565, + }; + self.video_filter = video_filter(&self.video_encoder, &self.av_info, format).unwrap(); + true + } + + fn set_system_av_info(&mut self, system_av_info: &SystemAvInfo) -> bool { + if self.frame_properties_locked { + return true; + } + + //self.video_encoder.set_frame_rate(system_av_info.timing.fps.into()); + //self.video_encoder.set_time_base(Rational::new(1, 60)); + //self.video_encoder.set_frame_rate(Some(Rational::new(1, 60))); + if system_av_info.timing.sample_rate.round() as i32 > 0 { + self.audio_encoder.set_rate(system_av_info.timing.sample_rate.round() as i32); + } + self.av_info.timing = system_av_info.timing.clone(); + self.set_geometry(&system_av_info.geometry); + true + } + + fn set_geometry(&mut self, geometry: &GameGeometry) -> bool { + if self.frame_properties_locked { + return true; + } + + self.video_encoder.set_width(geometry.base_width); + self.video_encoder.set_height(geometry.base_height); + //self.video_encoder.set_aspect_ratio(geometry.aspect_ratio as f64); + self.av_info.geometry = geometry.clone(); + let pixel_format = match self.video_pixel_format { + format::Pixel::RGB555 => PixelFormat::ARGB1555, + format::Pixel::RGB32 => PixelFormat::ARGB8888, + format::Pixel::RGB565 => PixelFormat::RGB565, + _ => unimplemented!(), + }; + self.video_filter = video_filter(&self.video_encoder, &self.av_info, pixel_format).unwrap(); + true + } + + + fn get_variable(&mut self, key: &str) -> Option { + match key { + "beetle_saturn_analog_stick_deadzone" => Some("15%".to_string()), + "parallel-n64-gfxplugin" => Some("angrylion".to_string()), + "parallel-n64-astick-deadzone" => Some("15%".to_string()), + _ => None, + } + } + + fn set_variables(&mut self, variables: &Vec) -> bool { + for v in variables { + eprintln!("{:?}", v); + } + true + } + + fn log_print(&mut self, level: retro::ffi::LogLevel, msg: &str) { + eprint!("🕹ī¸ [{:?}] {}", level, msg); + } +} diff --git a/src/components/mod.rs b/src/components/mod.rs index 2cb0116..7a017b4 100644 --- a/src/components/mod.rs +++ b/src/components/mod.rs @@ -1,3 +1,5 @@ +//pub mod ffmpeg; + use crate::prelude::*; use crate::retro::ffi::*; use std::os::raw::c_uint; diff --git a/src/lib.rs b/src/lib.rs index e9ae16f..d789f27 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -8,4 +8,5 @@ pub mod prelude { pub use crate::retro::constants::*; pub use crate::retro::wrapped_types::*; pub use crate::retro::wrapper::{RetroCallbacks, LibretroWrapper, LibretroWrapperAccess}; + pub use crate::retro::ffi::{PixelFormat, GameGeometry, SystemAvInfo, SystemInfo}; } diff --git a/src/retro/loading.rs b/src/retro/loading.rs index 9f889f8..cac7572 100644 --- a/src/retro/loading.rs +++ b/src/retro/loading.rs @@ -46,31 +46,31 @@ impl LibretroApi { } } /// set_environment() must be called before init(). - pub fn set_environment(&self, cb: EnvironmentFn) { + pub fn set_environment(&mut self, cb: EnvironmentFn) { unsafe { (&self.core_api.retro_set_environment)(cb) } } /// set_video_refresh() must be called before run(). - pub fn set_video_refresh(&self, cb: VideoRefreshFn) { + pub fn set_video_refresh(&mut self, cb: VideoRefreshFn) { unsafe { (&self.core_api.retro_set_video_refresh)(cb) } } - pub fn set_audio_sample(&self, cb: AudioSampleFn) { + pub fn set_audio_sample(&mut self, cb: AudioSampleFn) { unsafe { (&self.core_api.retro_set_audio_sample)(cb) } } - pub fn set_audio_sample_batch(&self, cb: AudioSampleBatchFn) { + pub fn set_audio_sample_batch(&mut self, cb: AudioSampleBatchFn) { unsafe { (&self.core_api.retro_set_audio_sample_batch)(cb) } } - pub fn set_input_poll(&self, cb: InputPollFn) { + pub fn set_input_poll(&mut self, cb: InputPollFn) { unsafe { (&self.core_api.retro_set_input_poll)(cb) } } - pub fn set_input_state(&self, cb: InputStateFn) { + pub fn set_input_state(&mut self, cb: InputStateFn) { unsafe { (&self.core_api.retro_set_input_state)(cb) } } /// set_environment() must be called before init(). - pub fn init(&self) { + pub fn init(&mut self) { // TODO assert!(called retro_set_environment); unsafe { (&self.core_api.retro_init)() } } - pub fn deinit(&self) { + pub fn deinit(&mut self) { unsafe { (&self.core_api.retro_deinit)() } } /// Must return RETRO_API_VERSION. Used to validate ABI compatibility when the API is revised. @@ -110,11 +110,11 @@ impl LibretroApi { /// the core should call RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS to notify the /// frontend if the descriptions for any controls have changed as a /// result of changing the device type. - pub fn set_controller_port_device(&self, port: u32, device: u32) { + pub fn set_controller_port_device(&mut self, port: u32, device: u32) { unsafe { (&self.core_api.retro_set_controller_port_device)(port, device) } } /// Resets the current game. - pub fn reset(&self) { + pub fn reset(&mut self) { unsafe { (&self.core_api.retro_reset)() } } /// Runs the game for one video frame. @@ -124,11 +124,11 @@ impl LibretroApi { /// this still counts as a frame, and retro_run() should explicitly dupe /// a frame if GET_CAN_DUPE returns true. /// In this case, the video callback can take a NULL argument for data. - pub fn run(&self) { + pub fn run(&mut self) { unsafe { (&self.core_api.retro_run)() } } /// Serializes internal state. - pub fn serialize(&self) -> Fallible> { + pub fn serialize(&mut self) -> Fallible> { let size: usize = unsafe { (&self.core_api.retro_serialize_size)() }; let mut vec = Vec::with_capacity(size); vec.resize(size, 0); @@ -139,7 +139,7 @@ impl LibretroApi { Err(failure::err_msg("Serialize failed")) } } - pub fn unserialize(&self, data: &[u8]) -> Fallible<()> { + pub fn unserialize(&mut self, data: &[u8]) -> Fallible<()> { // validate size of the data let size: usize = unsafe { (&self.core_api.retro_serialize_size)() }; if data.len() != size { @@ -152,15 +152,15 @@ impl LibretroApi { Err(failure::err_msg("Unserialize failed")) } } - pub fn cheat_reset(&self) { + pub fn cheat_reset(&mut self) { unsafe { (&self.core_api.retro_cheat_reset)() } } - pub fn cheat_set(&self, index: u32, enabled: bool, code: &str) { + pub fn cheat_set(&mut self, index: u32, enabled: bool, code: &str) { unsafe { (&self.core_api.retro_cheat_set)(index, enabled, code.as_bytes().as_ptr() as *const c_char) } } /// Loads a game. pub fn load_game( - &self, + &mut self, path: Option<&Path>, data: Option<&[u8]>, meta: Option<&str>, @@ -194,7 +194,7 @@ impl LibretroApi { } } /// Unloads the currently loaded game. Called before deinit(). - pub fn unload_game(&self) { + pub fn unload_game(&mut self) { unsafe { (&self.core_api.retro_unload_game)() } } pub fn get_region(&self) -> Region { diff --git a/src/retro/wrapper.rs b/src/retro/wrapper.rs index d17d916..5c68f19 100644 --- a/src/retro/wrapper.rs +++ b/src/retro/wrapper.rs @@ -4,7 +4,7 @@ use core::slice::from_raw_parts; use std::convert::TryFrom; use std::ffi::{CStr, CString}; -use std::ops::Deref; +use std::ops::{Deref, DerefMut}; use std::os::raw::{c_char, c_uint}; use std::os::unix::ffi::OsStrExt; use std::path::{Path, PathBuf}; @@ -29,14 +29,10 @@ extern "C" { fn c_ext_set_log_print_cb(cb: WrappedLogPrintFn); } -pub trait LibretroWrapperAccess { - fn libretro_core(&mut self) -> &mut LibretroWrapper; -} - // method docs largely copied/lightly-adapted-to-rust straight from libretro.h. #[rustfmt::skip] #[allow(unused)] -pub trait RetroCallbacks: LibretroWrapperAccess + Unpin + 'static { +pub trait RetroCallbacks: Unpin + 'static { // -- main callbacks -- /// Render a frame. Pixel format is 15-bit 0RGB1555 native endian /// unless changed (see [Self::set_pixel_format]). @@ -370,9 +366,16 @@ pub trait RetroCallbacks: LibretroWrapperAccess + Unpin + 'static { fn get_sensor_input(&mut self, port: c_uint, id: c_uint) -> f32 { 0.0 } } +pub trait LibretroWrapperAccess { + fn libretro_core(&mut self) -> &mut LibretroWrapper; +} + +pub trait RootRetroCallbacks : RetroCallbacks + LibretroWrapperAccess {} +impl RootRetroCallbacks for T {} + #[derive(Default)] struct StaticCallbacks { - handler: Option>, + handler: Option>, } unsafe impl Sync for StaticCallbacks {} @@ -854,11 +857,17 @@ impl Deref for LibretroWrapper { } } +impl DerefMut for LibretroWrapper { + fn deref_mut(&mut self) -> &mut LibretroApi { + &mut self.api + } +} + // a note on lifetimes: we explicitly lie about them here because as long as they live as long as // the library wrapper itself we're good (we wipe our 'static references on drop() too) -pub fn set_handler(handler: Pin<&'_ mut (dyn RetroCallbacks + '_)>) { +pub fn set_handler(handler: Pin<&'_ mut (dyn RootRetroCallbacks + '_)>) { unsafe { - let ptr = handler.get_unchecked_mut() as *mut dyn RetroCallbacks; + let ptr = handler.get_unchecked_mut() as *mut dyn RootRetroCallbacks; CB_SINGLETON .handler .replace(Pin::new_unchecked(ptr.as_mut().unwrap()));