initial commit
This commit is contained in:
commit
c9e16119a1
|
|
@ -0,0 +1,7 @@
|
|||
/target
|
||||
mastodon-data.toml
|
||||
*.mp4
|
||||
*.z64
|
||||
*.sh
|
||||
*.so
|
||||
dkgolf
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,20 @@
|
|||
[package]
|
||||
name = "dkgolf"
|
||||
version = "0.1.0"
|
||||
authors = ["viv <vvnl+git@protonmail.com>"]
|
||||
edition = "2018"
|
||||
|
||||
[build-dependencies]
|
||||
cc = "^1"
|
||||
|
||||
[dependencies]
|
||||
libretro-sys = "^0.1"
|
||||
failure = "^0.1"
|
||||
libloading = "^0.5"
|
||||
num_enum = "^0.4"
|
||||
ffmpeg-next = "4.3.8"
|
||||
rand = "0.8.4"
|
||||
ferretro = { git = "ssh://git@vvn.space:2222/cinnabon/rustro.git", branch = "viv/ffmpeg2" }
|
||||
structopt = "^0.3"
|
||||
mammut = "0.13.0"
|
||||
toml = "0.5.8"
|
||||
|
|
@ -0,0 +1,937 @@
|
|||
extern crate ferretro;
|
||||
extern crate ffmpeg_next as ffmpeg;
|
||||
extern crate rand;
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::collections::VecDeque;
|
||||
use std::fs::File;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::pin::Pin;
|
||||
|
||||
use ferretro::retro::constants::{InputIndex, JoypadButton};
|
||||
use mammut::apps::{AppBuilder, Scopes};
|
||||
use mammut::{Data, Mastodon, MediaBuilder, Registration, StatusBuilder};
|
||||
use structopt::StructOpt;
|
||||
use failure::Fallible;
|
||||
|
||||
use ferretro::retro;
|
||||
use ferretro::retro::ffi::{PixelFormat, GameGeometry, SystemAvInfo, SystemInfo};
|
||||
use ferretro::retro::wrapper::{LibretroWrapper, Handler};
|
||||
|
||||
use ferretro::retro::wrapped_types::{InputDeviceId, Variable2};
|
||||
|
||||
use ffmpeg::{ChannelLayout, Packet, codec, filter, format, frame, media};
|
||||
use ffmpeg::util::rational::Rational;
|
||||
use std::convert::TryInto;
|
||||
|
||||
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,
|
||||
video_frame: u64,
|
||||
discard_video_frames: bool,
|
||||
stay_crouched: bool,
|
||||
}
|
||||
|
||||
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: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<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 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,
|
||||
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,
|
||||
video_frame: 0,
|
||||
discard_video_frames: true, // start out discarding
|
||||
stay_crouched: false,
|
||||
};
|
||||
|
||||
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;
|
||||
if !self.discard_video_frames {
|
||||
self.video_frame += 1;
|
||||
}
|
||||
self.retro.run();
|
||||
|
||||
match self.video_frames.pop_front() {
|
||||
Some(mut vframe) => {
|
||||
if !self.discard_video_frames {
|
||||
vframe.set_pts(Some(self.video_frame.try_into().unwrap()));
|
||||
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(self.video_frame.try_into().unwrap()));
|
||||
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);
|
||||
|
||||
if !self.discard_video_frames {
|
||||
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<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.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();
|
||||
}
|
||||
}
|
||||
|
||||
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());
|
||||
//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;
|
||||
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 get_variable(&mut self, key: &str) -> Option<String> {
|
||||
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<Variable2>) -> bool {
|
||||
for v in variables {
|
||||
eprintln!("{:?}", v);
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn log_print(&mut self, level: retro::ffi::LogLevel, msg: &str) {
|
||||
eprint!("🕹️ [{:?}] {}", level, msg);
|
||||
}
|
||||
|
||||
fn input_state(&mut self, port: u32, device: InputDeviceId, index: InputIndex) -> i16 {
|
||||
match self.frame {
|
||||
300..=320 => { // push start to get to title screen
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Start => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
500..=550 => { // push start to get to menu
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Start => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
650..=660 => { // d-pad down to pick VS mode
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Down => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
750..=780 => { // a button to pick vs mode
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::B => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
850..=880 => { // a button for vs start
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::B => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
}, // wait about 200 frames for character select to show
|
||||
1130..=1140 => { // move all control sticks into character select
|
||||
match port {
|
||||
0 | 1 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => 0x7FFF,
|
||||
retro::constants::AnalogAxis::Y => -0x7FFF,
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
1150..=1170 => { // a button for p1 and p2 to select characters
|
||||
match port {
|
||||
0 | 1 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::B => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
1190..=1200 => { // start to go to stage select
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Start => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
}, // wait ~200 frames for stage select
|
||||
1400..=1430 => { // right to select sector z
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Right => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
1450..=1460 => { // down to select sector z
|
||||
// poke memory to make us be DK
|
||||
let mut ram = self.retro.get_memory(2);
|
||||
ram[0xa4d28] = 0x02;
|
||||
// and make the computer be a random character
|
||||
// everytthing after 0b is special characters.
|
||||
// 0c: master hand
|
||||
// 0d: metal mario
|
||||
// 0e-19: polygon team
|
||||
// 1a is giant dk
|
||||
ram[0xa4d9c] = rand::random::<u8>() % 0x1b;
|
||||
if ram[0xa4d9c] > 0x0b { // if it picked a special character, reroll - i want special characters to be a bit less likely than regular ones
|
||||
ram[0xa4d9c] = rand::random::<u8>() % 0x1b;
|
||||
}
|
||||
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Down => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
1480..=1500 => { // confirm stage
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::B => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
1540..=1550 => { // start record
|
||||
self.discard_video_frames = false;
|
||||
0
|
||||
},
|
||||
2000..=2100 => { // run in opposite directions
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => -0x7FFF,
|
||||
retro::constants::AnalogAxis::Y => 0x0000,
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
1 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => 0x7FFF,
|
||||
retro::constants::AnalogAxis::Y => 0x0000,
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
2130..=2135 => { // face each other
|
||||
// poke memory to give DK's punch random power
|
||||
let mut ram = self.retro.get_memory(2);
|
||||
ram[0x26bf84] = rand::random::<u8>() / 3;
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => 0x3000,
|
||||
retro::constants::AnalogAxis::Y => 0x0000,
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
1 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => -0x3000,
|
||||
retro::constants::AnalogAxis::Y => 0x0000,
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
2160..=2170 | 2180..=2190 => { // do the punch. tap b twice so we fire the punch immediately instead of charging
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::Y => 1,
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
},
|
||||
2400..=2460 => { // taunt or crouch depending on whether it hit
|
||||
// read opponent %, if it is greater than 0 we hit
|
||||
let ram = self.retro.get_memory(2);
|
||||
let taunt = ram[0x26c024] > 0;
|
||||
|
||||
if taunt {
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::L => 1, // taunt
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
}
|
||||
else {
|
||||
self.stay_crouched = true;
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => 0x0000,
|
||||
retro::constants::AnalogAxis::Y => 0x6000, // crouch
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
1 => match device {
|
||||
InputDeviceId::Joypad(button) => match button {
|
||||
JoypadButton::L => 1, // Taunt
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
if self.stay_crouched {
|
||||
match port {
|
||||
0 => match device {
|
||||
InputDeviceId::Analog(axis) => match axis {
|
||||
retro::constants::AnalogAxis::X => 0x0000,
|
||||
retro::constants::AnalogAxis::Y => 0x6000, // crouch
|
||||
},
|
||||
_ => 0
|
||||
},
|
||||
_ => 0
|
||||
}
|
||||
}
|
||||
else {
|
||||
0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[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();
|
||||
|
||||
let mastodon = match File::open("mastodon-data.toml") {
|
||||
Ok(mut file) => {
|
||||
let mut config = String::new();
|
||||
file.read_to_string(&mut config).unwrap();
|
||||
let data: Data = toml::from_str(&config).unwrap();
|
||||
Mastodon::from_data(data)
|
||||
},
|
||||
Err(_) => masto_register(),
|
||||
};
|
||||
|
||||
let you = mastodon.verify_credentials().unwrap();
|
||||
|
||||
println!("{:#?}", you);
|
||||
|
||||
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..2700 {
|
||||
eprintln!("🖼️ frame: {}", frame);
|
||||
emu.run(frame);
|
||||
|
||||
}
|
||||
let mut packet = Packet::empty();
|
||||
eprintln!("flushed: {:?}", emu.video_encoder.flush(&mut packet).unwrap());
|
||||
|
||||
let character_name = {
|
||||
let mut ram = emu.retro.get_memory(2);
|
||||
// and make the computer be a random character
|
||||
// everytthing after 0b is special characters.
|
||||
// 0c: master hand
|
||||
// 0d: metal mario
|
||||
// 0e-19: polygon team
|
||||
// 1a is giant dk
|
||||
match ram[0xa4d9c] {
|
||||
0x00 => "Mario",
|
||||
0x01 => "Fox",
|
||||
0x02 => "DK",
|
||||
0x03 => "Samus",
|
||||
0x04 => "Luigi",
|
||||
0x05 => "Link",
|
||||
0x06 => "Yoshi",
|
||||
0x07 => "Captain Falcon",
|
||||
0x08 => "Kirby",
|
||||
0x09 => "Pikachu",
|
||||
0x0A => "Jigglypuff",
|
||||
0x0B => "Ness",
|
||||
0x0C => "Master Hand",
|
||||
0x0D => "Metal Mario",
|
||||
0x0E => "Mario?",
|
||||
0x0F => "Fox?",
|
||||
0x10 => "DK?",
|
||||
0x11 => "Samus?",
|
||||
0x12 => "Luigi?",
|
||||
0x13 => "Link?",
|
||||
0x14 => "Yoshi?",
|
||||
0x15 => "Captain Falcon?",
|
||||
0x16 => "Kirby?",
|
||||
0x17 => "Pikachu?",
|
||||
0x18 => "Jigglypuff?",
|
||||
0x19 => "Ness?",
|
||||
0x1a => "DK (big)",
|
||||
_ => "???"
|
||||
}
|
||||
};
|
||||
emu.end();
|
||||
//octx.write_trailer().unwrap();
|
||||
|
||||
|
||||
println!("{:#?}", you);
|
||||
|
||||
let mut media = MediaBuilder::new(Cow::Owned(String::from(opt.video.clone().as_os_str().to_str().unwrap())));
|
||||
media.description = Some(Cow::Owned(String::from(format!("A video of Super Smash Bros 64 where DK attempts to punch {} from across the stage.", character_name))));
|
||||
|
||||
println!("media to upload: {:?}", media);
|
||||
|
||||
let attachment = mastodon.media(media).unwrap(); // upload the video
|
||||
|
||||
let mut status = StatusBuilder::new(format!("DK vs. {}", character_name));
|
||||
status.media_ids = Some(vec![attachment.id]);
|
||||
|
||||
mastodon.new_status(status).unwrap();
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
enum EncoderToWriteFrom {
|
||||
Video,
|
||||
Audio,
|
||||
}
|
||||
|
||||
fn masto_register() -> Mastodon {
|
||||
let app = AppBuilder {
|
||||
client_name: "dk-punch",
|
||||
redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
|
||||
scopes: Scopes::ReadWrite,
|
||||
website: Some("https://github.com/vivlim/dkpunch"),
|
||||
};
|
||||
|
||||
let mut registration = Registration::new("https://botsin.space");
|
||||
registration.register(app).unwrap();
|
||||
let url = registration.authorise().unwrap();
|
||||
|
||||
println!("Click this link to authorize on Mastodon: {}", url);
|
||||
println!("Paste the returned authorization code: ");
|
||||
|
||||
let mut input = String::new();
|
||||
io::stdin().read_line(&mut input).unwrap();
|
||||
|
||||
let code = input.trim();
|
||||
let mastodon = registration.create_access_token(code.to_string()).unwrap();
|
||||
|
||||
// Save app data for using on the next run.
|
||||
let toml = toml::to_string(&*mastodon).unwrap();
|
||||
let mut file = File::create("mastodon-data.toml").unwrap();
|
||||
file.write_all(toml.as_bytes()).unwrap();
|
||||
|
||||
mastodon
|
||||
}
|
||||
Loading…
Reference in New Issue