3 extern crate nihav_core;
4 extern crate nihav_registry;
5 extern crate nihav_allstuff;
8 use std::io::prelude::*;
9 use std::io::{BufReader, SeekFrom};
11 use std::time::Duration;
13 use sdl2_sys::{SDL_AudioSpec, Uint32};
14 use nihav_core::io::byteio::{FileReader, ByteReader};
15 use nihav_core::frame::*;
16 use nihav_core::codecs::*;
17 use nihav_core::demuxers::*;
18 use nihav_core::soundcvt::*;
19 use nihav_registry::detect;
20 use nihav_allstuff::*;
27 dmx_reg: RegisteredDemuxers,
28 dec_reg: RegisteredDecoders,
37 device_id: sdl2_sys::SDL_AudioDeviceID
41 fn open(arate: u32, channels: u8) -> Option<(Self, SDL_AudioSpec)> {
42 let desired_spec = SDL_AudioSpec {
44 format: sdl2_sys::AUDIO_S16 as u16,
51 userdata: std::ptr::null_mut(),
53 let mut dspec = desired_spec;
54 let device_id = unsafe { sdl2_sys::SDL_OpenAudioDevice(std::ptr::null(), 0, &desired_spec, &mut dspec, 0) };
56 Some((AudioDevice { device_id }, dspec))
62 unsafe { sdl2_sys::SDL_PauseAudioDevice(self.device_id, 1); }
65 unsafe { sdl2_sys::SDL_PauseAudioDevice(self.device_id, 0); }
68 unsafe { sdl2_sys::SDL_ClearQueuedAudio(self.device_id); }
70 fn queue(&self, buf: &[i16]) {
72 let len = buf.len() * 2;
73 let buf_ptr = buf.as_ptr();
74 sdl2_sys::SDL_QueueAudio(self.device_id, buf_ptr as *const core::ffi::c_void, len as Uint32);
77 fn queue_bytes(&self, buf: &[u8]) {
80 let buf_ptr = buf.as_ptr();
81 sdl2_sys::SDL_QueueAudio(self.device_id, buf_ptr as *const core::ffi::c_void, len as Uint32);
84 fn size(&self) -> u32 {
85 unsafe { sdl2_sys::SDL_GetQueuedAudioSize(self.device_id) }
91 decoder: Box<dyn NADecoder>,
92 dsupp: Box<NADecoderSupport>,
93 buf: &'a mut Vec<i16>,
95 dst_info: NAAudioInfo,
96 dst_chmap: NAChannelMap,
103 fn output_vol_i16(device: &AudioDevice, tmp: &mut Vec<i16>, src: &[i16], mute: bool, volume: u8) {
106 tmp.reserve(src.len());
107 let vol = i32::from(volume);
108 for &sample in src.iter() {
109 let nsamp = vol * i32::from(sample) / 100;
110 tmp.push(nsamp.min(32767).max(-32768) as i16);
114 tmp.resize(src.len(), 0);
119 fn output_vol_u8(device: &AudioDevice, tmp: &mut Vec<i16>, src: &[u8], mute: bool, volume: u8) {
122 tmp.reserve(src.len());
123 let vol = i32::from(volume);
124 for sample in src.chunks_exact(2) {
125 let sample = (u16::from(sample[0]) + u16::from(sample[1]) * 256) as i16;
126 let nsamp = vol * i32::from(sample) / 100;
127 tmp.push(nsamp.min(32767).max(-32768) as i16);
131 tmp.resize(src.len() / 2, 0);
136 impl<'a> Decoder<'a> {
137 fn refill(&mut self, device: &AudioDevice) -> bool {
139 match self.demuxer.get_frame() {
141 if pkt.get_stream().get_num() == self.stream_no {
142 match self.decoder.decode(&mut self.dsupp, &pkt) {
144 let buf = frm.get_buffer();
145 if let Some(pts) = frm.ts.get_pts() {
146 self.samplepos = NATimeInfo::ts_to_time(pts, u64::from(self.arate), frm.ts.tb_num, frm.ts.tb_den);
148 let out_buf = convert_audio_frame(&buf, &self.dst_info, &self.dst_chmap).unwrap();
150 NABufferType::AudioI16(abuf) => {
151 if !self.mute && self.volume == 100 {
152 device.queue(&abuf.get_data());
154 output_vol_i16(device, self.buf, &abuf.get_data(), self.mute, self.volume);
156 self.samplepos += abuf.get_length() as u64;
158 NABufferType::AudioPacked(abuf) => {
159 if !self.mute && self.volume == 100 {
160 device.queue_bytes(&abuf.get_data());
162 output_vol_u8(device, self.buf, &abuf.get_data(), self.mute, self.volume);
164 self.samplepos += abuf.get_length() as u64;
166 _ => println!("unknown buffer type"),
171 println!(" error decoding {:?}", err);
177 Err(DemuxerError::EOF) => return true,
179 println!("demuxing error {:?}", err);
185 fn seek(&mut self, time: u64) -> bool {
186 let ret = self.demuxer.seek(NATimePoint::Milliseconds(time));
187 if ret.is_err() { println!(" seek error\n"); }
192 fn format_time(ms: u64) -> String {
194 let ds = (ms % 1000) / 100;
195 let (min, s) = (s / 60, s % 60);
196 let (h, min) = (min / 60, min % 60);
199 format!("{}.{}", s, ds)
201 format!("{}:{:02}.{}", min, s, ds)
204 format!("{}:{:02}:{:02}.{}", h, min, s, ds)
210 let mut dmx_reg = RegisteredDemuxers::new();
211 nihav_register_all_demuxers(&mut dmx_reg);
212 let mut dec_reg = RegisteredDecoders::new();
213 nihav_register_all_decoders(&mut dec_reg);
216 if sdl2_sys::SDL_Init(sdl2_sys::SDL_INIT_AUDIO) != 0 {
217 panic!("cannot init SDL");
231 fn play_file(&mut self, name: &str, cmd_receiver: &mpsc::Receiver<Command>) {
232 let ret = File::open(name);
234 println!("error opening {}", name);
237 let mut file = ret.unwrap();
239 let mut fr = FileReader::new_read(&mut file);
240 let mut br = ByteReader::new(&mut fr);
241 let res = detect::detect_format(name, &mut br);
243 println!("cannot detect format for {}", name);
246 let (dmx_name, _) = res.unwrap();
249 let dmx_fact = self.dmx_reg.find_demuxer(dmx_name);
250 if dmx_fact.is_none() {
251 println!("no demuxer for format {}", dmx_name);
254 let dmx_fact = dmx_fact.unwrap();
256 file.seek(SeekFrom::Start(0)).unwrap();
257 let mut file = BufReader::new(file);
258 let mut fr = FileReader::new_read(&mut file);
259 let mut br = ByteReader::new(&mut fr);
260 let res = create_demuxer(dmx_fact, &mut br);
262 println!("cannot create demuxer");
265 let dmx = res.unwrap();
267 let mut ainfo = None;
268 let mut dec: Option<(Box<NADecoderSupport>, Box<dyn NADecoder>)> = None;
269 let mut stream_no = 0;
270 let mut duration = dmx.get_duration();
271 for i in 0..dmx.get_num_streams() {
272 let s = dmx.get_stream(i).unwrap();
273 let info = s.get_info();
275 let decfunc = self.dec_reg.find_decoder(info.get_name());
276 if decfunc.is_none() {
277 println!("no decoder for {}", info.get_name());
280 let mut decoder = (decfunc.unwrap())();
281 let mut dsupp = Box::new(NADecoderSupport::new());
282 if decoder.init(&mut dsupp, info.clone()).is_err() {
283 println!("cannot init decoder for stream {}", i);
286 dec = Some((dsupp, decoder));
290 duration = NATimeInfo::ts_to_time(s.duration, 1000, s.tb_num, s.tb_den);
296 println!("no audio decoder found");
299 let (dsupp, decoder) = dec.unwrap();
301 let ainfo = ainfo.unwrap().get_properties().get_audio_info().unwrap();
302 let arate = if ainfo.sample_rate > 0 { ainfo.sample_rate } else { 44100 };
303 let ch = ainfo.channels;
305 println!("Playing {} [{}Hz {}ch]", name, arate, ch);
306 let ret = AudioDevice::open(arate, ch.max(2));
308 println!("cannot open output");
311 let (device, dspec) = ret.unwrap();
312 let block_limit = dmx.get_stream(stream_no).unwrap().tb_num * arate / dmx.get_stream(stream_no).unwrap().tb_den * u32::from(dspec.channels);
314 let dst_info = NAAudioInfo { sample_rate: dspec.freq as u32, channels: dspec.channels, format: SND_S16_FORMAT, block_len: 1 };
315 let dst_chmap = if dst_info.channels == 2 {
316 NAChannelMap::from_str("L,R").unwrap()
318 NAChannelMap::from_str("C").unwrap()
320 let mut decoder = Decoder {
331 let mut refill_limit = arate * u32::from(dspec.channels);
332 let underfill_limit = (arate * u32::from(dspec.channels) / 4).max(block_limit);
334 let mut eof = decoder.refill(&device);
335 while !eof && device.size() < refill_limit {
336 eof = decoder.refill(&device);
339 let duration_str = if duration != 0 { format_time(duration) } else { "???".to_owned() };
343 let mut no_display = false;
345 let cur_time = decoder.samplepos.saturating_sub(u64::from(device.size() / 2 / u32::from(dst_info.channels)));
346 let full_ms = cur_time * 1000 / u64::from(arate);
347 let timestr = format_time(full_ms);
348 let disp_vol = if self.mute { 0 } else { self.volume };
351 print!("> {} / {} {}% \r", timestr, duration_str, disp_vol);
353 print!("> {} / {} |{}| {}% \r", timestr, duration_str, device.size(), disp_vol);
356 std::io::stdout().flush().unwrap();
357 if device.size() < underfill_limit && !self.paused && refill_limit < (1 << 20) {
359 println!("underrun!");
361 refill_limit += refill_limit >> 1;
363 if device.size() < refill_limit / 2 {
364 while !eof && device.size() < refill_limit {
365 eof = decoder.refill(&device);
368 if eof && device.size() == 0 {
371 while let Ok(cmd) = cmd_receiver.try_recv() {
372 let cur_time = decoder.samplepos.saturating_sub(u64::from(device.size() / 2 / u32::from(dst_info.channels)));
374 Command::Forward(val) => {
377 let seekoff = match val {
382 let seek_time = cur_time * 1000 / u64::from(arate) + seekoff * 1000;
383 let _ret = decoder.seek(seek_time);
384 while !eof && device.size() < refill_limit {
385 eof = decoder.refill(&device);
394 Command::Back(val) => {
397 let seekoff = match val {
402 let seek_time = (cur_time * 1000 / u64::from(arate)).saturating_sub(seekoff * 1000);
403 let _ret = decoder.seek(seek_time);
404 while !eof && device.size() < refill_limit {
405 eof = decoder.refill(&device);
414 Command::Seek(seek_time) => {
417 let _ret = decoder.seek(seek_time);
418 while !eof && device.size() < refill_limit {
419 eof = decoder.refill(&device);
440 let _ret = decoder.seek(0);
441 while !eof && device.size() < refill_limit {
442 eof = decoder.refill(&device);
452 self.paused = !self.paused;
459 Command::VolumeUp => {
460 self.volume = (self.volume + 10).min(200);
461 decoder.volume = self.volume;
463 Command::VolumeDown => {
464 self.volume = self.volume.saturating_sub(10);
465 decoder.volume = self.volume;
468 self.mute = !self.mute;
469 decoder.mute = self.mute;
472 self.debug = !self.debug;
474 Command::PauseDisplay => {
480 Command::ResumeDisplay => {
488 print!("\r{:60}\r", ' ');
491 thread::sleep(Duration::from_millis(200));
499 let args: Vec<String> = std::env::args().collect();
501 let cmd_state = CmdLineState::new();
503 let (cmd_reader_thread, cmd_receiver) = start_reader();
504 let mut player = Player::new();
507 println!("usage: nihav-sndplay file1 file2 ...");
511 if args[1] == "--help" {
512 println!("usage: nihav-sndplay file1 file2 ...");
513 println!("commands:");
514 println!(" escape / q - quit");
515 println!(" space - pause / resume playback");
516 println!(" enter / end - play next file");
517 println!(" home - play current track from the beginning");
518 println!(" left / right - seek 10 seconds forward / back");
519 println!(" up / down - seek 1 minute forward / back");
520 println!(" pgup / pgdn - seek 10 minutes forward / back");
521 println!(" + / - - increase / decrease volume");
522 println!(" m - mute output");
526 for arg in args[1..].iter() {
527 player.play_file(arg, &cmd_receiver);
534 drop(cmd_reader_thread);
535 unsafe { sdl2_sys::SDL_Quit(); }