1 extern crate nihav_core;
2 extern crate nihav_codec_support;
3 extern crate nihav_registry;
4 extern crate nihav_allstuff;
7 use std::io::{BufReader, Write};
9 use nihav_core::io::byteio::{FileReader, ByteReader};
10 use nihav_core::frame::*;
11 use nihav_core::options::*;
12 use nihav_core::codecs::*;
13 use nihav_core::demuxers::*;
14 use nihav_core::muxers::*;
15 use nihav_core::reorder::*;
16 use nihav_core::scale::*;
17 use nihav_registry::detect;
18 use nihav_registry::register;
20 use std::time::{Duration, Instant};
30 #[derive(Clone,Copy,Default,PartialEq)]
38 pub struct SelfBorrow<T, U> {
43 impl<T: Unpin, U: Unpin> SelfBorrow<T, U> {
44 pub fn new<F>(src: T, create: F) -> Pin<Box<Self>>
45 where F: Fn(*mut T) -> U {
46 let mut obj = Box::pin(Self{
50 let ptr = &mut obj.bval as *mut T;
51 obj.dst = Some(create(ptr));
54 fn get_object(&self) -> &U {
55 if let Some(ref dst) = self.dst {
61 fn get_object_mut(&mut self) -> &mut U {
62 if let Some(ref mut dst) = self.dst {
70 impl<T, U> Drop for SelfBorrow<T, U> {
76 pub type SBBox<T, U> = Pin<Box<SelfBorrow<T, U>>>;
78 const SND_NO_FORMAT: NASoniton = NASoniton { bits: 0, be: false, packed: false, planar: false, float: false, signed: false };
80 fn format_time(ms: u64) -> String {
82 let ds = (ms % 1000) / 100;
83 let (min, s) = (s / 60, s % 60);
84 let (h, min) = (min / 60, min % 60);
87 format!("{}.{}", s, ds)
89 format!("{}:{:02}.{}", min, s, ds)
92 format!("{}:{:02}:{:02}.{}", h, min, s, ds)
96 fn print_options(name: &str, options: &[NAOptionDefinition]) {
97 if options.is_empty() {
98 println!("No custom options.");
100 println!("Options for '{}'", name);
101 for opt in options.iter() {
102 println!(" {}", opt);
107 fn parse_bitrate(strval: &str) -> Result<u32, ()> {
109 let mut has_suffix = false;
110 for ch in strval.chars() {
112 _ if has_suffix => return Err(()),
114 if val >= std::u32::MAX / 100 {
117 val = val * 10 + ch.to_digit(10).unwrap_or(0);
120 if val >= std::u32::MAX / 1000 {
127 if val >= std::u32::MAX / 1000000 {
141 value: Option<String>,
144 struct InputStreamOptions {
147 dec_opts: Vec<OptionArgs>,
150 struct OutputStreamOptions {
152 enc_params: EncodeParameters,
154 enc_opts: Vec<OptionArgs>,
158 Video(NAScale, NABufferType),
159 Audio(AudioConverter),
163 #[allow(clippy::large_enum_variant)]
167 Encode(u32, Box<dyn NAEncoder>, OutputConvert),
171 #[allow(clippy::type_complexity)]
173 input_name: [Option<String>; 16],
174 input_fmt: [Option<String>; 16],
176 output_fmt: Option<String>,
177 demux_opts: [Vec<OptionArgs>; 16],
178 mux_opts: Vec<OptionArgs>,
179 istr_opts: Vec<InputStreamOptions>,
180 ostr_opts: Vec<OutputStreamOptions>,
181 scale_opts: Vec<(String, String)>,
182 decoders: Vec<Option<(Box<NADecoderSupport>, Box<dyn NADecoder>, Box<dyn FrameReorderer>)>>,
183 encoders: Vec<OutputMode>,
191 macro_rules! parse_and_apply_options {
192 ($obj: expr, $in_opts: expr, $name: expr) => {
193 let mut opts = Vec::with_capacity($in_opts.len());
194 let opt_def = $obj.get_supported_options();
195 for opt in $in_opts.iter() {
196 let mut found = false;
197 for opt_def in opt_def.iter() {
198 let mut matches = opt.name == opt_def.name;
199 if !matches && opt.name.starts_with("no") {
200 let (_, name) = opt.name.split_at(2);
201 matches = name == opt_def.name;
204 let arg = if let Some(ref strval) = opt.value { Some(strval) } else { None };
205 let ret = opt_def.parse(&opt.name, arg);
206 if let Ok((val, _)) = ret {
209 println!("invalid option {} for {}", opt.name, $name);
215 println!(" ignoring option '{}' for {}", opt.name, $name);
218 $obj.set_options(opts.as_slice());
223 fn new() -> Self { Self::default() }
224 fn parse_istream_options(&mut self, opt0: &str, opt1: &str) -> bool {
225 let (_, strno) = opt0.split_at(9);
226 let ret = strno.parse::<u32>();
227 if ret.is_err() { return false; }
228 let streamno = ret.unwrap();
230 let sidx = if let Some(idx) = self.istr_opts.iter().position(|el| el.id == streamno) {
233 self.istr_opts.push(InputStreamOptions {id: streamno, drop: false, dec_opts: Vec::new() });
234 self.istr_opts.len() - 1
236 let istr = &mut self.istr_opts[sidx];
238 for opt in opt1.split(',') {
239 let oval: Vec<_> = opt.split('=').collect();
242 "drop" => { istr.drop = true; },
244 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
247 } else if oval.len() == 2 {
248 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
250 println!("unrecognized option '{}'", opt);
255 fn parse_ostream_options(&mut self, opt0: &str, opt1: &str, enc_reg: &RegisteredEncoders) -> bool {
256 let (_, strno) = opt0.split_at(9);
257 let ret = strno.parse::<u32>();
258 if ret.is_err() { return false; }
259 let streamno = ret.unwrap();
261 let sidx = if let Some(idx) = self.ostr_opts.iter().position(|el| el.id == streamno) {
264 self.ostr_opts.push(OutputStreamOptions {id: streamno, enc_name: String::new(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() });
265 self.ostr_opts.len() - 1
267 let ostr = &mut self.ostr_opts[sidx];
269 for opt in opt1.split(',') {
270 let oval: Vec<_> = opt.split('=').collect();
274 if ostr.enc_params.format == NACodecTypeInfo::None {
275 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
277 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
278 vinfo.flipped = true;
280 println!("video option for audio stream");
284 if ostr.enc_params.format == NACodecTypeInfo::None {
285 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
287 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
288 vinfo.flipped = false;
290 println!("video option for audio stream");
294 ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
297 } else if oval.len() == 2 {
298 //todo parse encoder options, store, init later
301 let mut parts = oval[1].split('/');
302 let num = parts.next().unwrap();
303 let den = parts.next();
304 if let Some(den) = den {
305 let rnum = num.parse::<u32>();
306 let rden = den.parse::<u32>();
307 if let (Ok(num), Ok(den)) = (rnum, rden) {
308 ostr.enc_params.tb_num = num;
309 ostr.enc_params.tb_den = den;
311 println!("invalid timebase value");
314 println!("invalid timebase format (should be num/den)");
318 if enc_reg.find_encoder(oval[1]).is_some() {
319 ostr.enc_name = oval[1].to_string();
321 println!("unknown encoder '{}'", oval[1]);
322 ostr.enc_name = oval[1].to_string();
326 if ostr.enc_params.format == NACodecTypeInfo::None {
327 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
329 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
330 let ret = oval[1].parse::<usize>();
331 if let Ok(val) = ret {
334 println!("invalid width");
337 println!("video option for audio stream");
341 if ostr.enc_params.format == NACodecTypeInfo::None {
342 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
344 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
345 let ret = oval[1].parse::<usize>();
346 if let Ok(val) = ret {
349 println!("invalid height");
352 println!("video option for audio stream");
356 if ostr.enc_params.format == NACodecTypeInfo::None {
357 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
359 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
360 let ret = oval[1].parse::<NAPixelFormaton>();
361 if let Ok(val) = ret {
364 println!("invalid pixel format");
367 println!("video option for audio stream");
371 if ostr.enc_params.format == NACodecTypeInfo::None {
372 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
374 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
375 let ret = oval[1].parse::<u32>();
376 if let Ok(val) = ret {
377 ainfo.sample_rate = val;
379 println!("invalid sampling rate");
382 println!("audio option for video stream");
386 if ostr.enc_params.format == NACodecTypeInfo::None {
387 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
389 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
390 let ret = oval[1].parse::<u8>();
391 if let Ok(val) = ret {
392 ainfo.channels = val;
394 println!("invalid number of channels");
397 println!("audio option for video stream");
401 if ostr.enc_params.format == NACodecTypeInfo::None {
402 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
404 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
405 let ret = oval[1].parse::<usize>();
406 if let Ok(val) = ret {
407 ainfo.block_len = val;
409 println!("invalid block_length");
412 println!("audio option for video stream");
416 if ostr.enc_params.format == NACodecTypeInfo::None {
417 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
419 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
420 let ret = oval[1].parse::<NASoniton>();
421 if let Ok(val) = ret {
424 println!("invalid audio format");
427 println!("audio option for video stream");
430 // todo channel map negotiation
432 if ostr.enc_params.format == NACodecTypeInfo::None {
433 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
435 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
436 let ret = oval[1].parse::<NAChannelMap>();
437 if let Ok(val) = ret {
440 println!("invalid channel map");
443 println!("audio option for video stream");
447 let ret = parse_bitrate(oval[1]);
448 if let Ok(val) = ret {
449 ostr.enc_params.bitrate = val;
451 println!("invalid bitrate value");
455 let ret = oval[1].parse::<u8>();
456 if let Ok(val) = ret {
457 ostr.enc_params.quality = val;
459 println!("invalid quality value");
463 ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
467 println!("unrecognized option '{}'", opt);
472 fn parse_demuxer_options(&mut self, opts: &str, dmx_reg: &RegisteredDemuxers, input_no: usize) -> bool {
473 for opt in opts.split(',') {
474 let oval: Vec<_> = opt.split('=').collect();
476 self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: None });
477 } else if oval.len() == 2 {
478 if oval[0] == "format" {
479 if dmx_reg.find_demuxer(oval[1]).is_some() {
480 self.input_fmt[input_no] = Some(oval[1].to_string());
482 println!("unknown demuxer format '{}'", oval[1]);
485 self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
488 println!("unrecognized option '{}'", opt);
493 fn parse_muxer_options(&mut self, opts: &str, mux_reg: &RegisteredMuxers) -> bool {
494 for opt in opts.split(',') {
495 let oval: Vec<_> = opt.split('=').collect();
497 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
498 } else if oval.len() == 2 {
499 if oval[0] == "format" {
500 if mux_reg.find_muxer(oval[1]).is_some() {
501 self.output_fmt = Some(oval[1].to_string());
503 println!("unknown muxer format '{}'", oval[1]);
506 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
509 println!("unrecognized option '{}'", opt);
514 fn parse_scale_options(&mut self, opts: &str) -> bool {
515 for opt in opts.split(',') {
516 let oval: Vec<_> = opt.split('=').collect();
518 self.scale_opts.push((oval[0].to_string(), "".to_string()));
519 } else if oval.len() == 2 {
520 self.scale_opts.push((oval[0].to_string(), oval[1].to_string()));
522 println!("unrecognized option '{}'", opt);
528 fn apply_decoder_options(&self, dec: &mut dyn NADecoder, str_id: u32) {
529 if let Some(str_idx) = self.istr_opts.iter().position(|el| el.id == str_id) {
530 let dec_opts = dec.get_supported_options();
531 if dec_opts.is_empty() { return; }
532 let name = format!("input stream {}", str_id);
533 parse_and_apply_options!(dec, &self.istr_opts[str_idx].dec_opts, name);
536 fn register_output_stream(&mut self, cname: &str, istr: NAStreamRef, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> RegisterResult {
537 let out_id = out_sm.get_num_streams() as u32;
538 if let Some(str_idx) = self.istr_opts.iter().position(|el| el.id == (istr.get_num() as u32)) {
539 if self.istr_opts[str_idx].drop {
540 self.encoders.push(OutputMode::Drop);
541 return RegisterResult::Ignored;
545 if let Some(str_idx) = self.ostr_opts.iter().position(|el| el.id == out_id) {
546 let oopts = &mut self.ostr_opts[str_idx];
547 if oopts.enc_name.as_str() == "copy" && (cname == "any" || istr.get_info().get_name() == cname) {
548 out_sm.add_stream((*istr).clone());
549 self.encoders.push(OutputMode::Copy(out_id));
550 } else if cname == "any" || oopts.enc_name.as_str() == cname {
551 let enc_create = enc_reg.find_encoder(oopts.enc_name.as_str());
552 if enc_create.is_none() {
553 println!("encoder '{}' not found", oopts.enc_name.as_str());
554 return RegisterResult::Failed;
556 let mut encoder = (enc_create.unwrap())();
557 let forced_out = oopts.enc_params.format != NACodecTypeInfo::None;
558 let iformat = istr.get_info().get_properties();
559 if oopts.enc_params.format == NACodecTypeInfo::None {
560 oopts.enc_params.format = istr.get_info().get_properties();
562 match (&iformat, &mut oopts.enc_params.format) {
563 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(ref mut dvinfo)) => {
564 if dvinfo.width == 0 {
565 dvinfo.width = svinfo.width;
567 if dvinfo.height == 0 {
568 dvinfo.height = svinfo.height;
571 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(ref mut dainfo)) => {
572 if dainfo.sample_rate == 0 {
573 dainfo.sample_rate = sainfo.sample_rate;
575 if dainfo.format == SND_NO_FORMAT {
576 dainfo.format = sainfo.format;
578 if dainfo.channels == 0 {
579 dainfo.channels = sainfo.channels;
581 if dainfo.block_len == 0 {
582 dainfo.block_len = sainfo.block_len;
588 if oopts.enc_params.tb_num == 0 {
589 oopts.enc_params.tb_num = istr.tb_num;
590 oopts.enc_params.tb_den = istr.tb_den;
592 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
593 if ret_eparams.is_err() {
594 println!("cannot negotiate encoding parameters");
595 return RegisterResult::Failed;
597 let ret_eparams = ret_eparams.unwrap();
599 //todo check for params mismatch
600 let cvt = match (&iformat, &ret_eparams.format) {
601 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
602 if svinfo == dvinfo && !forced_out {
605 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
606 let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
608 println!("cannot create scaler");
609 return RegisterResult::Failed;
611 let scaler = ret.unwrap();
612 let ret = alloc_video_buffer(*dvinfo, 4);
614 println!("cannot create scaler buffer");
615 return RegisterResult::Failed;
617 let cvt_buf = ret.unwrap();
618 OutputConvert::Video(scaler, cvt_buf)
621 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
622 if sainfo == dainfo {
625 let dchmap = match dainfo.channels {
626 1 => NAChannelMap::from_ms_mapping(0x4),
627 2 => NAChannelMap::from_ms_mapping(0x3),
629 println!("can't generate default channel map for {} channels", dainfo.channels);
630 return RegisterResult::Failed;
633 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
635 OutputConvert::Audio(acvt)
638 _ => OutputConvert::None,
640 let ret = encoder.init(out_id, ret_eparams);
642 println!("error initialising encoder");
643 return RegisterResult::Failed;
645 out_sm.add_stream_ref(ret.unwrap());
647 let name = format!("output stream {}", out_id);
648 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
650 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
652 println!("encoder {} is not supported by output (expected {})", istr.id, istr.get_info().get_name());
653 return RegisterResult::Failed;
655 } else if cname == "any" || istr.get_info().get_name() == cname {
656 out_sm.add_stream((*istr).clone());
657 self.encoders.push(OutputMode::Copy(out_id));
659 let mut oopts = OutputStreamOptions {id: out_id, enc_name: cname.to_owned(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() };
661 let enc_create = enc_reg.find_encoder(cname);
662 if enc_create.is_none() {
663 println!("encoder '{}' not found", oopts.enc_name.as_str());
664 return RegisterResult::Failed;
666 let mut encoder = (enc_create.unwrap())();
667 oopts.enc_params.format = istr.get_info().get_properties();
668 oopts.enc_params.tb_num = istr.tb_num;
669 oopts.enc_params.tb_den = istr.tb_den;
670 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
671 if ret_eparams.is_err() {
672 println!("cannot negotiate encoding parameters");
673 return RegisterResult::Failed;
675 let ret_eparams = ret_eparams.unwrap();
677 //todo check for params mismatch
678 let cvt = match (&oopts.enc_params.format, &ret_eparams.format) {
679 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
680 if svinfo == dvinfo {
683 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
684 let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
686 println!("cannot create scaler");
687 return RegisterResult::Failed;
689 let scaler = ret.unwrap();
690 let ret = alloc_video_buffer(*dvinfo, 4);
692 println!("cannot create scaler buffer");
693 return RegisterResult::Failed;
695 let cvt_buf = ret.unwrap();
696 OutputConvert::Video(scaler, cvt_buf)
699 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
700 if sainfo == dainfo {
703 let dchmap = match dainfo.channels {
704 1 => NAChannelMap::from_ms_mapping(0x4),
705 2 => NAChannelMap::from_ms_mapping(0x3),
707 println!("can't generate default channel map for {} channels", dainfo.channels);
708 return RegisterResult::Failed;
712 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
713 OutputConvert::Audio(acvt)
716 _ => OutputConvert::None,
718 let ret = encoder.init(out_id, ret_eparams);
720 println!("error initialising encoder");
721 return RegisterResult::Failed;
723 out_sm.add_stream_ref(ret.unwrap());
724 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
725 self.ostr_opts.push(oopts);
729 fn map_single(&mut self, cname: &str, ctype: StreamType, src_sm: &StreamManager, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
730 let mut found_stream = false;
731 for istr in src_sm.iter() {
732 if istr.get_media_type() != ctype || found_stream {
733 self.encoders.push(OutputMode::Drop);
735 match self.register_output_stream(cname, istr, out_sm, enc_reg) {
736 RegisterResult::Ok => found_stream = true,
737 RegisterResult::Failed => return false,
738 RegisterResult::Ignored => {},
744 fn negotiate_stream_map(&mut self, src_sm: &StreamManager, mux_caps: MuxerCapabilities, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
746 MuxerCapabilities::SingleVideo(cname) => {
747 if self.no_video { return false; }
748 self.map_single(cname, StreamType::Video, src_sm, out_sm, enc_reg)
750 MuxerCapabilities::SingleAudio(cname) => {
751 if self.no_audio { return false; }
752 self.map_single(cname, StreamType::Audio, src_sm, out_sm, enc_reg)
754 MuxerCapabilities::SingleVideoAndAudio(vname, aname) => {
755 let mut found_vid = false;
756 let mut found_aud = false;
757 for istr in src_sm.iter() {
758 if istr.get_media_type() == StreamType::Video && !found_vid && !self.no_video {
759 match self.register_output_stream(vname, istr, out_sm, enc_reg) {
760 RegisterResult::Ok => found_vid = true,
761 RegisterResult::Failed => return false,
762 RegisterResult::Ignored => {},
764 } else if istr.get_media_type() == StreamType::Audio && !found_aud && !self.no_audio {
765 match self.register_output_stream(aname, istr, out_sm, enc_reg) {
766 RegisterResult::Ok => found_aud = true,
767 RegisterResult::Failed => return false,
768 RegisterResult::Ignored => {},
771 self.encoders.push(OutputMode::Drop);
774 found_vid | found_aud
776 MuxerCapabilities::OnlyVideo => {
777 if self.no_video { return false; }
779 let mut found_vid = false;
780 for istr in src_sm.iter() {
781 if istr.get_media_type() == StreamType::Video && !found_vid {
782 match self.register_output_stream("any", istr, out_sm, enc_reg) {
783 RegisterResult::Ok => found_vid = true,
784 RegisterResult::Failed => return false,
785 RegisterResult::Ignored => {},
788 self.encoders.push(OutputMode::Drop);
793 MuxerCapabilities::OnlyAudio => {
794 if self.no_audio { return false; }
796 let mut found_aud = false;
797 for istr in src_sm.iter() {
798 if istr.get_media_type() == StreamType::Audio && !found_aud {
799 match self.register_output_stream("any", istr, out_sm, enc_reg) {
800 RegisterResult::Ok => found_aud = true,
801 RegisterResult::Failed => return false,
802 RegisterResult::Ignored => {},
805 self.encoders.push(OutputMode::Drop);
810 MuxerCapabilities::Universal => {
811 for istr in src_sm.iter() {
812 if (istr.get_media_type() == StreamType::Video && self.no_video) ||
813 (istr.get_media_type() == StreamType::Audio && self.no_audio) {
814 self.encoders.push(OutputMode::Drop);
817 if self.register_output_stream("any", istr, out_sm, enc_reg) == RegisterResult::Failed {
827 fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef, scale_opts: &[(String, String)]) -> bool {
828 let buf = frm.get_buffer();
829 let cbuf = if let NABufferType::None = buf {
830 if (encoder.get_capabilities() & ENC_CAPS_SKIPFRAME) == 0 {
832 OutputConvert::Video(_, ref mut dbuf) => dbuf.clone(),
834 println!("encoder does not support skip frames, skipping");
843 OutputConvert::None => buf,
844 OutputConvert::Video(ref mut scaler, ref mut dbuf) => {
845 let cur_ifmt = get_scale_fmt_from_pic(&buf);
846 let last_ifmt = scaler.get_in_fmt();
847 if cur_ifmt != last_ifmt {
848 let ofmt = scaler.get_out_fmt();
849 let ret = NAScale::new_with_options(cur_ifmt, ofmt, scale_opts);
851 println!("error re-initialising scaler for {} -> {}", cur_ifmt, ofmt);
854 *scaler = ret.unwrap();
856 let ret = scaler.convert(&buf, dbuf);
858 println!("error converting frame for encoding");
863 OutputConvert::Audio(ref mut acvt) => {
864 if !acvt.queue_frame(buf, frm.get_time_information()) {
865 println!("error converting audio for stream {}", dst_id);
872 let cfrm = NAFrame::new(frm.get_time_information(), frm.frame_type, frm.key, frm.get_info(), cbuf);
873 encoder.encode(&cfrm).unwrap();
877 macro_rules! next_arg {
878 ($args: expr, $arg_idx: expr) => {
879 if $arg_idx + 1 >= $args.len() {
880 println!("codec name is required");
886 macro_rules! parse_id {
887 ($val: expr, $stype: expr, $maxval: expr) => {
890 } else if let Ok(val) = $val.parse::<usize>() {
894 println!("{} number should be below {}", $stype, $maxval);
898 println!("invalid {} number '{}'", $stype, $val);
904 #[allow(clippy::single_match)]
906 let args: Vec<_> = env::args().collect();
909 println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
910 println!(" use nihav-encoder --help to list all available options");
913 if args.len() == 2 && (args[1] == "--help" || args[1] == "-h") {
914 println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
915 println!(" query options:");
916 println!(" --list-{{decoders,encoders,demuxers,muxers}} - lists all available decoders/encoders/demuxers/muxers");
917 println!(" --query-{{decoder,encoder,demuxer,muxer}}-options name - lists all options recognized by that decoder/encoder/demuxer/muxer");
918 println!(" processing options:");
919 println!(" --verbose - show time for the currently processed input");
920 println!(" --input inputfile - set input file");
921 println!(" --input-format fmt - force input format");
922 println!(" --demuxer-options options - set input demuxer options");
923 println!(" --scale-options options - set scaler options");
924 println!(" --output outputfile - set output file");
925 println!(" --output-format fmt - force output format");
926 println!(" --muxer-options options - set output muxer options");
927 println!(" --no-audio - do not decode audio streams");
928 println!(" --no-video - do not decode video streams");
929 println!(" --start starttime - start decoding from given position");
930 println!(" --end endtime - end decoding at given position");
931 println!(" --istreamX options - set options for input stream X");
932 println!(" --ostreamX options - set options for output stream X");
934 println!(" (de)muxer and stream options are passed as comma-separated list e.g. --ostream0 width=320,height=240,flip");
938 let full_reg = FullRegister::new();
940 let mut transcoder = Transcoder::new();
943 let mut printed_info = false;
944 while arg_idx < args.len() {
945 match args[arg_idx].as_str() {
946 "--list-decoders" => {
947 if full_reg.dec_reg.iter().len() > 0 {
948 println!("Registered decoders:");
949 for dec in full_reg.dec_reg.iter() {
950 let cdesc = register::get_codec_description(dec.name);
951 let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
952 println!(" {} ({})", dec.name, full_name);
955 println!("No registered decoders.");
959 "--list-encoders" => {
960 if full_reg.enc_reg.iter().len() > 0 {
961 println!("Registered encoders:");
962 for enc in full_reg.enc_reg.iter() {
963 let cdesc = register::get_codec_description(enc.name);
964 let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
965 println!(" {} ({})", enc.name, full_name);
968 println!("No registered encoders.");
972 "--list-demuxers" => {
973 print!("Registered demuxers:");
974 for dmx in full_reg.dmx_reg.iter() {
975 print!(" {}", dmx.get_name());
981 print!("Registered muxers:");
982 for mux in full_reg.mux_reg.iter() {
983 print!(" {}", mux.get_name());
988 "--query-decoder-options" => {
989 next_arg!(args, arg_idx);
990 let cname = args[arg_idx].as_str();
991 if let Some(decfunc) = full_reg.dec_reg.find_decoder(cname) {
992 let dec = (decfunc)();
993 let opts = dec.get_supported_options();
994 print_options(cname, opts);
996 println!("codec {} is not found", cname);
1000 "--query-demuxer-options" => {
1001 next_arg!(args, arg_idx);
1002 let dname = args[arg_idx].as_str();
1003 let mut mr = MemoryReader::new_read(&[]);
1004 let mut br = ByteReader::new(&mut mr);
1005 if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) {
1006 let dmx = dmx_creator.new_demuxer(&mut br);
1007 let opts = dmx.get_supported_options();
1008 print_options(dname, opts);
1010 println!("demuxer {} is not found", dname);
1012 printed_info = true;
1014 "--query-encoder-options" => {
1015 next_arg!(args, arg_idx);
1016 let cname = args[arg_idx].as_str();
1017 if let Some(encfunc) = full_reg.enc_reg.find_encoder(cname) {
1018 let enc = (encfunc)();
1019 let opts = enc.get_supported_options();
1020 print_options(cname, opts);
1022 println!("codec {} is not found", cname);
1024 printed_info = true;
1026 "--query-muxer-options" => {
1027 next_arg!(args, arg_idx);
1028 let name = args[arg_idx].as_str();
1030 let mut mw = MemoryWriter::new_write(&mut data);
1031 let mut bw = ByteWriter::new(&mut mw);
1032 if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) {
1033 let mux = mux_creator.new_muxer(&mut bw);
1034 let opts = mux.get_supported_options();
1035 print_options(name, opts);
1037 println!("muxer {} is not found", name);
1039 printed_info = true;
1041 "--output" | "-o" => {
1042 next_arg!(args, arg_idx);
1043 transcoder.output_name = args[arg_idx].clone();
1045 "--output-format" => {
1046 next_arg!(args, arg_idx);
1047 transcoder.output_fmt = Some(args[arg_idx].clone());
1049 "--scale-options" => {
1050 next_arg!(args, arg_idx);
1051 if !transcoder.parse_scale_options(&args[arg_idx]) {
1052 println!("invalid scale option syntax");
1056 "--no-video" | "-vn" => {
1057 transcoder.no_video = true;
1059 "--no-audio" | "-an" => {
1060 transcoder.no_audio = true;
1063 next_arg!(args, arg_idx);
1064 let ret = args[arg_idx].parse::<NATimePoint>();
1065 if let Ok(val) = ret {
1066 transcoder.start = val;
1068 println!("invalid start time");
1073 next_arg!(args, arg_idx);
1074 let ret = args[arg_idx].parse::<NATimePoint>();
1075 if let Ok(val) = ret {
1076 transcoder.end = val;
1078 println!("invalid end time");
1082 "--muxer-options" => {
1083 next_arg!(args, arg_idx);
1084 if !transcoder.parse_muxer_options(&args[arg_idx], &full_reg.mux_reg) {
1085 println!("invalid muxer option syntax");
1089 "--verbose" | "-v" => transcoder.verbose = 1,
1090 "-vv" => transcoder.verbose = 2,
1091 "-v-" => transcoder.verbose = 0,
1093 if args[arg_idx].starts_with("--istream") {
1094 let opt0 = &args[arg_idx];
1095 next_arg!(args, arg_idx);
1096 if !transcoder.parse_istream_options(opt0, &args[arg_idx]) {
1097 println!("invalid input stream option syntax");
1100 } else if args[arg_idx].starts_with("--ostream") {
1101 let opt0 = &args[arg_idx];
1102 next_arg!(args, arg_idx);
1103 if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &full_reg.enc_reg) {
1104 println!("invalid output stream option syntax");
1107 } else if args[arg_idx].starts_with("--input-format") {
1108 let id = parse_id!(&args[arg_idx][14..], "input format", transcoder.input_fmt.len());
1109 next_arg!(args, arg_idx);
1110 transcoder.input_fmt[id] = Some(args[arg_idx].clone());
1111 } else if args[arg_idx].starts_with("--input") { // should be after --input-format
1112 let id = parse_id!(&args[arg_idx][7..], "input", transcoder.input_name.len());
1113 next_arg!(args, arg_idx);
1114 transcoder.input_name[id] = Some(args[arg_idx].clone());
1115 } else if args[arg_idx].starts_with("-i") {
1116 let id = parse_id!(&args[arg_idx][2..], "input", transcoder.input_name.len());
1117 next_arg!(args, arg_idx);
1118 transcoder.input_name[id] = Some(args[arg_idx].clone());
1119 } else if args[arg_idx].starts_with("--demuxer-options") {
1120 let id = parse_id!(&args[arg_idx][17..], "input options", transcoder.demux_opts.len());
1121 next_arg!(args, arg_idx);
1122 if !transcoder.parse_demuxer_options(&args[arg_idx], &full_reg.dmx_reg, id) {
1123 println!("invalid demuxer option syntax");
1126 } else if args[arg_idx].starts_with("--") {
1127 println!("unknown option");
1129 println!("unrecognized argument");
1140 if transcoder.input_name.iter().flatten().count() == 0 {
1141 println!("no input name(s) provided");
1144 if transcoder.output_name.is_empty() {
1145 println!("no output name provided");
1149 let mut demuxers = Vec::with_capacity(1);
1150 let mut isn_start = 0;
1151 for (i, (iname, ifmt)) in transcoder.input_name.iter().zip(
1152 transcoder.input_fmt.iter()).enumerate() {
1153 match (iname, ifmt.as_ref().map(|s| s.as_str())) {
1154 (Some(name), Some("imgseq")) => {
1155 println!("trying image sequence {}", name);
1156 let mut isdc = ImgSeqDemuxerCreator::new(name.as_str());
1157 parse_and_apply_options!(isdc, &transcoder.demux_opts[i], "input");
1158 let isd = if let Ok(ctx) = isdc.open() {
1161 println!("failed to create image sequence demuxer!");
1164 let dmx = DemuxerObject::create_imgseq(isd);
1165 for i in 0..dmx.get_num_streams() {
1166 let s = dmx.get_stream(i).unwrap();
1167 let info = s.get_info();
1168 println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
1170 isn_start += dmx.get_num_streams();
1171 demuxers.push((dmx, false))
1173 (Some(name), _) => {
1174 let res = File::open(name);
1176 println!("error opening input");
1179 let file = res.unwrap();
1180 let file = BufReader::new(file);
1181 let mut fr = FileReader::new_read(file);
1182 let mut br = ByteReader::new(&mut fr);
1183 let (is_raw, start, end) = if ifmt.is_none() {
1184 detect_tags(&mut br)
1189 let nfr: Box<dyn ByteIO> = if start != 0 || end.is_some() {
1190 let file = fr.finish();
1191 Box::new(BoundedFileReader::new_read(file, start, end).unwrap())
1195 let sb = SelfBorrow::new(nfr, |rd| {
1197 ByteReader::new(rd.as_mut().unwrap().as_mut())
1201 let mut dmx = DemuxerObject::create(sb, &full_reg, name, ifmt, is_raw);
1203 println!("cannot find demuxer for '{}'", name);
1206 parse_and_apply_options!(dmx, &transcoder.demux_opts[i], "input");
1207 for i in 0..dmx.get_num_streams() {
1208 let s = dmx.get_stream(i).unwrap();
1209 let info = s.get_info();
1210 println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
1212 isn_start += dmx.get_num_streams();
1213 demuxers.push((dmx, false));
1219 let duration = demuxers.iter().fold(0u64, |mindur, (dmx, _)| {
1220 let dur = dmx.get_duration();
1227 let duration_string = if duration != 0 { format_time(duration) } else { String::new() };
1229 let mut ism = StreamManager::new();
1230 let mut is_offset = Vec::with_capacity(demuxers.len());
1232 let mut nstreams = 0;
1233 for (dmx, _) in demuxers.iter() {
1234 is_offset.push(nstreams);
1235 let sm = dmx.get_stream_manager();
1236 let max_id = sm.iter().fold(0u32, |id, strm| id.max(strm.id));
1237 for stream in sm.iter() {
1238 let mut newstream = (*stream).clone();
1239 newstream.id += start;
1240 ism.add_stream(newstream);
1242 start += max_id + 1;
1243 nstreams += sm.get_num_streams();
1246 for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
1247 for i in 0..dmx.get_num_streams() {
1248 let s = dmx.get_stream(i).unwrap();
1249 let info = s.get_info();
1250 let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
1251 let str_id = (s.get_num() + is_off) as u32;
1252 if let Some(create_dec) = decfunc {
1253 let mut dec = (create_dec)();
1254 let mut dsupp = Box::new(NADecoderSupport::new());
1255 let ret = dec.init(&mut dsupp, info.clone());
1257 println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
1260 transcoder.apply_decoder_options(dec.as_mut(), str_id);
1261 let desc = register::get_codec_description(info.get_name());
1262 let has_b = if let Some(desc) = desc {
1265 println!("No codec description found, using B-frame reorderer.");
1268 let reord: Box<dyn FrameReorderer> = if has_b { Box::new(IPBReorderer::new()) } else { Box::new(NoReorderer::new()) };
1269 transcoder.decoders.push(Some((dsupp, dec, reord)));
1271 println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
1272 transcoder.decoders.push(None);
1275 if transcoder.start != NATimePoint::None {
1276 let ret = dmx.seek(transcoder.start);
1278 println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
1283 let output_fmt = if let Some(ref fmtname) = transcoder.output_fmt {
1285 } else if transcoder.output_name.as_str() == "/dev/null" {
1287 } else if let Some(fmtname) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
1290 println!("Cannot guess muxer for output");
1293 let ret = full_reg.mux_reg.find_muxer(output_fmt);
1294 let ofmt = output_fmt.to_string();
1297 println!("cannot find muxer '{}'", output_fmt);
1299 let mux_creator = ret.unwrap();
1301 let mux_caps = mux_creator.get_capabilities();
1302 let mut out_sm = StreamManager::new();
1303 if !transcoder.negotiate_stream_map(&ism, mux_caps, &mut out_sm, &full_reg.enc_reg) {
1304 println!("cannot determine stream map");
1308 let ret = File::create(transcoder.output_name.as_str());
1310 println!("cannot open output file");
1313 let mut fw = FileWriter::new_write(ret.unwrap());
1314 let mut bw = ByteWriter::new(&mut fw);
1315 let ret = create_muxer(mux_creator, out_sm, &mut bw);
1316 if let Err(err) = ret {
1317 println!("cannot create muxer instance {:?}", err);
1320 let mut mux = ret.unwrap();
1321 parse_and_apply_options!(mux, &transcoder.mux_opts, "output");
1323 println!("Output {} muxer {}", transcoder.output_name, ofmt);
1324 for ostr in mux.get_streams() {
1325 println!(" #{}: {} {}", ostr.get_num(), ostr, ostr.get_info().get_name());
1328 let mut time = Instant::now();
1329 let show_interval = Duration::from_millis(100);
1330 let mut adata_size = 0;
1331 let mut vdata_size = 0;
1332 let mut cur_dmx = 0;
1334 let mut pktres = Err(DemuxerError::EOF);
1335 let mut src_dmx = 0;
1337 if !demuxers.iter().any(|(_, eof)| !eof) {
1340 let mut got_res = false;
1341 if !demuxers[cur_dmx].1 {
1342 pktres = demuxers[cur_dmx].0.get_frame();
1347 if cur_dmx >= demuxers.len() {
1355 if let Err(DemuxerError::EOF) = pktres { break; }
1356 if pktres.is_err() {
1357 println!("demuxing error");
1360 let mut pkt = pktres.unwrap();
1361 if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; }
1362 let src_id = pkt.get_stream().get_num() + is_offset[src_dmx];
1364 let newstream = ism.get_stream(src_id).unwrap();
1365 pkt.reassign(newstream, ts);
1367 if transcoder.verbose > 0 && time.elapsed() >= show_interval {
1368 if let Some(pts) = pkt.get_pts() {
1369 let cur_time = format_time(NATimeInfo::ts_to_time(pts, 1000, pkt.ts.tb_num, pkt.ts.tb_den));
1370 print!(" {}", cur_time);
1374 if !duration_string.is_empty() {
1375 print!(" / {}", duration_string);
1377 if transcoder.verbose > 1 {
1378 print!(" data sizes V: {} A: {}", vdata_size, adata_size);
1381 std::io::stdout().flush().unwrap();
1382 time = Instant::now();
1384 match transcoder.encoders[src_id] {
1385 OutputMode::Drop => {},
1386 OutputMode::Copy(dst_id) => {
1387 let dstr = mux.get_stream(dst_id as usize).unwrap();
1388 pkt.reassign(dstr, pkt.get_time_information());
1389 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1390 let pkt_size = pkt.get_buffer().len();
1391 match pkt.get_stream().get_media_type() {
1392 StreamType::Video => { vdata_size += pkt_size; },
1393 StreamType::Audio => { adata_size += pkt_size; },
1396 if mux.mux_frame(pkt).is_err() {
1397 println!("error muxing packet");
1401 OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) => {
1402 if let Some((ref mut dsupp, ref mut decoder, ref mut reorderer)) = transcoder.decoders[src_id] {
1403 let ret = decoder.decode(dsupp, &pkt);
1404 if let (true, Err(DecoderError::MissingReference)) = (transcoder.start != NATimePoint::None, &ret) {
1408 println!("error decoding stream {}", src_id);
1411 let frm = ret.unwrap();
1412 let tinfo = frm.get_info();
1413 reorderer.add_frame(frm);
1414 while let Some(frm) = reorderer.get_frame() {
1415 if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1418 while let Ok(Some(pkt)) = encoder.get_packet() {
1419 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1420 let pkt_size = pkt.get_buffer().len();
1421 match pkt.get_stream().get_media_type() {
1422 StreamType::Video => { vdata_size += pkt_size; },
1423 StreamType::Audio => { adata_size += pkt_size; },
1426 mux.mux_frame(pkt).unwrap();
1429 if let OutputConvert::Audio(ref mut acvt) = cvt {
1430 while let Some(ofrm) = acvt.get_frame(tinfo.clone()) {
1431 if encoder.encode(&ofrm).is_err() {
1434 while let Ok(Some(pkt)) = encoder.get_packet() {
1435 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1436 let pkt_size = pkt.get_buffer().len();
1437 adata_size += pkt_size;
1438 mux.mux_frame(pkt).unwrap();
1443 println!("no decoder for stream {}", src_id);
1449 'reord_flush_loop: for stream in ism.iter() {
1450 let src_id = stream.get_num();
1451 if let OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) = transcoder.encoders[src_id] {
1452 if let Some((_, _, ref mut reorderer)) = transcoder.decoders[src_id] {
1453 while let Some(frm) = reorderer.get_last_frames() {
1454 if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1457 while let Ok(Some(pkt)) = encoder.get_packet() {
1458 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'reord_flush_loop; }
1459 mux.mux_frame(pkt).unwrap();
1465 'flush_loop: for enc in transcoder.encoders.iter_mut() {
1467 OutputMode::Encode(str_id, ref mut encoder, _) => {
1468 let ret = encoder.flush();
1470 println!("error flushing encoder for stream {}", str_id);
1473 while let Ok(Some(pkt)) = encoder.get_packet() {
1474 if mux.mux_frame(pkt).is_err() {
1475 println!("error muxing packet");
1484 if transcoder.verbose > 0 {
1488 let ret = mux.end();
1490 println!("error at finalising muxing");