296 lines
9.8 KiB
Rust
296 lines
9.8 KiB
Rust
extern crate ferretro;
|
|
extern crate ffmpeg4 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 ferretro::retro;
|
|
use ferretro::retro::ffi::{PixelFormat, GameGeometry, SystemAvInfo, SystemInfo};
|
|
use ferretro::retro::wrapper::{LibretroWrapper, Handler};
|
|
|
|
use ffmpeg::{format, filter, frame, media, ChannelLayout};
|
|
use ffmpeg::util::rational::Rational;
|
|
|
|
struct MyEmulator {
|
|
retro: retro::wrapper::LibretroWrapper,
|
|
sys_info: SystemInfo,
|
|
audio_buf: Vec<(i16, i16)>,
|
|
video_pixel_format: format::Pixel,
|
|
video_frames: VecDeque<frame::Video>,
|
|
video_encoder: ffmpeg::encoder::Video,
|
|
audio_encoder: ffmpeg::encoder::Audio,
|
|
video_filter: filter::Graph,
|
|
audio_filter: filter::Graph,
|
|
sys_path: Option<PathBuf>,
|
|
}
|
|
|
|
fn video_filter(
|
|
video_encoder: &ffmpeg::encoder::video::Video,
|
|
av_info: &SystemAvInfo,
|
|
pix_fmt: PixelFormat,
|
|
) -> Result<filter::Graph, ffmpeg::Error> {
|
|
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 args = format!(
|
|
"buffer=width={}:height={}:pix_fmt={}:frame_rate={}:pixel_aspect={}",
|
|
av_info.geometry.base_width,
|
|
av_info.geometry.base_height,
|
|
pix_fmt,
|
|
av_info.timing.fps,
|
|
pixel_aspect,
|
|
);
|
|
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)?;
|
|
vfilter.validate()?;
|
|
|
|
Ok(vfilter)
|
|
}
|
|
|
|
fn audio_filter(
|
|
audio_encoder: &ffmpeg::encoder::audio::Audio,
|
|
sample_rate: f64,
|
|
) -> Result<filter::Graph, ffmpeg::Error> {
|
|
let mut afilter = filter::Graph::new();
|
|
let args = format!("sample_rate={}:sample_fmt=s16:channel_layout=stereo", sample_rate);
|
|
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)?;
|
|
afilter.validate()?;
|
|
|
|
Ok(afilter)
|
|
}
|
|
|
|
impl MyEmulator {
|
|
pub fn new(
|
|
core_path: impl AsRef<Path>,
|
|
sys_path: &Option<impl AsRef<Path>>,
|
|
mut video_encoder: ffmpeg::encoder::video::Video,
|
|
mut audio_encoder: ffmpeg::encoder::audio::Audio,
|
|
) -> Pin<Box<Self>> {
|
|
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 av_info = retro.get_system_av_info();
|
|
|
|
video_encoder.set_time_base(Rational::new(1, av_info.timing.fps.round() as i32));
|
|
video_encoder.set_frame_rate(av_info.timing.fps.into());
|
|
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);
|
|
|
|
audio_encoder.set_rate(system_av_info.timing.sample_rate.round() as i32);
|
|
|
|
let video_filter = video_filter(&video_encoder, &av_info).unwrap();
|
|
let audio_filter = audio_filter(&audio_encoder, av_info.timing.sample_rate).unwrap();
|
|
|
|
let video_encoder = video_encoder.open().unwrap();
|
|
let audio_encoder = audio_encoder.open().unwrap();
|
|
|
|
let emu = MyEmulator {
|
|
retro,
|
|
sys_info,
|
|
audio_buf: Default::default(),
|
|
video_pixel_format: format::Pixel::RGB555,
|
|
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()),
|
|
};
|
|
|
|
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
|
|
}
|
|
|
|
pub fn run(&mut self) {
|
|
self.retro.run();
|
|
|
|
let vframe = self.video_frames.pop_front().unwrap();
|
|
let mut aframe = frame::Audio::new(
|
|
format::Sample::I16(format::sample::Type::Packed),
|
|
self.audio_buf.len(),
|
|
ChannelLayout::STEREO
|
|
);
|
|
let aplane: &mut [(i16, i16)] = aframe.plane_mut(0);
|
|
aplane.copy_from_slice(self.audio_buf.as_ref());
|
|
self.audio_buf.clear();
|
|
|
|
let mut out = ffmpeg::Packet::empty();
|
|
self.video_encoder.encode(&vframe, &mut out).unwrap();
|
|
self.audio_encoder.encode(&aframe, &mut out).unwrap();
|
|
}
|
|
|
|
pub fn load_game(&self, rom: impl AsRef<Path>) {
|
|
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();
|
|
}
|
|
}
|
|
|
|
impl retro::wrapper::Handler for MyEmulator {
|
|
fn libretro_core(&mut self) -> &mut LibretroWrapper {
|
|
&mut self.retro
|
|
}
|
|
|
|
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)]
|
|
);
|
|
}
|
|
}
|
|
|
|
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_can_dupe(&mut self) -> Option<bool> { Some(false) }
|
|
|
|
fn get_system_directory(&mut self) -> Option<PathBuf> {
|
|
self.sys_path.clone()
|
|
}
|
|
|
|
fn set_pixel_format(&mut self, format: PixelFormat) -> bool {
|
|
self.video_pixel_format = match format {
|
|
PixelFormat::ARGB1555 => format::Pixel::RGB555,
|
|
PixelFormat::ARGB8888 => format::Pixel::RGB32,
|
|
PixelFormat::RGB565 => format::Pixel::RGB565,
|
|
};
|
|
true
|
|
}
|
|
|
|
fn set_system_av_info(&mut self, system_av_info: SystemAvInfo) -> bool {
|
|
self.video_encoder.set_frame_rate(system_av_info.timing.fps.into());
|
|
self.audio_encoder.set_rate(system_av_info.timing.sample_rate.round() as i32);
|
|
self.set_geometry(system_av_info.geometry);
|
|
true
|
|
}
|
|
|
|
fn set_geometry(&mut self, geometry: GameGeometry) -> bool {
|
|
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);
|
|
true
|
|
}
|
|
}
|
|
|
|
#[derive(StructOpt)]
|
|
struct Opt {
|
|
/// Core module to use.
|
|
#[structopt(short, long, parse(from_os_str))]
|
|
core: PathBuf,
|
|
/// ROM to load using the core.
|
|
#[structopt(short, long, parse(from_os_str))]
|
|
rom: PathBuf,
|
|
/// Recorded video to write.
|
|
#[structopt(short, long, parse(from_os_str))]
|
|
video: PathBuf,
|
|
/// System directory, often containing BIOS files
|
|
#[structopt(short, long, parse(from_os_str))]
|
|
system: Option<PathBuf>,
|
|
}
|
|
|
|
fn main() -> Fallible<()> {
|
|
let opt: Opt = Opt::from_args();
|
|
ffmpeg::init().unwrap();
|
|
|
|
let mut octx = format::output(&opt.video)?;
|
|
|
|
let detected_vcodec = octx.format().codec(&opt.video, media::Type::Video);
|
|
let detected_acodec = octx.format().codec(&opt.video, media::Type::Audio);
|
|
|
|
let vcodec = ffmpeg::encoder::find(detected_vcodec).unwrap().video()?;
|
|
let acodec = ffmpeg::encoder::find(detected_acodec).unwrap().audio()?;
|
|
|
|
let mut video_encoder = octx.add_stream(vcodec)?.codec().encoder().video()?;
|
|
let mut audio_encoder = octx.add_stream(acodec)?.codec().encoder().audio()?;
|
|
|
|
video_encoder.set_bit_rate(64000);
|
|
video_encoder.set_format(video_encoder.codec().unwrap().video()?.formats().unwrap().nth(0).unwrap());
|
|
|
|
audio_encoder.set_bit_rate(64000);
|
|
audio_encoder.set_rate(44100);
|
|
audio_encoder.set_format(audio_encoder.codec().unwrap().audio()?.formats().unwrap().nth(0).unwrap());
|
|
audio_encoder.set_channels(2);
|
|
audio_encoder.set_channel_layout(ChannelLayout::STEREO);
|
|
|
|
let mut emu = MyEmulator::new(opt.core, &opt.system, video_encoder, audio_encoder);
|
|
emu.load_game(opt.rom);
|
|
|
|
octx.write_header().unwrap();
|
|
|
|
for _ in 0..60*60 {
|
|
emu.run();
|
|
}
|
|
|
|
octx.write_trailer().unwrap();
|
|
Ok(())
|
|
}
|