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