Commit | Line | Data |
---|---|---|
b043bd0a KS |
1 | extern crate libc; |
2 | extern crate sdl2_sys; | |
3 | extern crate nihav_core; | |
4 | extern crate nihav_registry; | |
5 | extern crate nihav_allstuff; | |
6 | ||
7 | use std::fs::File; | |
8 | use std::io::prelude::*; | |
9 | use std::io::{BufReader, SeekFrom}; | |
10 | use std::sync::mpsc; | |
11 | use std::time::Duration; | |
12 | use std::thread; | |
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::*; | |
21 | ||
22 | mod command; | |
23 | use command::*; | |
24 | ||
25 | struct Player { | |
26 | ended: bool, | |
27 | dmx_reg: RegisteredDemuxers, | |
28 | dec_reg: RegisteredDecoders, | |
29 | paused: bool, | |
30 | mute: bool, | |
31 | volume: u8, | |
32 | debug: bool, | |
33 | buf: Vec<i16>, | |
34 | } | |
35 | ||
36 | struct AudioDevice { | |
37 | device_id: sdl2_sys::SDL_AudioDeviceID | |
38 | } | |
39 | ||
40 | impl AudioDevice { | |
41 | fn open(arate: u32, channels: u8) -> Option<(Self, SDL_AudioSpec)> { | |
42 | let desired_spec = SDL_AudioSpec { | |
43 | freq: arate as i32, | |
44 | format: sdl2_sys::AUDIO_S16 as u16, | |
45 | channels, | |
46 | silence: 0, | |
47 | samples: 0, | |
48 | padding: 0, | |
49 | size: 0, | |
50 | callback: None, | |
51 | userdata: std::ptr::null_mut(), | |
52 | }; | |
53 | let mut dspec = desired_spec; | |
54 | let device_id = unsafe { sdl2_sys::SDL_OpenAudioDevice(std::ptr::null(), 0, &desired_spec, &mut dspec, 0) }; | |
55 | if device_id != 0 { | |
56 | Some((AudioDevice { device_id }, dspec)) | |
57 | } else { | |
58 | None | |
59 | } | |
60 | } | |
61 | fn pause(&self) { | |
62 | unsafe { sdl2_sys::SDL_PauseAudioDevice(self.device_id, 1); } | |
63 | } | |
64 | fn resume(&self) { | |
65 | unsafe { sdl2_sys::SDL_PauseAudioDevice(self.device_id, 0); } | |
66 | } | |
67 | fn clear(&self) { | |
68 | unsafe { sdl2_sys::SDL_ClearQueuedAudio(self.device_id); } | |
69 | } | |
70 | fn queue(&self, buf: &[i16]) { | |
71 | unsafe { | |
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); | |
75 | } | |
76 | } | |
77 | fn queue_bytes(&self, buf: &[u8]) { | |
78 | unsafe { | |
79 | let len = buf.len(); | |
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); | |
82 | } | |
83 | } | |
84 | fn size(&self) -> u32 { | |
85 | unsafe { sdl2_sys::SDL_GetQueuedAudioSize(self.device_id) } | |
86 | } | |
87 | } | |
88 | ||
89 | struct Decoder<'a> { | |
90 | demuxer: Demuxer<'a>, | |
91 | decoder: Box<dyn NADecoder>, | |
92 | dsupp: Box<NADecoderSupport>, | |
93 | buf: &'a mut Vec<i16>, | |
94 | stream_no: usize, | |
95 | dst_info: NAAudioInfo, | |
96 | dst_chmap: NAChannelMap, | |
97 | samplepos: u64, | |
98 | arate: u32, | |
99 | volume: u8, | |
100 | mute: bool, | |
101 | } | |
102 | ||
103 | fn output_vol_i16(device: &AudioDevice, tmp: &mut Vec<i16>, src: &[i16], mute: bool, volume: u8) { | |
104 | if !mute { | |
105 | tmp.truncate(0); | |
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); | |
111 | } | |
112 | } else { | |
113 | tmp.truncate(0); | |
114 | tmp.resize(src.len(), 0); | |
115 | } | |
116 | device.queue(&tmp); | |
117 | } | |
118 | ||
119 | fn output_vol_u8(device: &AudioDevice, tmp: &mut Vec<i16>, src: &[u8], mute: bool, volume: u8) { | |
120 | if !mute { | |
121 | tmp.truncate(0); | |
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); | |
128 | } | |
129 | } else { | |
130 | tmp.truncate(0); | |
131 | tmp.resize(src.len() / 2, 0); | |
132 | } | |
133 | device.queue(&tmp); | |
134 | } | |
135 | ||
136 | impl<'a> Decoder<'a> { | |
137 | fn refill(&mut self, device: &AudioDevice) -> bool { | |
138 | loop { | |
139 | match self.demuxer.get_frame() { | |
140 | Ok(pkt) => { | |
141 | if pkt.get_stream().get_num() == self.stream_no { | |
142 | match self.decoder.decode(&mut self.dsupp, &pkt) { | |
143 | Ok(frm) => { | |
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); | |
147 | } | |
148 | let out_buf = convert_audio_frame(&buf, &self.dst_info, &self.dst_chmap).unwrap(); | |
149 | match out_buf { | |
150 | NABufferType::AudioI16(abuf) => { | |
151 | if !self.mute && self.volume == 100 { | |
152 | device.queue(&abuf.get_data()); | |
153 | } else { | |
154 | output_vol_i16(device, self.buf, &abuf.get_data(), self.mute, self.volume); | |
155 | } | |
156 | self.samplepos += abuf.get_length() as u64; | |
157 | }, | |
158 | NABufferType::AudioPacked(abuf) => { | |
159 | if !self.mute && self.volume == 100 { | |
160 | device.queue_bytes(&abuf.get_data()); | |
161 | } else { | |
162 | output_vol_u8(device, self.buf, &abuf.get_data(), self.mute, self.volume); | |
163 | } | |
164 | self.samplepos += abuf.get_length() as u64; | |
165 | }, | |
166 | _ => println!("unknown buffer type"), | |
167 | }; | |
168 | return false; | |
169 | }, | |
170 | Err(err) => { | |
171 | println!(" error decoding {:?}", err); | |
172 | return true; | |
173 | }, | |
174 | }; | |
175 | } | |
176 | }, | |
177 | Err(DemuxerError::EOF) => return true, | |
178 | Err(err) => { | |
179 | println!("demuxing error {:?}", err); | |
180 | return true; | |
181 | }, | |
182 | }; | |
183 | } | |
184 | } | |
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"); } | |
188 | ret.is_ok() | |
189 | } | |
190 | } | |
191 | ||
192 | fn format_time(ms: u64) -> String { | |
193 | let s = ms / 1000; | |
194 | let ds = (ms % 1000) / 100; | |
195 | let (min, s) = (s / 60, s % 60); | |
196 | if min == 0 { | |
197 | format!("{}.{}", s, ds) | |
198 | } else { | |
199 | format!("{}:{:02}.{}", min, s, ds) | |
200 | } | |
201 | } | |
202 | ||
203 | impl Player { | |
204 | fn new() -> Self { | |
205 | let mut dmx_reg = RegisteredDemuxers::new(); | |
206 | nihav_register_all_demuxers(&mut dmx_reg); | |
207 | let mut dec_reg = RegisteredDecoders::new(); | |
208 | nihav_register_all_decoders(&mut dec_reg); | |
209 | ||
210 | unsafe { | |
211 | if sdl2_sys::SDL_Init(sdl2_sys::SDL_INIT_AUDIO) != 0 { | |
212 | panic!("cannot init SDL"); | |
213 | } | |
214 | } | |
215 | ||
216 | Self { | |
217 | ended: false, | |
218 | paused: false, | |
219 | dmx_reg, dec_reg, | |
220 | volume: 100, | |
221 | mute: false, | |
222 | debug: false, | |
223 | buf: Vec::new(), | |
224 | } | |
225 | } | |
226 | fn play_file(&mut self, name: &str, cmd_receiver: &mpsc::Receiver<Command>) { | |
227 | let ret = File::open(name); | |
228 | if ret.is_err() { | |
229 | println!("error opening {}", name); | |
230 | return; | |
231 | } | |
232 | let mut file = ret.unwrap(); | |
233 | ||
234 | let mut fr = FileReader::new_read(&mut file); | |
235 | let mut br = ByteReader::new(&mut fr); | |
236 | let res = detect::detect_format(name, &mut br); | |
237 | if res.is_none() { | |
238 | println!("cannot detect format for {}", name); | |
239 | return; | |
240 | } | |
241 | let (dmx_name, _) = res.unwrap(); | |
242 | drop(br); | |
243 | drop(fr); | |
244 | let dmx_fact = self.dmx_reg.find_demuxer(dmx_name); | |
245 | if dmx_fact.is_none() { | |
246 | println!("no demuxer for format {}", dmx_name); | |
247 | return; | |
248 | } | |
249 | let dmx_fact = dmx_fact.unwrap(); | |
250 | ||
251 | file.seek(SeekFrom::Start(0)).unwrap(); | |
252 | let mut file = BufReader::new(file); | |
253 | let mut fr = FileReader::new_read(&mut file); | |
254 | let mut br = ByteReader::new(&mut fr); | |
255 | let res = create_demuxer(dmx_fact, &mut br); | |
256 | if res.is_err() { | |
257 | println!("cannot create demuxer"); | |
258 | return; | |
259 | } | |
260 | let dmx = res.unwrap(); | |
261 | ||
262 | let mut ainfo = None; | |
263 | let mut dec: Option<(Box<NADecoderSupport>, Box<dyn NADecoder>)> = None; | |
264 | let mut stream_no = 0; | |
265 | let mut duration = dmx.get_duration(); | |
266 | for i in 0..dmx.get_num_streams() { | |
267 | let s = dmx.get_stream(i).unwrap(); | |
268 | let info = s.get_info(); | |
269 | if info.is_audio() { | |
270 | let decfunc = self.dec_reg.find_decoder(info.get_name()); | |
271 | if decfunc.is_none() { | |
272 | println!("no decoder for {}", info.get_name()); | |
273 | continue; | |
274 | } | |
275 | let mut decoder = (decfunc.unwrap())(); | |
276 | let mut dsupp = Box::new(NADecoderSupport::new()); | |
277 | if decoder.init(&mut dsupp, info.clone()).is_err() { | |
278 | println!("cannot init decoder for stream {}", i); | |
279 | continue; | |
280 | } | |
281 | dec = Some((dsupp, decoder)); | |
282 | ainfo = Some(info); | |
283 | stream_no = i; | |
284 | if s.duration > 0 { | |
285 | duration = NATimeInfo::ts_to_time(s.duration, 1000, s.tb_num, s.tb_den); | |
286 | } | |
287 | break; | |
288 | } | |
289 | } | |
290 | if dec.is_none() { | |
291 | println!("no audio decoder found"); | |
292 | return; | |
293 | } | |
294 | let (dsupp, decoder) = dec.unwrap(); | |
295 | ||
296 | let ainfo = ainfo.unwrap().get_properties().get_audio_info().unwrap(); | |
297 | let arate = if ainfo.sample_rate > 0 { ainfo.sample_rate } else { 44100 }; | |
298 | let ch = ainfo.channels; | |
299 | ||
300 | println!("Playing {} [{}Hz {}ch]", name, arate, ch); | |
301 | let ret = AudioDevice::open(arate, ch.max(2)); | |
302 | if ret.is_none() { | |
303 | println!("cannot open output"); | |
304 | return; | |
305 | } | |
306 | let (device, dspec) = ret.unwrap(); | |
307 | let block_limit = dmx.get_stream(stream_no).unwrap().tb_num * arate / dmx.get_stream(stream_no).unwrap().tb_den * u32::from(dspec.channels); | |
308 | ||
309 | let dst_info = NAAudioInfo { sample_rate: dspec.freq as u32, channels: dspec.channels, format: SND_S16_FORMAT, block_len: 1 }; | |
310 | let dst_chmap = if dst_info.channels == 2 { | |
311 | NAChannelMap::from_str("L,R").unwrap() | |
312 | } else { | |
313 | NAChannelMap::from_str("C").unwrap() | |
314 | }; | |
315 | let mut decoder = Decoder { | |
316 | demuxer: dmx, | |
317 | decoder, dsupp, | |
318 | stream_no, | |
319 | dst_info, dst_chmap, | |
320 | samplepos: 0, | |
321 | arate, | |
322 | volume: self.volume, | |
323 | mute: self.mute, | |
324 | buf: &mut self.buf, | |
325 | }; | |
326 | let mut refill_limit = arate * u32::from(dspec.channels); | |
327 | let underfill_limit = (arate * u32::from(dspec.channels) / 4).max(block_limit); | |
328 | ||
329 | let mut eof = decoder.refill(&device); | |
330 | while !eof && device.size() < refill_limit { | |
331 | eof = decoder.refill(&device); | |
332 | } | |
333 | ||
334 | let duration_str = if duration != 0 { format_time(duration) } else { "???".to_owned() }; | |
335 | if !self.paused { | |
336 | device.resume(); | |
337 | } | |
0a727e05 | 338 | let mut no_display = false; |
b043bd0a KS |
339 | 'main: loop { |
340 | let cur_time = decoder.samplepos.saturating_sub(u64::from(device.size() / 2 / u32::from(dst_info.channels))); | |
341 | let full_ms = cur_time * 1000 / u64::from(arate); | |
342 | let timestr = format_time(full_ms); | |
343 | let disp_vol = if self.mute { 0 } else { self.volume }; | |
0a727e05 KS |
344 | if !no_display { |
345 | if !self.debug { | |
346 | print!("> {} / {} {}% \r", timestr, duration_str, disp_vol); | |
347 | } else { | |
348 | print!("> {} / {} |{}| {}% \r", timestr, duration_str, device.size(), disp_vol); | |
349 | } | |
b043bd0a KS |
350 | } |
351 | std::io::stdout().flush().unwrap(); | |
352 | if device.size() < underfill_limit && !self.paused && refill_limit < (1 << 20) { | |
353 | if full_ms > 5000 { | |
354 | println!("underrun!"); | |
355 | } | |
356 | refill_limit += refill_limit >> 1; | |
357 | } | |
358 | if device.size() < refill_limit / 2 { | |
359 | while !eof && device.size() < refill_limit { | |
360 | eof = decoder.refill(&device); | |
361 | } | |
362 | } | |
363 | if eof && device.size() == 0 { | |
364 | break 'main; | |
365 | } | |
366 | while let Ok(cmd) = cmd_receiver.try_recv() { | |
367 | let cur_time = decoder.samplepos.saturating_sub(u64::from(device.size() / 2 / u32::from(dst_info.channels))); | |
368 | match cmd { | |
369 | Command::Forward(val) => { | |
370 | device.pause(); | |
371 | device.clear(); | |
372 | let seekoff = match val { | |
373 | 1 => 10, | |
374 | 2 => 60, | |
375 | _ => 10 * 60, | |
376 | }; | |
377 | let seek_time = cur_time * 1000 / u64::from(arate) + seekoff * 1000; | |
378 | let _ret = decoder.seek(seek_time); | |
379 | while !eof && device.size() < refill_limit { | |
380 | eof = decoder.refill(&device); | |
381 | } | |
382 | if eof { | |
383 | break 'main; | |
384 | } | |
385 | if !self.paused { | |
386 | device.resume(); | |
387 | } | |
388 | }, | |
389 | Command::Back(val) => { | |
390 | device.pause(); | |
391 | device.clear(); | |
392 | let seekoff = match val { | |
393 | 1 => 10, | |
394 | 2 => 60, | |
395 | _ => 10 * 60, | |
396 | }; | |
397 | let seek_time = (cur_time * 1000 / u64::from(arate)).saturating_sub(seekoff * 1000); | |
398 | let _ret = decoder.seek(seek_time); | |
399 | while !eof && device.size() < refill_limit { | |
400 | eof = decoder.refill(&device); | |
401 | } | |
402 | if eof { | |
403 | break 'main; | |
404 | } | |
405 | if !self.paused { | |
406 | device.resume(); | |
407 | } | |
408 | }, | |
0a727e05 KS |
409 | Command::Seek(seek_time) => { |
410 | device.pause(); | |
411 | device.clear(); | |
412 | let _ret = decoder.seek(seek_time); | |
413 | while !eof && device.size() < refill_limit { | |
414 | eof = decoder.refill(&device); | |
415 | } | |
416 | if eof { | |
417 | break 'main; | |
418 | } | |
419 | if !self.paused { | |
420 | device.resume(); | |
421 | } | |
422 | }, | |
b043bd0a KS |
423 | Command::Quit => { |
424 | device.pause(); | |
425 | self.ended = true; | |
426 | break 'main; | |
427 | }, | |
428 | Command::Next => { | |
429 | device.pause(); | |
430 | break 'main; | |
431 | }, | |
432 | Command::Repeat => { | |
433 | device.pause(); | |
434 | device.clear(); | |
435 | let _ret = decoder.seek(0); | |
436 | while !eof && device.size() < refill_limit { | |
437 | eof = decoder.refill(&device); | |
438 | } | |
439 | if eof { | |
440 | break 'main; | |
441 | } | |
442 | if !self.paused { | |
443 | device.resume(); | |
444 | } | |
445 | }, | |
446 | Command::Pause => { | |
447 | self.paused = !self.paused; | |
448 | if self.paused { | |
449 | device.pause(); | |
450 | } else { | |
451 | device.resume(); | |
452 | } | |
453 | }, | |
454 | Command::VolumeUp => { | |
455 | self.volume = (self.volume + 10).min(200); | |
456 | decoder.volume = self.volume; | |
457 | }, | |
458 | Command::VolumeDown => { | |
459 | self.volume = self.volume.saturating_sub(10); | |
460 | decoder.volume = self.volume; | |
461 | }, | |
462 | Command::Mute => { | |
463 | self.mute = !self.mute; | |
464 | decoder.mute = self.mute; | |
465 | }, | |
466 | Command::Debug => { | |
467 | self.debug = !self.debug; | |
468 | }, | |
0a727e05 KS |
469 | Command::PauseDisplay => { no_display = true; }, |
470 | Command::ResumeDisplay => { no_display = false; }, | |
b043bd0a | 471 | }; |
0a727e05 KS |
472 | if !no_display { |
473 | print!("\r{:60}\r", ' '); | |
474 | } | |
b043bd0a KS |
475 | } |
476 | thread::sleep(Duration::from_millis(200)); | |
477 | } | |
478 | ||
479 | println!(); | |
480 | } | |
481 | } | |
482 | ||
483 | fn main() { | |
484 | let args: Vec<String> = std::env::args().collect(); | |
485 | ||
486 | let cmd_state = CmdLineState::new(); | |
487 | ||
488 | let (cmd_reader_thread, cmd_receiver) = start_reader(); | |
489 | let mut player = Player::new(); | |
490 | ||
491 | if args.len() == 1 { | |
492 | println!("usage: nihav-sndplay file1 file2 ..."); | |
493 | return; | |
494 | } | |
495 | ||
496 | if args[1] == "--help" { | |
497 | println!("usage: nihav-sndplay file1 file2 ..."); | |
498 | println!("commands:"); | |
499 | println!(" escape / q - quit"); | |
500 | println!(" space - pause / resume playback"); | |
501 | println!(" enter / end - play next file"); | |
502 | println!(" home - play current track from the beginning"); | |
503 | println!(" left / right - seek 10 seconds forward / back"); | |
504 | println!(" up / down - seek 1 minute forward / back"); | |
505 | println!(" pgup / pgdn - seek 10 minutes forward / back"); | |
506 | println!(" + / - - increase / decrease volume"); | |
507 | println!(" m - mute output"); | |
508 | return; | |
509 | } | |
510 | ||
511 | for arg in args[1..].iter() { | |
512 | player.play_file(arg, &cmd_receiver); | |
513 | if player.ended { | |
514 | break; | |
515 | } | |
516 | } | |
517 | cmd_state.restore(); | |
518 | ||
519 | drop(cmd_reader_thread); | |
520 | unsafe { sdl2_sys::SDL_Quit(); } | |
521 | } |