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>,
194 macro_rules! parse_and_apply_options {
195 ($obj: expr, $in_opts: expr, $name: expr) => {
196 let mut opts = Vec::with_capacity($in_opts.len());
197 let opt_def = $obj.get_supported_options();
198 for opt in $in_opts.iter() {
199 let mut found = false;
200 for opt_def in opt_def.iter() {
201 let mut matches = opt.name == opt_def.name;
202 if !matches && opt.name.starts_with("no") {
203 let (_, name) = opt.name.split_at(2);
204 matches = name == opt_def.name;
207 let arg = if let Some(ref strval) = opt.value { Some(strval) } else { None };
208 let ret = opt_def.parse(&opt.name, arg);
209 if let Ok((val, _)) = ret {
212 println!("invalid option {} for {}", opt.name, $name);
218 println!(" ignoring option '{}' for {}", opt.name, $name);
221 $obj.set_options(opts.as_slice());
226 fn new() -> Self { Self::default() }
227 fn parse_istream_options(&mut self, opt0: &str, opt1: &str) -> bool {
228 let (_, strno) = opt0.split_at(9);
229 let ret = strno.parse::<u32>();
230 if ret.is_err() { return false; }
231 let streamno = ret.unwrap();
233 let sidx = if let Some(idx) = self.istr_opts.iter().position(|el| el.id == streamno) {
236 self.istr_opts.push(InputStreamOptions {id: streamno, drop: false, dec_opts: Vec::new() });
237 self.istr_opts.len() - 1
239 let istr = &mut self.istr_opts[sidx];
241 for opt in opt1.split(',') {
242 let oval: Vec<_> = opt.split('=').collect();
245 "drop" => { istr.drop = true; },
247 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
250 } else if oval.len() == 2 {
251 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
253 println!("unrecognized option '{}'", opt);
258 fn parse_ostream_options(&mut self, opt0: &str, opt1: &str, enc_reg: &RegisteredEncoders) -> bool {
259 let (_, strno) = opt0.split_at(9);
260 let ret = strno.parse::<u32>();
261 if ret.is_err() { return false; }
262 let streamno = ret.unwrap();
264 let sidx = if let Some(idx) = self.ostr_opts.iter().position(|el| el.id == streamno) {
267 self.ostr_opts.push(OutputStreamOptions {id: streamno, enc_name: String::new(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() });
268 self.ostr_opts.len() - 1
270 let ostr = &mut self.ostr_opts[sidx];
272 for opt in opt1.split(',') {
273 let oval: Vec<_> = opt.split('=').collect();
277 if ostr.enc_params.format == NACodecTypeInfo::None {
278 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
280 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
281 vinfo.flipped = true;
283 println!("video option for audio stream");
287 if ostr.enc_params.format == NACodecTypeInfo::None {
288 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
290 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
291 vinfo.flipped = false;
293 println!("video option for audio stream");
297 ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
300 } else if oval.len() == 2 {
301 //todo parse encoder options, store, init later
304 let mut parts = oval[1].split('/');
305 let num = parts.next().unwrap();
306 let den = parts.next();
307 if let Some(den) = den {
308 let rnum = num.parse::<u32>();
309 let rden = den.parse::<u32>();
310 if let (Ok(num), Ok(den)) = (rnum, rden) {
311 ostr.enc_params.tb_num = num;
312 ostr.enc_params.tb_den = den;
314 println!("invalid timebase value");
317 println!("invalid timebase format (should be num/den)");
321 if enc_reg.find_encoder(oval[1]).is_some() {
322 ostr.enc_name = oval[1].to_string();
324 println!("unknown encoder '{}'", oval[1]);
325 ostr.enc_name = oval[1].to_string();
329 if ostr.enc_params.format == NACodecTypeInfo::None {
330 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
332 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
333 let ret = oval[1].parse::<usize>();
334 if let Ok(val) = ret {
337 println!("invalid width");
340 println!("video option for audio stream");
344 if ostr.enc_params.format == NACodecTypeInfo::None {
345 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
347 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
348 let ret = oval[1].parse::<usize>();
349 if let Ok(val) = ret {
352 println!("invalid height");
355 println!("video option for audio stream");
359 if ostr.enc_params.format == NACodecTypeInfo::None {
360 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
362 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
363 let ret = oval[1].parse::<NAPixelFormaton>();
364 if let Ok(val) = ret {
367 println!("invalid pixel format");
370 println!("video option for audio stream");
374 if ostr.enc_params.format == NACodecTypeInfo::None {
375 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
377 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
378 let ret = oval[1].parse::<u32>();
379 if let Ok(val) = ret {
380 ainfo.sample_rate = val;
382 println!("invalid sampling rate");
385 println!("audio option for video stream");
389 if ostr.enc_params.format == NACodecTypeInfo::None {
390 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
392 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
393 let ret = oval[1].parse::<u8>();
394 if let Ok(val) = ret {
395 ainfo.channels = val;
397 println!("invalid number of channels");
400 println!("audio option for video stream");
404 if ostr.enc_params.format == NACodecTypeInfo::None {
405 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
407 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
408 let ret = oval[1].parse::<usize>();
409 if let Ok(val) = ret {
410 ainfo.block_len = val;
412 println!("invalid block_length");
415 println!("audio option for video stream");
419 if ostr.enc_params.format == NACodecTypeInfo::None {
420 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
422 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
423 let ret = oval[1].parse::<NASoniton>();
424 if let Ok(val) = ret {
427 println!("invalid audio format");
430 println!("audio option for video stream");
433 // todo channel map negotiation
435 if ostr.enc_params.format == NACodecTypeInfo::None {
436 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
438 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
439 let ret = oval[1].parse::<NAChannelMap>();
440 if let Ok(val) = ret {
443 println!("invalid channel map");
446 println!("audio option for video stream");
450 let ret = parse_bitrate(oval[1]);
451 if let Ok(val) = ret {
452 ostr.enc_params.bitrate = val;
454 println!("invalid bitrate value");
458 let ret = oval[1].parse::<u8>();
459 if let Ok(val) = ret {
460 ostr.enc_params.quality = val;
462 println!("invalid quality value");
466 ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
470 println!("unrecognized option '{}'", opt);
475 fn parse_demuxer_options(&mut self, opts: &str, dmx_reg: &RegisteredDemuxers, input_no: usize) -> bool {
476 for opt in opts.split(',') {
477 let oval: Vec<_> = opt.split('=').collect();
479 self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: None });
480 } else if oval.len() == 2 {
481 if oval[0] == "format" {
482 if dmx_reg.find_demuxer(oval[1]).is_some() {
483 self.input_fmt[input_no] = Some(oval[1].to_string());
485 println!("unknown demuxer format '{}'", oval[1]);
488 self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
491 println!("unrecognized option '{}'", opt);
496 fn parse_muxer_options(&mut self, opts: &str, mux_reg: &RegisteredMuxers) -> bool {
497 for opt in opts.split(',') {
498 let oval: Vec<_> = opt.split('=').collect();
500 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
501 } else if oval.len() == 2 {
502 if oval[0] == "format" {
503 if mux_reg.find_muxer(oval[1]).is_some() {
504 self.output_fmt = Some(oval[1].to_string());
506 println!("unknown muxer format '{}'", oval[1]);
509 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
512 println!("unrecognized option '{}'", opt);
517 fn parse_scale_options(&mut self, opts: &str) -> bool {
518 for opt in opts.split(',') {
519 let oval: Vec<_> = opt.split('=').collect();
521 self.scale_opts.push((oval[0].to_string(), "".to_string()));
522 } else if oval.len() == 2 {
523 self.scale_opts.push((oval[0].to_string(), oval[1].to_string()));
525 println!("unrecognized option '{}'", opt);
531 fn apply_decoder_options(&self, dec: &mut dyn NADecoder, str_id: u32) {
532 if let Some(str_idx) = self.istr_opts.iter().position(|el| el.id == str_id) {
533 let dec_opts = dec.get_supported_options();
534 if dec_opts.is_empty() { return; }
535 let name = format!("input stream {}", str_id);
536 parse_and_apply_options!(dec, &self.istr_opts[str_idx].dec_opts, name);
539 fn register_output_stream(&mut self, cname: &str, istr: NAStreamRef, iidx: usize, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> RegisterResult {
540 let out_id = out_sm.get_num_streams() as u32;
541 if let Some(str_idx) = self.istr_opts.iter().position(|el| el.id == (istr.get_num() as u32)) {
542 if self.istr_opts[str_idx].drop {
543 self.encoders.push(OutputMode::Drop);
544 return RegisterResult::Ignored;
548 if let Some(str_idx) = self.ostr_opts.iter().position(|el| el.id == out_id) {
549 let oopts = &mut self.ostr_opts[str_idx];
550 if oopts.enc_name.as_str() == "copy" && (cname == "any" || istr.get_info().get_name() == cname) {
551 out_sm.add_stream((*istr).clone());
552 self.encoders.push(OutputMode::Copy(out_id));
553 } else if cname == "any" || oopts.enc_name.as_str() == cname {
554 let enc_create = enc_reg.find_encoder(oopts.enc_name.as_str());
555 if enc_create.is_none() {
556 println!("encoder '{}' not found", oopts.enc_name.as_str());
557 return RegisterResult::Failed;
559 let mut encoder = (enc_create.unwrap())();
560 let forced_out = oopts.enc_params.format != NACodecTypeInfo::None;
561 let iformat = istr.get_info().get_properties();
562 if oopts.enc_params.format == NACodecTypeInfo::None {
563 oopts.enc_params.format = istr.get_info().get_properties();
565 match (&iformat, &mut oopts.enc_params.format) {
566 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(ref mut dvinfo)) => {
567 if dvinfo.width == 0 {
568 dvinfo.width = svinfo.width;
570 if dvinfo.height == 0 {
571 dvinfo.height = svinfo.height;
574 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(ref mut dainfo)) => {
575 if dainfo.sample_rate == 0 {
576 dainfo.sample_rate = sainfo.sample_rate;
578 if dainfo.format == SND_NO_FORMAT {
579 dainfo.format = sainfo.format;
581 if dainfo.channels == 0 {
582 dainfo.channels = sainfo.channels;
584 if dainfo.block_len == 0 {
585 dainfo.block_len = sainfo.block_len;
591 if oopts.enc_params.tb_num == 0 {
592 oopts.enc_params.tb_num = istr.tb_num;
593 oopts.enc_params.tb_den = istr.tb_den;
595 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
596 if ret_eparams.is_err() {
597 println!("cannot negotiate encoding parameters");
598 return RegisterResult::Failed;
600 let ret_eparams = ret_eparams.unwrap();
602 //todo check for params mismatch
603 let cvt = match (&iformat, &ret_eparams.format) {
604 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
605 if svinfo == dvinfo && !forced_out {
608 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
609 let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
611 println!("cannot create scaler");
612 return RegisterResult::Failed;
614 let scaler = ret.unwrap();
615 let ret = alloc_video_buffer(*dvinfo, 4);
617 println!("cannot create scaler buffer");
618 return RegisterResult::Failed;
620 let cvt_buf = ret.unwrap();
621 OutputConvert::Video(scaler, cvt_buf)
624 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
625 if sainfo == dainfo {
628 let dchmap = match dainfo.channels {
629 1 => NAChannelMap::from_ms_mapping(0x4),
630 2 => NAChannelMap::from_ms_mapping(0x3),
632 println!("can't generate default channel map for {} channels", dainfo.channels);
633 return RegisterResult::Failed;
636 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
638 OutputConvert::Audio(acvt)
641 _ => OutputConvert::None,
643 let name = format!("output stream {}", out_id);
644 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
646 if self.calc_len && self.nframes.len() > iidx {
647 encoder.set_options(&[NAOption{name: "nframes", value: NAValue::Int(self.nframes[iidx] as i64)}]);
650 let ret = encoder.init(out_id, ret_eparams);
652 println!("error initialising encoder");
653 return RegisterResult::Failed;
655 out_sm.add_stream_ref(ret.unwrap());
657 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
659 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
661 println!("encoder {} is not supported by output (expected {})", istr.id, istr.get_info().get_name());
662 return RegisterResult::Failed;
664 } else if cname == "any" || istr.get_info().get_name() == cname {
665 out_sm.add_stream((*istr).clone());
666 self.encoders.push(OutputMode::Copy(out_id));
668 let mut oopts = OutputStreamOptions {id: out_id, enc_name: cname.to_owned(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() };
670 let enc_create = enc_reg.find_encoder(cname);
671 if enc_create.is_none() {
672 println!("encoder '{}' not found", oopts.enc_name.as_str());
673 return RegisterResult::Failed;
675 let mut encoder = (enc_create.unwrap())();
676 oopts.enc_params.format = istr.get_info().get_properties();
677 oopts.enc_params.tb_num = istr.tb_num;
678 oopts.enc_params.tb_den = istr.tb_den;
679 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
680 if ret_eparams.is_err() {
681 println!("cannot negotiate encoding parameters");
682 return RegisterResult::Failed;
684 let ret_eparams = ret_eparams.unwrap();
686 //todo check for params mismatch
687 let cvt = match (&oopts.enc_params.format, &ret_eparams.format) {
688 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
689 if svinfo == dvinfo {
692 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
693 let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
695 println!("cannot create scaler");
696 return RegisterResult::Failed;
698 let scaler = ret.unwrap();
699 let ret = alloc_video_buffer(*dvinfo, 4);
701 println!("cannot create scaler buffer");
702 return RegisterResult::Failed;
704 let cvt_buf = ret.unwrap();
705 OutputConvert::Video(scaler, cvt_buf)
708 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
709 if sainfo == dainfo {
712 let dchmap = match dainfo.channels {
713 1 => NAChannelMap::from_ms_mapping(0x4),
714 2 => NAChannelMap::from_ms_mapping(0x3),
716 println!("can't generate default channel map for {} channels", dainfo.channels);
717 return RegisterResult::Failed;
721 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
722 OutputConvert::Audio(acvt)
725 _ => OutputConvert::None,
727 let ret = encoder.init(out_id, ret_eparams);
729 println!("error initialising encoder");
730 return RegisterResult::Failed;
732 out_sm.add_stream_ref(ret.unwrap());
733 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
734 self.ostr_opts.push(oopts);
738 fn map_single(&mut self, cname: &str, ctype: StreamType, src_sm: &StreamManager, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
739 let mut found_stream = false;
740 for (iidx, istr) in src_sm.iter().enumerate() {
741 if istr.get_media_type() != ctype || found_stream {
742 self.encoders.push(OutputMode::Drop);
744 match self.register_output_stream(cname, istr, iidx, out_sm, enc_reg) {
745 RegisterResult::Ok => found_stream = true,
746 RegisterResult::Failed => return false,
747 RegisterResult::Ignored => {},
753 fn negotiate_stream_map(&mut self, src_sm: &StreamManager, mux_caps: MuxerCapabilities, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
755 MuxerCapabilities::SingleVideo(cname) => {
756 if self.no_video { return false; }
757 self.map_single(cname, StreamType::Video, src_sm, out_sm, enc_reg)
759 MuxerCapabilities::SingleAudio(cname) => {
760 if self.no_audio { return false; }
761 self.map_single(cname, StreamType::Audio, src_sm, out_sm, enc_reg)
763 MuxerCapabilities::SingleVideoAndAudio(vname, aname) => {
764 let mut found_vid = false;
765 let mut found_aud = false;
766 for (iidx, istr) in src_sm.iter().enumerate() {
767 if istr.get_media_type() == StreamType::Video && !found_vid && !self.no_video {
768 match self.register_output_stream(vname, istr, iidx, out_sm, enc_reg) {
769 RegisterResult::Ok => found_vid = true,
770 RegisterResult::Failed => return false,
771 RegisterResult::Ignored => {},
773 } else if istr.get_media_type() == StreamType::Audio && !found_aud && !self.no_audio {
774 match self.register_output_stream(aname, istr, iidx, out_sm, enc_reg) {
775 RegisterResult::Ok => found_aud = true,
776 RegisterResult::Failed => return false,
777 RegisterResult::Ignored => {},
780 self.encoders.push(OutputMode::Drop);
783 found_vid | found_aud
785 MuxerCapabilities::OnlyVideo => {
786 if self.no_video { return false; }
788 let mut found_vid = false;
789 for (iidx, istr) in src_sm.iter().enumerate() {
790 if istr.get_media_type() == StreamType::Video && !found_vid {
791 match self.register_output_stream("any", istr, iidx, out_sm, enc_reg) {
792 RegisterResult::Ok => found_vid = true,
793 RegisterResult::Failed => return false,
794 RegisterResult::Ignored => {},
797 self.encoders.push(OutputMode::Drop);
802 MuxerCapabilities::OnlyAudio => {
803 if self.no_audio { return false; }
805 let mut found_aud = false;
806 for (iidx, istr) in src_sm.iter().enumerate() {
807 if istr.get_media_type() == StreamType::Audio && !found_aud {
808 match self.register_output_stream("any", istr, iidx, out_sm, enc_reg) {
809 RegisterResult::Ok => found_aud = true,
810 RegisterResult::Failed => return false,
811 RegisterResult::Ignored => {},
814 self.encoders.push(OutputMode::Drop);
819 MuxerCapabilities::Universal => {
820 for (iidx, istr) in src_sm.iter().enumerate() {
821 if (istr.get_media_type() == StreamType::Video && self.no_video) ||
822 (istr.get_media_type() == StreamType::Audio && self.no_audio) {
823 self.encoders.push(OutputMode::Drop);
826 if self.register_output_stream("any", istr, iidx, out_sm, enc_reg) == RegisterResult::Failed {
834 fn create_demuxers(&mut self, demuxers: &mut Vec<(DemuxerObject, bool)>, full_reg: &FullRegister, print_info: bool) -> bool {
835 let mut isn_start = 0;
836 for (i, (iname, ifmt)) in self.input_name.iter().zip(
837 self.input_fmt.iter()).enumerate() {
838 match (iname, ifmt.as_ref().map(|s| s.as_str())) {
839 (Some(name), Some("imgseq")) => {
840 println!("trying image sequence {}", name);
841 let mut isdc = ImgSeqDemuxerCreator::new(name.as_str());
842 parse_and_apply_options!(isdc, &self.demux_opts[i], "input");
843 let isd = if let Ok(ctx) = isdc.open() {
846 println!("failed to create image sequence demuxer!");
849 let dmx = DemuxerObject::create_imgseq(isd);
851 for i in 0..dmx.get_num_streams() {
852 let s = dmx.get_stream(i).unwrap();
853 let info = s.get_info();
854 println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
857 isn_start += dmx.get_num_streams();
858 demuxers.push((dmx, false))
861 let res = File::open(name);
863 println!("error opening input");
866 let file = res.unwrap();
867 let file = BufReader::new(file);
868 let mut fr = FileReader::new_read(file);
869 let mut br = ByteReader::new(&mut fr);
870 let (is_raw, start, end) = if ifmt.is_none() {
876 let nfr: Box<dyn ByteIO> = if start != 0 || end.is_some() {
877 let file = fr.finish();
878 Box::new(BoundedFileReader::new_read(file, start, end).unwrap())
882 let sb = SelfBorrow::new(nfr, |rd| {
884 ByteReader::new(rd.as_mut().unwrap().as_mut())
888 let mut dmx = DemuxerObject::create(sb, full_reg, name, ifmt, is_raw, print_info);
890 println!("cannot find demuxer for '{}'", name);
893 parse_and_apply_options!(dmx, &self.demux_opts[i], "input");
895 for i in 0..dmx.get_num_streams() {
896 let s = dmx.get_stream(i).unwrap();
897 let info = s.get_info();
898 println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
901 isn_start += dmx.get_num_streams();
902 demuxers.push((dmx, false));
911 fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef, scale_opts: &[(String, String)]) -> bool {
912 let buf = frm.get_buffer();
913 let cbuf = if let NABufferType::None = buf {
914 if (encoder.get_capabilities() & ENC_CAPS_SKIPFRAME) == 0 {
916 OutputConvert::Video(_, ref mut dbuf) => dbuf.clone(),
918 println!("encoder does not support skip frames, skipping");
927 OutputConvert::None => buf,
928 OutputConvert::Video(ref mut scaler, ref mut dbuf) => {
929 let cur_ifmt = get_scale_fmt_from_pic(&buf);
930 let last_ifmt = scaler.get_in_fmt();
931 if cur_ifmt != last_ifmt {
932 let ofmt = scaler.get_out_fmt();
933 let ret = NAScale::new_with_options(cur_ifmt, ofmt, scale_opts);
935 println!("error re-initialising scaler for {} -> {}", cur_ifmt, ofmt);
938 *scaler = ret.unwrap();
940 let ret = scaler.convert(&buf, dbuf);
942 println!("error converting frame for encoding");
947 OutputConvert::Audio(ref mut acvt) => {
948 if !acvt.queue_frame(buf, frm.get_time_information()) {
949 println!("error converting audio for stream {}", dst_id);
956 let cfrm = NAFrame::new(frm.get_time_information(), frm.frame_type, frm.key, frm.get_info(), cbuf);
957 encoder.encode(&cfrm).unwrap();
961 macro_rules! next_arg {
962 ($args: expr, $arg_idx: expr) => {
963 if $arg_idx + 1 >= $args.len() {
964 println!("codec name is required");
970 macro_rules! parse_id {
971 ($val: expr, $stype: expr, $maxval: expr) => {
974 } else if let Ok(val) = $val.parse::<usize>() {
978 println!("{} number should be below {}", $stype, $maxval);
982 println!("invalid {} number '{}'", $stype, $val);
988 #[allow(clippy::single_match)]
990 let args: Vec<_> = env::args().collect();
993 println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
994 println!(" use nihav-encoder --help to list all available options");
997 if args.len() == 2 && (args[1] == "--help" || args[1] == "-h") {
998 println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
999 println!(" query options:");
1000 println!(" --list-{{decoders,encoders,demuxers,muxers}} - lists all available decoders/encoders/demuxers/muxers");
1001 println!(" --query-{{decoder,encoder,demuxer,muxer}}-options name - lists all options recognized by that decoder/encoder/demuxer/muxer");
1002 println!(" processing options:");
1003 println!(" --verbose - show time for the currently processed input");
1004 println!(" --input inputfile - set input file");
1005 println!(" --input-format fmt - force input format");
1006 println!(" --demuxer-options options - set input demuxer options");
1007 println!(" --scale-options options - set scaler options");
1008 println!(" --output outputfile - set output file");
1009 println!(" --output-format fmt - force output format");
1010 println!(" --muxer-options options - set output muxer options");
1011 println!(" --no-audio - do not decode audio streams");
1012 println!(" --no-video - do not decode video streams");
1013 println!(" --start starttime - start decoding from given position");
1014 println!(" --end endtime - end decoding at given position");
1015 println!(" --istreamX options - set options for input stream X");
1016 println!(" --ostreamX options - set options for output stream X");
1018 println!(" (de)muxer and stream options are passed as comma-separated list e.g. --ostream0 width=320,height=240,flip");
1022 let full_reg = FullRegister::new();
1024 let mut transcoder = Transcoder::new();
1026 let mut arg_idx = 1;
1027 let mut printed_info = false;
1028 while arg_idx < args.len() {
1029 match args[arg_idx].as_str() {
1030 "--list-decoders" => {
1031 if full_reg.dec_reg.iter().len() > 0 {
1032 println!("Registered decoders:");
1033 for dec in full_reg.dec_reg.iter() {
1034 let cdesc = register::get_codec_description(dec.name);
1035 let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
1036 println!(" {} ({})", dec.name, full_name);
1039 println!("No registered decoders.");
1041 printed_info = true;
1043 "--list-encoders" => {
1044 if full_reg.enc_reg.iter().len() > 0 {
1045 println!("Registered encoders:");
1046 for enc in full_reg.enc_reg.iter() {
1047 let cdesc = register::get_codec_description(enc.name);
1048 let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
1049 println!(" {} ({})", enc.name, full_name);
1052 println!("No registered encoders.");
1054 printed_info = true;
1056 "--list-demuxers" => {
1057 print!("Registered demuxers:");
1058 for dmx in full_reg.dmx_reg.iter() {
1059 print!(" {}", dmx.get_name());
1062 printed_info = true;
1064 "--list-muxers" => {
1065 print!("Registered muxers:");
1066 for mux in full_reg.mux_reg.iter() {
1067 print!(" {}", mux.get_name());
1070 printed_info = true;
1072 "--query-decoder-options" => {
1073 next_arg!(args, arg_idx);
1074 let cname = args[arg_idx].as_str();
1075 if let Some(decfunc) = full_reg.dec_reg.find_decoder(cname) {
1076 let dec = (decfunc)();
1077 let opts = dec.get_supported_options();
1078 print_options(cname, opts);
1080 println!("codec {} is not found", cname);
1082 printed_info = true;
1084 "--query-demuxer-options" => {
1085 next_arg!(args, arg_idx);
1086 let dname = args[arg_idx].as_str();
1087 let mut mr = MemoryReader::new_read(&[]);
1088 let mut br = ByteReader::new(&mut mr);
1089 if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) {
1090 let dmx = dmx_creator.new_demuxer(&mut br);
1091 let opts = dmx.get_supported_options();
1092 print_options(dname, opts);
1094 println!("demuxer {} is not found", dname);
1096 printed_info = true;
1098 "--query-encoder-options" => {
1099 next_arg!(args, arg_idx);
1100 let cname = args[arg_idx].as_str();
1101 if let Some(encfunc) = full_reg.enc_reg.find_encoder(cname) {
1102 let enc = (encfunc)();
1103 let opts = enc.get_supported_options();
1104 print_options(cname, opts);
1106 println!("codec {} is not found", cname);
1108 printed_info = true;
1110 "--query-muxer-options" => {
1111 next_arg!(args, arg_idx);
1112 let name = args[arg_idx].as_str();
1114 let mut mw = MemoryWriter::new_write(&mut data);
1115 let mut bw = ByteWriter::new(&mut mw);
1116 if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) {
1117 let mux = mux_creator.new_muxer(&mut bw);
1118 let opts = mux.get_supported_options();
1119 print_options(name, opts);
1121 println!("muxer {} is not found", name);
1123 printed_info = true;
1125 "--output" | "-o" => {
1126 next_arg!(args, arg_idx);
1127 transcoder.output_name = args[arg_idx].clone();
1129 "--output-format" => {
1130 next_arg!(args, arg_idx);
1131 transcoder.output_fmt = Some(args[arg_idx].clone());
1133 "--scale-options" => {
1134 next_arg!(args, arg_idx);
1135 if !transcoder.parse_scale_options(&args[arg_idx]) {
1136 println!("invalid scale option syntax");
1140 "--no-video" | "-vn" => {
1141 transcoder.no_video = true;
1143 "--no-audio" | "-an" => {
1144 transcoder.no_audio = true;
1147 next_arg!(args, arg_idx);
1148 let ret = args[arg_idx].parse::<NATimePoint>();
1149 if let Ok(val) = ret {
1150 transcoder.start = val;
1152 println!("invalid start time");
1157 next_arg!(args, arg_idx);
1158 let ret = args[arg_idx].parse::<NATimePoint>();
1159 if let Ok(val) = ret {
1160 transcoder.end = val;
1162 println!("invalid end time");
1166 "--muxer-options" => {
1167 next_arg!(args, arg_idx);
1168 if !transcoder.parse_muxer_options(&args[arg_idx], &full_reg.mux_reg) {
1169 println!("invalid muxer option syntax");
1174 transcoder.calc_len = true;
1176 "--verbose" | "-v" => transcoder.verbose = 1,
1177 "-vv" => transcoder.verbose = 2,
1178 "-v-" => transcoder.verbose = 0,
1180 if args[arg_idx].starts_with("--istream") {
1181 let opt0 = &args[arg_idx];
1182 next_arg!(args, arg_idx);
1183 if !transcoder.parse_istream_options(opt0, &args[arg_idx]) {
1184 println!("invalid input stream option syntax");
1187 } else if args[arg_idx].starts_with("--ostream") {
1188 let opt0 = &args[arg_idx];
1189 next_arg!(args, arg_idx);
1190 if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &full_reg.enc_reg) {
1191 println!("invalid output stream option syntax");
1194 } else if args[arg_idx].starts_with("--input-format") {
1195 let id = parse_id!(&args[arg_idx][14..], "input format", transcoder.input_fmt.len());
1196 next_arg!(args, arg_idx);
1197 transcoder.input_fmt[id] = Some(args[arg_idx].clone());
1198 } else if args[arg_idx].starts_with("--input") { // should be after --input-format
1199 let id = parse_id!(&args[arg_idx][7..], "input", transcoder.input_name.len());
1200 next_arg!(args, arg_idx);
1201 transcoder.input_name[id] = Some(args[arg_idx].clone());
1202 } else if args[arg_idx].starts_with("-i") {
1203 let id = parse_id!(&args[arg_idx][2..], "input", transcoder.input_name.len());
1204 next_arg!(args, arg_idx);
1205 transcoder.input_name[id] = Some(args[arg_idx].clone());
1206 } else if args[arg_idx].starts_with("--demuxer-options") {
1207 let id = parse_id!(&args[arg_idx][17..], "input options", transcoder.demux_opts.len());
1208 next_arg!(args, arg_idx);
1209 if !transcoder.parse_demuxer_options(&args[arg_idx], &full_reg.dmx_reg, id) {
1210 println!("invalid demuxer option syntax");
1213 } else if args[arg_idx].starts_with("--") {
1214 println!("unknown option '{}'", args[arg_idx]);
1216 println!("unrecognized argument '{}'", args[arg_idx]);
1227 if transcoder.input_name.iter().flatten().count() == 0 {
1228 println!("no input name(s) provided");
1231 if transcoder.output_name.is_empty() {
1232 println!("no output name provided");
1236 let mut demuxers = Vec::with_capacity(1);
1237 if !transcoder.create_demuxers(&mut demuxers, &full_reg, true) {
1241 let duration = demuxers.iter().fold(0u64, |mindur, (dmx, _)| {
1242 let dur = dmx.get_duration();
1249 let duration_string = if duration != 0 { format_time(duration) } else { String::new() };
1251 let mut ism = StreamManager::new();
1252 let mut is_offset = Vec::with_capacity(demuxers.len());
1254 let mut nstreams = 0;
1255 for (dmx, _) in demuxers.iter() {
1256 is_offset.push(nstreams);
1257 let sm = dmx.get_stream_manager();
1258 let max_id = sm.iter().fold(0u32, |id, strm| id.max(strm.id));
1259 for stream in sm.iter() {
1260 let mut newstream = (*stream).clone();
1261 newstream.id += start;
1262 ism.add_stream(newstream);
1264 start += max_id + 1;
1265 nstreams += sm.get_num_streams();
1268 for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
1269 for i in 0..dmx.get_num_streams() {
1270 let s = dmx.get_stream(i).unwrap();
1271 let info = s.get_info();
1272 let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
1273 let str_id = (s.get_num() + is_off) as u32;
1274 if let Some(create_dec) = decfunc {
1275 let mut dec = (create_dec)();
1276 let mut dsupp = Box::new(NADecoderSupport::new());
1277 let ret = dec.init(&mut dsupp, info.clone());
1279 println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
1282 transcoder.apply_decoder_options(dec.as_mut(), str_id);
1283 let desc = register::get_codec_description(info.get_name());
1284 let has_b = if let Some(desc) = desc {
1287 println!("No codec description found, using B-frame reorderer.");
1290 let reord: Box<dyn FrameReorderer> = if has_b { Box::new(IPBReorderer::new()) } else { Box::new(NoReorderer::new()) };
1291 transcoder.decoders.push(Some((dsupp, dec, reord)));
1293 println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
1294 transcoder.decoders.push(None);
1297 if transcoder.start != NATimePoint::None {
1298 let ret = dmx.seek(transcoder.start);
1300 println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
1305 let output_fmt = if let Some(ref fmtname) = transcoder.output_fmt {
1307 } else if transcoder.output_name.as_str() == "/dev/null" {
1309 } else if let Some(fmtname) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
1312 println!("Cannot guess muxer for output");
1315 let ret = full_reg.mux_reg.find_muxer(output_fmt);
1316 let ofmt = output_fmt.to_string();
1319 println!("cannot find muxer '{}'", output_fmt);
1322 let mux_creator = ret.unwrap();
1324 if transcoder.calc_len {
1325 let mut sids = Vec::new();
1326 transcoder.nframes.clear();
1327 for (dmx, _) in demuxers.iter_mut() {
1328 let sstart = transcoder.nframes.len();
1329 let sm = dmx.get_stream_manager();
1331 for stream in sm.iter() {
1332 transcoder.nframes.push(0);
1333 sids.push(stream.get_id());
1336 while let Ok(pkt) = dmx.get_frame() {
1337 let stream = pkt.get_stream();
1338 let pos = sstart + sids.iter().position(|&x| x == stream.get_id()).unwrap();
1339 transcoder.nframes[pos] += 1;
1342 // this is necessary since not all demuxers allow to seek even back to the start
1344 if !transcoder.create_demuxers(&mut demuxers, &full_reg, false) {
1345 println!("failed to re-create demuxer(s)");
1350 let mux_caps = mux_creator.get_capabilities();
1351 let mut out_sm = StreamManager::new();
1352 if !transcoder.negotiate_stream_map(&ism, mux_caps, &mut out_sm, &full_reg.enc_reg) {
1353 println!("cannot determine stream map");
1357 let ret = File::create(transcoder.output_name.as_str());
1359 println!("cannot open output file");
1362 let mut fw = FileWriter::new_write(ret.unwrap());
1363 let mut bw = ByteWriter::new(&mut fw);
1364 let ret = create_muxer(mux_creator, out_sm, &mut bw);
1365 if let Err(err) = ret {
1366 println!("cannot create muxer instance {:?}", err);
1369 let mut mux = ret.unwrap();
1370 parse_and_apply_options!(mux, &transcoder.mux_opts, "output");
1372 println!("Output {} muxer {}", transcoder.output_name, ofmt);
1373 for ostr in mux.get_streams() {
1374 println!(" #{}: {} {}", ostr.get_num(), ostr, ostr.get_info().get_name());
1377 let mut time = Instant::now();
1378 let show_interval = Duration::from_millis(100);
1379 let mut adata_size = 0;
1380 let mut vdata_size = 0;
1381 let mut cur_dmx = 0;
1383 let mut pktres = Err(DemuxerError::EOF);
1384 let mut src_dmx = 0;
1386 if !demuxers.iter().any(|(_, eof)| !eof) {
1389 let mut got_res = false;
1390 if !demuxers[cur_dmx].1 {
1391 pktres = demuxers[cur_dmx].0.get_frame();
1396 if cur_dmx >= demuxers.len() {
1404 if let Err(DemuxerError::EOF) = pktres { break; }
1405 if pktres.is_err() {
1406 println!("demuxing error");
1409 let mut pkt = pktres.unwrap();
1410 if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; }
1411 let src_id = pkt.get_stream().get_num() + is_offset[src_dmx];
1413 let newstream = ism.get_stream(src_id).unwrap();
1414 pkt.reassign(newstream, ts);
1416 if transcoder.verbose > 0 && time.elapsed() >= show_interval {
1417 if let Some(pts) = pkt.get_pts() {
1418 let cur_time = format_time(NATimeInfo::ts_to_time(pts, 1000, pkt.ts.tb_num, pkt.ts.tb_den));
1419 print!(" {}", cur_time);
1423 if !duration_string.is_empty() {
1424 print!(" / {}", duration_string);
1426 if transcoder.verbose > 1 {
1427 print!(" data sizes V: {} A: {}", vdata_size, adata_size);
1430 std::io::stdout().flush().unwrap();
1431 time = Instant::now();
1433 match transcoder.encoders[src_id] {
1434 OutputMode::Drop => {},
1435 OutputMode::Copy(dst_id) => {
1436 let dstr = mux.get_stream(dst_id as usize).unwrap();
1437 pkt.reassign(dstr, pkt.get_time_information());
1438 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1439 let pkt_size = pkt.get_buffer().len();
1440 match pkt.get_stream().get_media_type() {
1441 StreamType::Video => { vdata_size += pkt_size; },
1442 StreamType::Audio => { adata_size += pkt_size; },
1445 if mux.mux_frame(pkt).is_err() {
1446 println!("error muxing packet");
1450 OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) => {
1451 if let Some((ref mut dsupp, ref mut decoder, ref mut reorderer)) = transcoder.decoders[src_id] {
1452 let ret = decoder.decode(dsupp, &pkt);
1453 if let (true, Err(DecoderError::MissingReference)) = (transcoder.start != NATimePoint::None, &ret) {
1457 println!("error decoding stream {}", src_id);
1460 let frm = ret.unwrap();
1461 let tinfo = frm.get_info();
1462 reorderer.add_frame(frm);
1463 while let Some(frm) = reorderer.get_frame() {
1464 if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1467 while let Ok(Some(pkt)) = encoder.get_packet() {
1468 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1469 let pkt_size = pkt.get_buffer().len();
1470 match pkt.get_stream().get_media_type() {
1471 StreamType::Video => { vdata_size += pkt_size; },
1472 StreamType::Audio => { adata_size += pkt_size; },
1475 mux.mux_frame(pkt).unwrap();
1478 if let OutputConvert::Audio(ref mut acvt) = cvt {
1479 while let Some(ofrm) = acvt.get_frame(tinfo.clone()) {
1480 if encoder.encode(&ofrm).is_err() {
1483 while let Ok(Some(pkt)) = encoder.get_packet() {
1484 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1485 let pkt_size = pkt.get_buffer().len();
1486 adata_size += pkt_size;
1487 mux.mux_frame(pkt).unwrap();
1492 println!("no decoder for stream {}", src_id);
1498 'reord_flush_loop: for stream in ism.iter() {
1499 let src_id = stream.get_num();
1500 if let OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) = transcoder.encoders[src_id] {
1501 if let Some((_, _, ref mut reorderer)) = transcoder.decoders[src_id] {
1502 while let Some(frm) = reorderer.get_last_frames() {
1503 if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1506 while let Ok(Some(pkt)) = encoder.get_packet() {
1507 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'reord_flush_loop; }
1508 mux.mux_frame(pkt).unwrap();
1514 'flush_loop: for enc in transcoder.encoders.iter_mut() {
1516 OutputMode::Encode(str_id, ref mut encoder, _) => {
1517 let ret = encoder.flush();
1519 println!("error flushing encoder for stream {}", str_id);
1522 while let Ok(Some(pkt)) = encoder.get_packet() {
1523 if mux.mux_frame(pkt).is_err() {
1524 println!("error muxing packet");
1533 if transcoder.verbose > 0 {
1537 let ret = mux.end();
1539 println!("error at finalising muxing");