ferretro/examples/ffmpeg_recorder.rs

461 lines
16 KiB
Rust

extern crate ferretro;
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 ferretro::retro;
use ferretro::retro::ffi::{PixelFormat, GameGeometry, SystemAvInfo, SystemInfo};
use ferretro::retro::wrapper::{LibretroWrapper, Handler};
use ffmpeg::{ChannelLayout, Packet, codec, filter, format, frame, media};
use ffmpeg::util::rational::Rational;
struct MyEmulator {
retro: retro::wrapper::LibretroWrapper,
sys_info: SystemInfo,
av_info: SystemAvInfo,
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>,
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<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 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<filter::Graph, ffmpeg::Error> {
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", 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)
{
afilter
.get("out")
.unwrap()
.sink()
.set_frame_size(audio_encoder.frame_size());
}
}
Ok(afilter)
}
impl MyEmulator {
pub fn new(
core_path: impl AsRef<Path>,
sys_path: &Option<impl AsRef<Path>>,
video_path: impl AsRef<Path>,
mut octx: ffmpeg::format::context::Output,
) -> 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 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 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();
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, fps_int));
video_output.set_time_base(Rational::new(1, fps_int));
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 = 32040.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(64000);
audio_encoder.set_rate(44100);
audio_encoder.set_format(audio_encoder.codec().unwrap().audio().unwrap().formats().unwrap().nth(0).unwrap());
audio_encoder.set_channels(2);
audio_encoder.set_channel_layout(ChannelLayout::STEREO);
audio_encoder.set_time_base(Rational::new(1, fps_int));
audio_output.set_time_base(Rational::new(1, fps_int));
let mut audio_encoder = audio_encoder.open_as(acodec).unwrap();
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);
audio_output.set_parameters(&audio_encoder);
octx.write_header().unwrap();
let emu = MyEmulator {
retro,
sys_info,
av_info: av_info.clone(),
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()),
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
}
pub fn run(&mut self, frame: i64) {
self.frame += 1;
self.retro.run();
let mut vframe = self.video_frames.pop_front().unwrap();
self.video_filter.get("in").unwrap().source().add(&vframe).unwrap();
let mut filtered_vframe = frame::Video::empty();
while let Ok(..) = self.video_filter.get("out").unwrap().sink().frame(&mut filtered_vframe) {
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();
let mut encoded_packet = ffmpeg::Packet::empty();
while let Ok(..) = self.video_encoder.receive_packet(&mut encoded_packet) {
if encoded_packet.size() > 0 {
encoded_packet.set_stream(0); // use stream index...
//encoded_packet.rescale_ts(Rational(1, 1), Rational(1, 60));
encoded_packet.write_interleaved(&mut self.octx).unwrap(); // AAA
}
//encoded_packet.write_interleaved(&mut self.octx).unwrap(); // AAA
}
}
eprintln!("Audio buffer length {}", self.audio_buf.len());
let mut aframe = frame::Audio::new(
format::Sample::I16(format::sample::Type::Packed),
self.audio_buf.len(),
ChannelLayout::STEREO
);
aframe.set_channels(2);
aframe.set_rate(32040);
aframe.set_pts(Some(frame));
let aplane: &mut [(i16, i16)] = aframe.plane_mut(0);
aplane.copy_from_slice(self.audio_buf.as_ref());
//eprintln!("src: {:?}, dest: {:?}", self.audio_buf, aplane);
self.audio_buf.clear();
self.audio_filter.get("in").unwrap().source().add(&aframe).unwrap();
let mut filtered_aframe = frame::Audio::empty();
while let Ok(..) = self.audio_filter.get("out").unwrap().sink().frame(&mut filtered_aframe) {
if self.audio_filter.get("in").unwrap().source().failed_requests() > 0 {
println!("🎥 failed to put filter input frame");
}
filtered_aframe.set_pts(Some(frame));
self.audio_encoder.send_frame(&aframe).unwrap();
let mut encoded_packet = ffmpeg::Packet::empty();
while let Ok(..) = self.audio_encoder.receive_packet(&mut encoded_packet) {
if encoded_packet.size() > 0 {
encoded_packet.set_stream(1);
//encoded_packet.rescale_ts(Rational(1, 1), Rational(1, 60));
encoded_packet.write_interleaved(&mut self.octx).unwrap(); // AAA
}
}
}
}
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();
}
pub fn end(&mut self) {
self.octx.write_trailer().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)]
);
}
}
//vframe.set_pts(Some(self.frame as i64));
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 {
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());
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;
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;
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 log_print(&mut self, level: retro::ffi::LogLevel, msg: &str) {
eprint!("🕹️ [{:?}] {}", level, msg);
}
}
#[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::log::set_level(ffmpeg::log::Level::Trace);
ffmpeg::init().unwrap();
let mut octx = format::output(&opt.video)?;
unsafe {
(*octx.as_mut_ptr()).debug = 1;
eprintln!("oformat: {:?}", &((*octx.as_mut_ptr()).oformat));
eprintln!("flags: {:?}", (*(*octx.as_mut_ptr()).oformat).flags);
}
//octx.write_header().unwrap();
let mut emu = MyEmulator::new(opt.core, &opt.system, &opt.video, octx);
emu.load_game(opt.rom);
emu.frame_properties_locked = true;
//for frame in 0..60*10 {
for frame in 0..600 {
eprintln!("🖼️ frame: {}", frame);
emu.run(frame);
}
let mut packet = Packet::empty();
eprintln!("flushed: {:?}", emu.video_encoder.flush(&mut packet).unwrap());
emu.end();
//octx.write_trailer().unwrap();
Ok(())
}