use sdl2::event::{Event, WindowEvent};
use sdl2::keyboard::{Keycode, Mod};
-use sdl2::mouse::MouseButton;
+use sdl2::mouse::{MouseButton, MouseWheelDirection};
use sdl2::render::{Canvas, Texture, TextureCreator};
use sdl2::pixels::PixelFormatEnum;
use sdl2::video::{Window, WindowContext};
use osd::*;
#[repr(u8)]
-#[derive(Clone,Copy,Debug,PartialEq)]
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
enum DecodingState {
+ #[default]
Normal,
Waiting,
Flush,
End,
}
-impl Default for DecodingState {
- fn default() -> Self { DecodingState::Normal }
-}
-
impl From<u8> for DecodingState {
fn from(val: u8) -> Self {
match val {
sdl_context: sdl2::Sdl,
vsystem: sdl2::VideoSubsystem,
asystem: sdl2::AudioSubsystem,
- xpos: Option<i32>,
- ypos: Option<i32>,
acontrol: AudioControl,
vcontrol: VideoControl,
let vsystem = sdl_context.video().expect("video subsystem init failure");
let asystem = sdl_context.audio().expect("audio subsystem init failure");
vsystem.disable_screen_saver();
- let acontrol = AudioControl::new(None, None, &asystem);
+ let acontrol = AudioControl::new(None, None, false, &asystem);
let vcontrol = VideoControl::new(None, 0, 0, 0, 0);
Self {
sdl_context, asystem, vsystem,
- xpos: None,
- ypos: None,
acontrol, vcontrol,
_ => {},
};
}
+ if let Event::MouseWheel {direction: MouseWheelDirection::Normal, x: 0, y, ..} = event {
+ self.seek(10, y > 0, dmx, disp_queue)?;
+ }
if let Event::KeyDown {keycode: Some(keycode), keymod, ..} = event {
match keycode {
Keycode::Escape => {
println!();
return Ok(true);
},
- Keycode::Q if matches!(keymod, Mod::RSHIFTMOD | Mod::LSHIFTMOD) => {
+ Keycode::Q if keymod.contains(Mod::RSHIFTMOD) || keymod.contains(Mod::LSHIFTMOD) => {
self.end = true;
println!();
return Ok(true);
},
- Keycode::Return => return Ok(true),
+ Keycode::Return | Keycode::KpEnter => return Ok(true),
Keycode::Right => { self.seek(10, true, dmx, disp_queue)?; },
Keycode::Left => { self.seek(10, false, dmx, disp_queue)?; },
Keycode::Up => { self.seek(60, true, dmx, disp_queue)?; },
self.vcontrol.try_send_video(PktSendEvent::HurryUp);
},
Keycode::O => {
- self.osd.toggle();
+ if keymod.contains(Mod::RSHIFTMOD) || keymod.contains(Mod::LSHIFTMOD) {
+ self.osd.toggle_perm();
+ } else {
+ self.osd.toggle();
+ }
},
_ => {},
};
}
Ok(false)
}
- fn play(&mut self, name: &str, start_time: NATimePoint) {
+ fn play(&mut self, mut window: Window, name: &str, start_time: NATimePoint) -> Window {
debug_log!(self; {format!("Playing {}", name)});
// prepare data source
handle
} else {
println!("failed to open {}", name);
- return;
+ return window;
};
- let dmx_fact;
let mut fr = FileReader::new_read(&mut file);
let mut br = ByteReader::new(&mut fr);
let res = detect::detect_format(name, &mut br);
if res.is_none() {
println!("cannot detect format for {}", name);
- return;
+ return window;
}
let (dmx_name, _score) = res.unwrap();
debug_log!(self; {format!(" found demuxer {} with score {:?}", dmx_name, _score)});
let ret = dmx_reg.find_demuxer(dmx_name);
if ret.is_none() {
println!("error finding {} demuxer", dmx_name);
- return;
+ return window;
}
- dmx_fact = ret.unwrap();
+ let dmx_fact = ret.unwrap();
br.seek(SeekFrom::Start(0)).expect("should be able to seek to the start");
let ret = create_demuxer(dmx_fact, &mut br);
if ret.is_err() {
println!("error creating demuxer");
- return;
+ return window;
}
let mut dmx = ret.unwrap();
if start_time != NATimePoint::None {
let mut tb_num = 0;
let mut tb_den = 0;
let mut ainfo: Option<NAAudioInfo> = None;
+ let mut sbr_hack = false;
let mut video_dec: Option<DecoderStuff> = None;
let mut audio_dec: Option<DecoderStuff> = None;
dsupp.pool_u32 = NAVideoBufferPool::new(reorder_depth);
if dec.init(&mut dsupp, info).is_err() {
println!("failed to initialise video decoder");
- return;
+ return window;
}
video_dec = Some(DecoderStuff{ dsupp, dec: DecoderType::Video(dec, reord) });
self.video_str = str_id;
let mut dec = (decfunc)();
let mut dsupp = Box::new(NADecoderSupport::new());
ainfo = info.get_properties().get_audio_info();
+ if let (true, Some(ref ai)) = (info.get_name() == "aac", ainfo) {
+ if ai.sample_rate < 32000 {
+ sbr_hack = true;
+ }
+ }
if dec.init(&mut dsupp, info).is_err() {
println!("failed to initialise audio decoder");
- return;
+ return window;
}
audio_dec = Some(DecoderStuff{ dsupp, dec: DecoderType::Audio(dec) });
self.audio_str = str_id;
}
if !self.has_video && !self.has_audio {
println!("No playable streams found.");
- return;
+ return window;
}
while (width <= 384) && (height <= 288) {
let mut new_vcontrol = VideoControl::new(video_dec, width, height, tb_num, tb_den);
std::mem::swap(&mut self.vcontrol, &mut new_vcontrol);
- let mut new_acontrol = AudioControl::new(audio_dec, ainfo, &self.asystem);
+ let mut new_acontrol = AudioControl::new(audio_dec, ainfo, sbr_hack, &self.asystem);
std::mem::swap(&mut self.acontrol, &mut new_acontrol);
if self.mute {
let fname = path.file_name();
let wname = if let Some(fname) = fname {
- "NihAV player - ".to_owned() + fname.to_str().expect("should be able to set window title")
+ // workaround for libSDL2 workaround for non-UTF8 windowing systems
+ // see https://github.com/libsdl-org/SDL/pull/4290 for detais
+ let nname = fname.to_str().expect("should be able to set window title").replace('\u{2013}', "-").replace('\u{2014}', "-");
+ "NihAV player - ".to_owned() + &nname
} else {
"NihAV player".to_owned()
};
- let mut builder = self.vsystem.window(&wname, width as u32, height as u32);
- let window = if let (Some(xpos), Some(ypos)) = (self.xpos, self.ypos) {
- builder.position(xpos, ypos).build().expect("should be able to set window position")
- } else {
- builder.position_centered().build().expect("should be able to centre window")
- };
+ window.set_title(&wname).expect("set window title");
+ if window.size() != (width as u32, height as u32) {
+ window.set_size(width as u32, height as u32).expect("resize window");
+ }
+ window.show();
let mut canvas = window.into_canvas().build().expect("should be able to build canvas");
let texture_creator = canvas.texture_creator();
let mut disp_q = DispQueue::new(&texture_creator, width, height, if self.has_video { FRAME_QUEUE_LEN } else { 0 });
self.has_audio = self.acontrol.has_audio();
if !self.has_video && !self.has_audio {
println!("No playable streams.");
- return;
+ return canvas.into_window();
}
// play
new_vcontrol.finish();
std::mem::swap(&mut self.acontrol, &mut new_acontrol);
new_acontrol.finish();
- return;
+ return canvas.into_window();
}
self.tkeep.reset_all(if !disp_q.is_empty() { disp_q.first_ts } else { 0 });
if !self.paused {
thread::sleep(Duration::from_millis(20));
}
}
- let (xpos, ypos) = canvas.into_window().position();
- self.xpos = Some(xpos);
- self.ypos = Some(ypos);
println!();
std::mem::swap(&mut self.vcontrol, &mut new_vcontrol);
new_vcontrol.finish();
std::mem::swap(&mut self.acontrol, &mut new_acontrol);
new_acontrol.finish();
+ canvas.into_window()
}
}
}
let mut player = Player::new();
+ let mut builder = player.vsystem.window("NihAV Player", 640, 480);
+ let mut window = builder.position_centered().hidden().build().expect("should be able to centre window");
let mut aiter = args.iter().skip(1);
let mut seek_time = NATimePoint::None;
"-ae" => { player.play_audio = true; },
"-vn" => { player.play_video = false; },
"-ve" => { player.play_video = true; },
- "-seek" => {
+ "-seek" | "-start" => {
if let Some(arg) = aiter.next() {
if let Ok(time) = arg.parse::<NATimePoint>() {
seek_time = time;
}
},
_ => {
- player.play(arg, seek_time);
+ window = player.play(window, arg, seek_time);
if player.end { break; }
seek_time = NATimePoint::None;
},
projects / nihav-player.git / blobdiff