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>,
192 global_tb: (u32, u32),
195 macro_rules! parse_and_apply_options {
196 ($obj: expr, $in_opts: expr, $name: expr) => {
197 let mut opts = Vec::with_capacity($in_opts.len());
198 let opt_def = $obj.get_supported_options();
199 for opt in $in_opts.iter() {
200 let mut found = false;
201 for opt_def in opt_def.iter() {
202 let mut matches = opt.name == opt_def.name;
203 if !matches && opt.name.starts_with("no") {
204 let (_, name) = opt.name.split_at(2);
205 matches = name == opt_def.name;
208 let arg = if let Some(ref strval) = opt.value { Some(strval) } else { None };
209 let ret = opt_def.parse(&opt.name, arg);
210 if let Ok((val, _)) = ret {
213 println!("invalid option {} for {}", opt.name, $name);
219 println!(" ignoring option '{}' for {}", opt.name, $name);
222 $obj.set_options(opts.as_slice());
227 fn new() -> Self { Self::default() }
228 fn parse_istream_options(&mut self, opt0: &str, opt1: &str) -> bool {
229 let (_, strno) = opt0.split_at(9);
230 let ret = strno.parse::<u32>();
231 if ret.is_err() { return false; }
232 let streamno = ret.unwrap();
234 let sidx = if let Some(idx) = self.istr_opts.iter().position(|el| el.id == streamno) {
237 self.istr_opts.push(InputStreamOptions {id: streamno, drop: false, dec_opts: Vec::new() });
238 self.istr_opts.len() - 1
240 let istr = &mut self.istr_opts[sidx];
242 for opt in opt1.split(',') {
243 let oval: Vec<_> = opt.split('=').collect();
246 "drop" => { istr.drop = true; },
248 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
251 } else if oval.len() == 2 {
252 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
254 println!("unrecognized option '{}'", opt);
259 fn parse_ostream_options(&mut self, opt0: &str, opt1: &str, enc_reg: &RegisteredEncoders) -> bool {
260 let (_, strno) = opt0.split_at(9);
261 let ret = strno.parse::<u32>();
262 if ret.is_err() { return false; }
263 let streamno = ret.unwrap();
265 let sidx = if let Some(idx) = self.ostr_opts.iter().position(|el| el.id == streamno) {
268 self.ostr_opts.push(OutputStreamOptions {id: streamno, enc_name: String::new(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() });
269 self.ostr_opts.len() - 1
271 let ostr = &mut self.ostr_opts[sidx];
273 for opt in opt1.split(',') {
274 let oval: Vec<_> = opt.split('=').collect();
278 if ostr.enc_params.format == NACodecTypeInfo::None {
279 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
281 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
282 vinfo.flipped = true;
284 println!("video option for audio stream");
288 if ostr.enc_params.format == NACodecTypeInfo::None {
289 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
291 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
292 vinfo.flipped = false;
294 println!("video option for audio stream");
298 ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
301 } else if oval.len() == 2 {
302 //todo parse encoder options, store, init later
305 let mut parts = oval[1].split('/');
306 let num = parts.next().unwrap();
307 let den = parts.next();
308 if let Some(den) = den {
309 let rnum = num.parse::<u32>();
310 let rden = den.parse::<u32>();
311 if let (Ok(num), Ok(den)) = (rnum, rden) {
312 ostr.enc_params.tb_num = num;
313 ostr.enc_params.tb_den = den;
315 println!("invalid timebase value");
318 println!("invalid timebase format (should be num/den)");
322 if enc_reg.find_encoder(oval[1]).is_some() {
323 ostr.enc_name = oval[1].to_string();
325 println!("unknown encoder '{}'", oval[1]);
326 ostr.enc_name = oval[1].to_string();
330 if ostr.enc_params.format == NACodecTypeInfo::None {
331 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
333 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
334 let ret = oval[1].parse::<usize>();
335 if let Ok(val) = ret {
338 println!("invalid width");
341 println!("video option for audio stream");
345 if ostr.enc_params.format == NACodecTypeInfo::None {
346 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
348 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
349 let ret = oval[1].parse::<usize>();
350 if let Ok(val) = ret {
353 println!("invalid height");
356 println!("video option for audio stream");
360 if ostr.enc_params.format == NACodecTypeInfo::None {
361 ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
363 if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
364 let ret = oval[1].parse::<NAPixelFormaton>();
365 if let Ok(val) = ret {
368 println!("invalid pixel format");
371 println!("video option for audio stream");
375 if ostr.enc_params.format == NACodecTypeInfo::None {
376 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
378 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
379 let ret = oval[1].parse::<u32>();
380 if let Ok(val) = ret {
381 ainfo.sample_rate = val;
383 println!("invalid sampling rate");
386 println!("audio option for video stream");
390 if ostr.enc_params.format == NACodecTypeInfo::None {
391 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
393 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
394 let ret = oval[1].parse::<u8>();
395 if let Ok(val) = ret {
396 ainfo.channels = val;
398 println!("invalid number of channels");
401 println!("audio option for video stream");
405 if ostr.enc_params.format == NACodecTypeInfo::None {
406 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
408 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
409 let ret = oval[1].parse::<usize>();
410 if let Ok(val) = ret {
411 ainfo.block_len = val;
413 println!("invalid block_length");
416 println!("audio option for video stream");
420 if ostr.enc_params.format == NACodecTypeInfo::None {
421 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
423 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
424 let ret = oval[1].parse::<NASoniton>();
425 if let Ok(val) = ret {
428 println!("invalid audio format");
431 println!("audio option for video stream");
434 // todo channel map negotiation
436 if ostr.enc_params.format == NACodecTypeInfo::None {
437 ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
439 if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
440 let ret = oval[1].parse::<NAChannelMap>();
441 if let Ok(val) = ret {
444 println!("invalid channel map");
447 println!("audio option for video stream");
451 let ret = parse_bitrate(oval[1]);
452 if let Ok(val) = ret {
453 ostr.enc_params.bitrate = val;
455 println!("invalid bitrate value");
459 let ret = oval[1].parse::<u8>();
460 if let Ok(val) = ret {
461 ostr.enc_params.quality = val;
463 println!("invalid quality value");
467 ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
471 println!("unrecognized option '{}'", opt);
476 fn parse_demuxer_options(&mut self, opts: &str, dmx_reg: &RegisteredDemuxers, input_no: usize) -> bool {
477 for opt in opts.split(',') {
478 let oval: Vec<_> = opt.split('=').collect();
480 self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: None });
481 } else if oval.len() == 2 {
482 if oval[0] == "format" {
483 if dmx_reg.find_demuxer(oval[1]).is_some() {
484 self.input_fmt[input_no] = Some(oval[1].to_string());
486 println!("unknown demuxer format '{}'", oval[1]);
489 self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
492 println!("unrecognized option '{}'", opt);
497 fn parse_muxer_options(&mut self, opts: &str, mux_reg: &RegisteredMuxers) -> bool {
498 for opt in opts.split(',') {
499 let oval: Vec<_> = opt.split('=').collect();
501 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
502 } else if oval.len() == 2 {
503 if oval[0] == "format" {
504 if mux_reg.find_muxer(oval[1]).is_some() {
505 self.output_fmt = Some(oval[1].to_string());
507 println!("unknown muxer format '{}'", oval[1]);
510 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
513 println!("unrecognized option '{}'", opt);
518 fn parse_scale_options(&mut self, opts: &str) -> bool {
519 for opt in opts.split(',') {
520 let oval: Vec<_> = opt.split('=').collect();
522 self.scale_opts.push((oval[0].to_string(), "".to_string()));
523 } else if oval.len() == 2 {
524 self.scale_opts.push((oval[0].to_string(), oval[1].to_string()));
526 println!("unrecognized option '{}'", opt);
532 fn apply_decoder_options(&self, dec: &mut dyn NADecoder, str_id: u32) {
533 if let Some(str_idx) = self.istr_opts.iter().position(|el| el.id == str_id) {
534 let dec_opts = dec.get_supported_options();
535 if dec_opts.is_empty() { return; }
536 let name = format!("input stream {}", str_id);
537 parse_and_apply_options!(dec, &self.istr_opts[str_idx].dec_opts, name);
540 fn register_output_stream(&mut self, cname: &str, istr: NAStreamRef, iidx: usize, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> RegisterResult {
541 let out_id = out_sm.get_num_streams() as u32;
542 if let Some(str_idx) = self.istr_opts.iter().position(|el| el.id == (istr.get_num() as u32)) {
543 if self.istr_opts[str_idx].drop {
544 self.encoders.push(OutputMode::Drop);
545 return RegisterResult::Ignored;
549 if let Some(str_idx) = self.ostr_opts.iter().position(|el| el.id == out_id) {
550 let oopts = &mut self.ostr_opts[str_idx];
551 if oopts.enc_name.as_str() == "copy" && (cname == "any" || istr.get_info().get_name() == cname) {
552 out_sm.add_stream((*istr).clone());
553 self.encoders.push(OutputMode::Copy(out_id));
554 } else if cname == "any" || oopts.enc_name.as_str() == cname {
555 let enc_create = enc_reg.find_encoder(oopts.enc_name.as_str());
556 if enc_create.is_none() {
557 println!("encoder '{}' not found", oopts.enc_name.as_str());
558 return RegisterResult::Failed;
560 let mut encoder = (enc_create.unwrap())();
561 let forced_out = oopts.enc_params.format != NACodecTypeInfo::None;
562 let iformat = istr.get_info().get_properties();
563 if oopts.enc_params.format == NACodecTypeInfo::None {
564 oopts.enc_params.format = istr.get_info().get_properties();
566 match (&iformat, &mut oopts.enc_params.format) {
567 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(ref mut dvinfo)) => {
568 if dvinfo.width == 0 {
569 dvinfo.width = svinfo.width;
571 if dvinfo.height == 0 {
572 dvinfo.height = svinfo.height;
575 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(ref mut dainfo)) => {
576 if dainfo.sample_rate == 0 {
577 dainfo.sample_rate = sainfo.sample_rate;
579 if dainfo.format == SND_NO_FORMAT {
580 dainfo.format = sainfo.format;
582 if dainfo.channels == 0 {
583 dainfo.channels = sainfo.channels;
585 if dainfo.block_len == 0 {
586 dainfo.block_len = sainfo.block_len;
592 if self.global_tb != (0, 0) {
593 oopts.enc_params.tb_num = self.global_tb.0;
594 oopts.enc_params.tb_den = self.global_tb.1;
596 if oopts.enc_params.tb_num == 0 {
597 oopts.enc_params.tb_num = istr.tb_num;
598 oopts.enc_params.tb_den = istr.tb_den;
600 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
601 if ret_eparams.is_err() {
602 println!("cannot negotiate encoding parameters");
603 return RegisterResult::Failed;
605 let ret_eparams = ret_eparams.unwrap();
607 //todo check for params mismatch
608 let cvt = match (&iformat, &ret_eparams.format) {
609 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
610 if svinfo == dvinfo && !forced_out {
613 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
614 let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
616 println!("cannot create scaler");
617 return RegisterResult::Failed;
619 let scaler = ret.unwrap();
620 let ret = alloc_video_buffer(*dvinfo, 4);
622 println!("cannot create scaler buffer");
623 return RegisterResult::Failed;
625 let cvt_buf = ret.unwrap();
626 OutputConvert::Video(scaler, cvt_buf)
629 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
630 let icodec = istr.get_info().get_name();
631 if (sainfo == dainfo) && (icodec != "pcm" || oopts.enc_name.as_str() == "pcm") {
634 let dchmap = match dainfo.channels {
635 1 => NAChannelMap::from_ms_mapping(0x4),
636 2 => NAChannelMap::from_ms_mapping(0x3),
638 println!("can't generate default channel map for {} channels", dainfo.channels);
639 return RegisterResult::Failed;
642 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
644 OutputConvert::Audio(acvt)
647 _ => OutputConvert::None,
649 let name = format!("output stream {}", out_id);
650 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
652 if self.calc_len && self.nframes.len() > iidx {
653 encoder.set_options(&[NAOption{name: "nframes", value: NAValue::Int(self.nframes[iidx] as i64)}]);
656 let ret = encoder.init(out_id, ret_eparams);
658 println!("error initialising encoder");
659 return RegisterResult::Failed;
661 out_sm.add_stream_ref(ret.unwrap());
663 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
665 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
667 println!("encoder {} is not supported by output (expected {})", istr.id, istr.get_info().get_name());
668 return RegisterResult::Failed;
670 } else if cname == "any" || istr.get_info().get_name() == cname {
671 out_sm.add_stream((*istr).clone());
672 self.encoders.push(OutputMode::Copy(out_id));
674 let mut oopts = OutputStreamOptions {id: out_id, enc_name: cname.to_owned(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() };
676 let enc_create = enc_reg.find_encoder(cname);
677 if enc_create.is_none() {
678 println!("encoder '{}' not found", oopts.enc_name.as_str());
679 return RegisterResult::Failed;
681 let mut encoder = (enc_create.unwrap())();
682 oopts.enc_params.format = istr.get_info().get_properties();
683 if self.global_tb != (0, 0) {
684 oopts.enc_params.tb_num = self.global_tb.0;
685 oopts.enc_params.tb_den = self.global_tb.1;
687 oopts.enc_params.tb_num = istr.tb_num;
688 oopts.enc_params.tb_den = istr.tb_den;
690 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
691 if ret_eparams.is_err() {
692 println!("cannot negotiate encoding parameters");
693 return RegisterResult::Failed;
695 let ret_eparams = ret_eparams.unwrap();
697 //todo check for params mismatch
698 let cvt = match (&oopts.enc_params.format, &ret_eparams.format) {
699 (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
700 if svinfo == dvinfo {
703 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
704 let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
706 println!("cannot create scaler");
707 return RegisterResult::Failed;
709 let scaler = ret.unwrap();
710 let ret = alloc_video_buffer(*dvinfo, 4);
712 println!("cannot create scaler buffer");
713 return RegisterResult::Failed;
715 let cvt_buf = ret.unwrap();
716 OutputConvert::Video(scaler, cvt_buf)
719 (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
720 if sainfo == dainfo {
723 let dchmap = match dainfo.channels {
724 1 => NAChannelMap::from_ms_mapping(0x4),
725 2 => NAChannelMap::from_ms_mapping(0x3),
727 println!("can't generate default channel map for {} channels", dainfo.channels);
728 return RegisterResult::Failed;
732 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
733 OutputConvert::Audio(acvt)
736 _ => OutputConvert::None,
738 let ret = encoder.init(out_id, ret_eparams);
740 println!("error initialising encoder");
741 return RegisterResult::Failed;
743 out_sm.add_stream_ref(ret.unwrap());
744 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
745 self.ostr_opts.push(oopts);
749 fn map_single(&mut self, cname: &str, ctype: StreamType, src_sm: &StreamManager, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
750 let mut found_stream = false;
751 for (iidx, istr) in src_sm.iter().enumerate() {
752 if istr.get_media_type() != ctype || found_stream {
753 self.encoders.push(OutputMode::Drop);
755 match self.register_output_stream(cname, istr, iidx, out_sm, enc_reg) {
756 RegisterResult::Ok => found_stream = true,
757 RegisterResult::Failed => return false,
758 RegisterResult::Ignored => {},
764 fn negotiate_stream_map(&mut self, src_sm: &StreamManager, mux_caps: MuxerCapabilities, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
766 MuxerCapabilities::SingleVideo(cname) => {
767 if self.no_video { return false; }
768 self.map_single(cname, StreamType::Video, src_sm, out_sm, enc_reg)
770 MuxerCapabilities::SingleAudio(cname) => {
771 if self.no_audio { return false; }
772 self.map_single(cname, StreamType::Audio, src_sm, out_sm, enc_reg)
774 MuxerCapabilities::SingleVideoAndAudio(vname, aname) => {
775 let mut found_vid = false;
776 let mut found_aud = false;
777 for (iidx, istr) in src_sm.iter().enumerate() {
778 if istr.get_media_type() == StreamType::Video && !found_vid && !self.no_video {
779 match self.register_output_stream(vname, istr, iidx, out_sm, enc_reg) {
780 RegisterResult::Ok => found_vid = true,
781 RegisterResult::Failed => return false,
782 RegisterResult::Ignored => {},
784 } else if istr.get_media_type() == StreamType::Audio && !found_aud && !self.no_audio {
785 match self.register_output_stream(aname, istr, iidx, out_sm, enc_reg) {
786 RegisterResult::Ok => found_aud = true,
787 RegisterResult::Failed => return false,
788 RegisterResult::Ignored => {},
791 self.encoders.push(OutputMode::Drop);
794 found_vid | found_aud
796 MuxerCapabilities::OnlyVideo => {
797 if self.no_video { return false; }
799 let mut found_vid = false;
800 for (iidx, istr) in src_sm.iter().enumerate() {
801 if istr.get_media_type() == StreamType::Video {
802 match self.register_output_stream("any", istr, iidx, out_sm, enc_reg) {
803 RegisterResult::Ok => found_vid = true,
804 RegisterResult::Failed => return false,
805 RegisterResult::Ignored => {},
808 self.encoders.push(OutputMode::Drop);
813 MuxerCapabilities::OnlyAudio => {
814 if self.no_audio { return false; }
816 let mut found_aud = false;
817 for (iidx, istr) in src_sm.iter().enumerate() {
818 if istr.get_media_type() == StreamType::Audio {
819 match self.register_output_stream("any", istr, iidx, out_sm, enc_reg) {
820 RegisterResult::Ok => found_aud = true,
821 RegisterResult::Failed => return false,
822 RegisterResult::Ignored => {},
825 self.encoders.push(OutputMode::Drop);
830 MuxerCapabilities::Universal => {
831 for (iidx, istr) in src_sm.iter().enumerate() {
832 if (istr.get_media_type() == StreamType::Video && self.no_video) ||
833 (istr.get_media_type() == StreamType::Audio && self.no_audio) {
834 self.encoders.push(OutputMode::Drop);
837 if self.register_output_stream("any", istr, iidx, out_sm, enc_reg) == RegisterResult::Failed {
845 fn create_demuxers(&mut self, demuxers: &mut Vec<(DemuxerObject, bool)>, full_reg: &FullRegister, print_info: bool) -> bool {
846 let mut isn_start = 0;
847 for (i, (iname, ifmt)) in self.input_name.iter().zip(
848 self.input_fmt.iter()).enumerate() {
849 match (iname, ifmt.as_ref().map(|s| s.as_str())) {
850 (Some(name), Some("imgseq")) => {
851 println!("trying image sequence {}", name);
852 let mut isdc = ImgSeqDemuxerCreator::new(name.as_str());
853 parse_and_apply_options!(isdc, &self.demux_opts[i], "input");
854 let isd = if let Ok(ctx) = isdc.open() {
857 println!("failed to create image sequence demuxer!");
860 let dmx = DemuxerObject::create_imgseq(isd);
862 for i in 0..dmx.get_num_streams() {
863 let s = dmx.get_stream(i).unwrap();
864 let info = s.get_info();
865 println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
868 isn_start += dmx.get_num_streams();
869 demuxers.push((dmx, false))
872 let res = File::open(name);
874 println!("error opening input");
877 let file = res.unwrap();
878 let file = BufReader::new(file);
879 let mut fr = FileReader::new_read(file);
880 let mut br = ByteReader::new(&mut fr);
881 let (is_raw, start, end) = if ifmt.is_none() {
887 let nfr: Box<dyn ByteIO> = if start != 0 || end.is_some() {
888 let file = fr.finish();
889 Box::new(BoundedFileReader::new_read(file, start, end).unwrap())
893 let sb = SelfBorrow::new(nfr, |rd| {
895 ByteReader::new(rd.as_mut().unwrap().as_mut())
899 let mut dmx = DemuxerObject::create(sb, full_reg, name, ifmt, is_raw, print_info);
901 println!("cannot find demuxer for '{}'", name);
904 parse_and_apply_options!(dmx, &self.demux_opts[i], "input");
906 for i in 0..dmx.get_num_streams() {
907 let s = dmx.get_stream(i).unwrap();
908 let info = s.get_info();
909 println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
912 isn_start += dmx.get_num_streams();
913 demuxers.push((dmx, false));
922 fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef, scale_opts: &[(String, String)]) -> bool {
923 let buf = frm.get_buffer();
924 let cbuf = if let NABufferType::None = buf {
925 if (encoder.get_capabilities() & ENC_CAPS_SKIPFRAME) == 0 {
927 OutputConvert::Video(_, ref mut dbuf) => dbuf.clone(),
929 println!("encoder does not support skip frames, skipping");
938 OutputConvert::None => buf,
939 OutputConvert::Video(ref mut scaler, ref mut dbuf) => {
940 let cur_ifmt = get_scale_fmt_from_pic(&buf);
941 let last_ifmt = scaler.get_in_fmt();
942 if cur_ifmt != last_ifmt {
943 let ofmt = scaler.get_out_fmt();
944 let ret = NAScale::new_with_options(cur_ifmt, ofmt, scale_opts);
946 println!("error re-initialising scaler for {} -> {}", cur_ifmt, ofmt);
949 *scaler = ret.unwrap();
951 let ret = scaler.convert(&buf, dbuf);
953 println!("error converting frame for encoding");
958 OutputConvert::Audio(ref mut acvt) => {
959 if !acvt.queue_frame(buf, frm.get_time_information()) {
960 println!("error converting audio for stream {}", dst_id);
967 let cfrm = NAFrame::new(frm.get_time_information(), frm.frame_type, frm.key, frm.get_info(), cbuf);
968 encoder.encode(&cfrm).unwrap();
972 macro_rules! next_arg {
973 ($args: expr, $arg_idx: expr) => {
974 if $arg_idx + 1 >= $args.len() {
975 println!("codec name is required");
981 macro_rules! parse_id {
982 ($val: expr, $stype: expr, $maxval: expr) => {
985 } else if let Ok(val) = $val.parse::<usize>() {
989 println!("{} number should be below {}", $stype, $maxval);
993 println!("invalid {} number '{}'", $stype, $val);
999 #[allow(clippy::single_match)]
1001 let args: Vec<_> = env::args().collect();
1003 if args.len() == 1 {
1004 println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
1005 println!(" use nihav-encoder --help to list all available options");
1008 if args.len() == 2 && (args[1] == "--help" || args[1] == "-h") {
1009 println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
1010 println!(" query options:");
1011 println!(" --list-{{decoders,encoders,demuxers,muxers}} - lists all available decoders/encoders/demuxers/muxers");
1012 println!(" --query-{{decoder,encoder,demuxer,muxer}}-options name - lists all options recognized by that decoder/encoder/demuxer/muxer");
1013 println!(" processing options:");
1014 println!(" --verbose - show time for the currently processed input");
1015 println!(" --input inputfile - set input file");
1016 println!(" --input-format fmt - force input format");
1017 println!(" --demuxer-options options - set input demuxer options");
1018 println!(" --scale-options options - set scaler options");
1019 println!(" --output outputfile - set output file");
1020 println!(" --output-format fmt - force output format");
1021 println!(" --muxer-options options - set output muxer options");
1022 println!(" --no-audio - do not decode audio streams");
1023 println!(" --no-video - do not decode video streams");
1024 println!(" --start starttime - start decoding from given position");
1025 println!(" --end endtime - end decoding at given position");
1026 println!(" --istreamX options - set options for input stream X");
1027 println!(" --ostreamX options - set options for output stream X");
1029 println!(" (de)muxer and stream options are passed as comma-separated list e.g. --ostream0 width=320,height=240,flip");
1033 let full_reg = FullRegister::new();
1035 let mut transcoder = Transcoder::new();
1036 let mut use_video_tb = false;
1038 let mut arg_idx = 1;
1039 let mut printed_info = false;
1040 while arg_idx < args.len() {
1041 match args[arg_idx].as_str() {
1042 "--list-decoders" => {
1043 if full_reg.dec_reg.iter().len() > 0 {
1044 println!("Registered decoders:");
1045 for dec in full_reg.dec_reg.iter() {
1046 let cdesc = register::get_codec_description(dec.name);
1047 let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
1048 println!(" {} ({})", dec.name, full_name);
1051 println!("No registered decoders.");
1053 printed_info = true;
1055 "--list-encoders" => {
1056 if full_reg.enc_reg.iter().len() > 0 {
1057 println!("Registered encoders:");
1058 for enc in full_reg.enc_reg.iter() {
1059 let cdesc = register::get_codec_description(enc.name);
1060 let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
1061 println!(" {} ({})", enc.name, full_name);
1064 println!("No registered encoders.");
1066 printed_info = true;
1068 "--list-demuxers" => {
1069 print!("Registered demuxers:");
1070 for dmx in full_reg.dmx_reg.iter() {
1071 print!(" {}", dmx.get_name());
1074 printed_info = true;
1076 "--list-muxers" => {
1077 print!("Registered muxers:");
1078 for mux in full_reg.mux_reg.iter() {
1079 print!(" {}", mux.get_name());
1082 printed_info = true;
1084 "--query-decoder-options" => {
1085 next_arg!(args, arg_idx);
1086 let cname = args[arg_idx].as_str();
1087 if let Some(decfunc) = full_reg.dec_reg.find_decoder(cname) {
1088 let dec = (decfunc)();
1089 let opts = dec.get_supported_options();
1090 print_options(cname, opts);
1092 println!("codec {} is not found", cname);
1094 printed_info = true;
1096 "--query-demuxer-options" => {
1097 next_arg!(args, arg_idx);
1098 let dname = args[arg_idx].as_str();
1099 let mut mr = MemoryReader::new_read(&[]);
1100 let mut br = ByteReader::new(&mut mr);
1101 if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) {
1102 let dmx = dmx_creator.new_demuxer(&mut br);
1103 let opts = dmx.get_supported_options();
1104 print_options(dname, opts);
1106 println!("demuxer {} is not found", dname);
1108 printed_info = true;
1110 "--query-encoder-options" => {
1111 next_arg!(args, arg_idx);
1112 let cname = args[arg_idx].as_str();
1113 if let Some(encfunc) = full_reg.enc_reg.find_encoder(cname) {
1114 let enc = (encfunc)();
1115 let opts = enc.get_supported_options();
1116 print_options(cname, opts);
1118 println!("codec {} is not found", cname);
1120 printed_info = true;
1122 "--query-muxer-options" => {
1123 next_arg!(args, arg_idx);
1124 let name = args[arg_idx].as_str();
1126 let mut mw = MemoryWriter::new_write(&mut data);
1127 let mut bw = ByteWriter::new(&mut mw);
1128 if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) {
1129 let mux = mux_creator.new_muxer(&mut bw);
1130 let opts = mux.get_supported_options();
1131 print_options(name, opts);
1133 println!("muxer {} is not found", name);
1135 printed_info = true;
1137 "--output" | "-o" => {
1138 next_arg!(args, arg_idx);
1139 transcoder.output_name = args[arg_idx].clone();
1141 "--output-format" => {
1142 next_arg!(args, arg_idx);
1143 transcoder.output_fmt = Some(args[arg_idx].clone());
1145 "--scale-options" => {
1146 next_arg!(args, arg_idx);
1147 if !transcoder.parse_scale_options(&args[arg_idx]) {
1148 println!("invalid scale option syntax");
1152 "--no-video" | "-vn" => {
1153 transcoder.no_video = true;
1155 "--no-audio" | "-an" => {
1156 transcoder.no_audio = true;
1159 next_arg!(args, arg_idx);
1160 let ret = args[arg_idx].parse::<NATimePoint>();
1161 if let Ok(val) = ret {
1162 transcoder.start = val;
1164 println!("invalid start time");
1169 next_arg!(args, arg_idx);
1170 let ret = args[arg_idx].parse::<NATimePoint>();
1171 if let Ok(val) = ret {
1172 transcoder.end = val;
1174 println!("invalid end time");
1178 "--muxer-options" => {
1179 next_arg!(args, arg_idx);
1180 if !transcoder.parse_muxer_options(&args[arg_idx], &full_reg.mux_reg) {
1181 println!("invalid muxer option syntax");
1186 transcoder.calc_len = true;
1188 "--use-video-tb" => {
1189 use_video_tb = true;
1191 "--verbose" | "-v" => transcoder.verbose = 1,
1192 "-vv" => transcoder.verbose = 2,
1193 "-v-" => transcoder.verbose = 0,
1195 if args[arg_idx].starts_with("--istream") {
1196 let opt0 = &args[arg_idx];
1197 next_arg!(args, arg_idx);
1198 if !transcoder.parse_istream_options(opt0, &args[arg_idx]) {
1199 println!("invalid input stream option syntax");
1202 } else if args[arg_idx].starts_with("--ostream") {
1203 let opt0 = &args[arg_idx];
1204 next_arg!(args, arg_idx);
1205 if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &full_reg.enc_reg) {
1206 println!("invalid output stream option syntax");
1209 } else if args[arg_idx].starts_with("--input-format") {
1210 let id = parse_id!(&args[arg_idx][14..], "input format", transcoder.input_fmt.len());
1211 next_arg!(args, arg_idx);
1212 transcoder.input_fmt[id] = Some(args[arg_idx].clone());
1213 } else if args[arg_idx].starts_with("--input") { // should be after --input-format
1214 let id = parse_id!(&args[arg_idx][7..], "input", transcoder.input_name.len());
1215 next_arg!(args, arg_idx);
1216 transcoder.input_name[id] = Some(args[arg_idx].clone());
1217 } else if args[arg_idx].starts_with("-i") {
1218 let id = parse_id!(&args[arg_idx][2..], "input", transcoder.input_name.len());
1219 next_arg!(args, arg_idx);
1220 transcoder.input_name[id] = Some(args[arg_idx].clone());
1221 } else if args[arg_idx].starts_with("--demuxer-options") {
1222 let id = parse_id!(&args[arg_idx][17..], "input options", transcoder.demux_opts.len());
1223 next_arg!(args, arg_idx);
1224 if !transcoder.parse_demuxer_options(&args[arg_idx], &full_reg.dmx_reg, id) {
1225 println!("invalid demuxer option syntax");
1228 } else if args[arg_idx].starts_with("--") {
1229 println!("unknown option '{}'", args[arg_idx]);
1231 println!("unrecognized argument '{}'", args[arg_idx]);
1242 if transcoder.input_name.iter().flatten().count() == 0 {
1243 println!("no input name(s) provided");
1246 if transcoder.output_name.is_empty() {
1247 println!("no output name provided");
1251 let mut demuxers = Vec::with_capacity(1);
1252 if !transcoder.create_demuxers(&mut demuxers, &full_reg, true) {
1256 let duration = demuxers.iter().fold(0u64, |mindur, (dmx, _)| {
1257 let dur = dmx.get_duration();
1264 let duration_string = if duration != 0 { format_time(duration) } else { String::new() };
1266 let mut ism = StreamManager::new();
1267 let mut is_offset = Vec::with_capacity(demuxers.len());
1269 let mut nstreams = 0;
1270 for (dmx, _) in demuxers.iter() {
1271 is_offset.push(nstreams);
1272 let sm = dmx.get_stream_manager();
1273 let max_id = sm.iter().fold(0u32, |id, strm| id.max(strm.id));
1274 for stream in sm.iter() {
1275 let mut newstream = (*stream).clone();
1276 if use_video_tb && transcoder.global_tb == (0, 0) && newstream.get_media_type() == StreamType::Video {
1277 transcoder.global_tb = newstream.get_timebase();
1279 newstream.id += start;
1280 ism.add_stream(newstream);
1282 start += max_id + 1;
1283 nstreams += sm.get_num_streams();
1286 for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
1287 for i in 0..dmx.get_num_streams() {
1288 let s = dmx.get_stream(i).unwrap();
1289 let info = s.get_info();
1290 let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
1291 let str_id = (s.get_num() + is_off) as u32;
1292 if let Some(create_dec) = decfunc {
1293 let mut dec = (create_dec)();
1294 let mut dsupp = Box::new(NADecoderSupport::new());
1295 let ret = dec.init(&mut dsupp, info.clone());
1297 println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
1300 transcoder.apply_decoder_options(dec.as_mut(), str_id);
1301 let desc = register::get_codec_description(info.get_name());
1302 let has_b = if let Some(desc) = desc {
1305 println!("No codec description found, using B-frame reorderer.");
1308 let reord: Box<dyn FrameReorderer> = if has_b { Box::new(IPBReorderer::new()) } else { Box::new(NoReorderer::new()) };
1309 transcoder.decoders.push(Some((dsupp, dec, reord)));
1311 println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
1312 transcoder.decoders.push(None);
1315 if transcoder.start != NATimePoint::None {
1316 let ret = dmx.seek(transcoder.start);
1318 println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
1323 let output_fmt = if let Some(ref fmtname) = transcoder.output_fmt {
1325 } else if transcoder.output_name.as_str() == "/dev/null" {
1327 } else if let Some(fmtname) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
1330 println!("Cannot guess muxer for output");
1333 let ret = full_reg.mux_reg.find_muxer(output_fmt);
1334 let ofmt = output_fmt.to_string();
1337 println!("cannot find muxer '{}'", output_fmt);
1340 let mux_creator = ret.unwrap();
1342 if transcoder.calc_len {
1343 let mut sids = Vec::new();
1344 transcoder.nframes.clear();
1345 for (dmx, _) in demuxers.iter_mut() {
1346 let sstart = transcoder.nframes.len();
1347 let sm = dmx.get_stream_manager();
1349 for stream in sm.iter() {
1350 transcoder.nframes.push(0);
1351 sids.push(stream.get_id());
1354 while let Ok(pkt) = dmx.get_frame() {
1355 let stream = pkt.get_stream();
1356 let pos = sstart + sids.iter().position(|&x| x == stream.get_id()).unwrap();
1357 transcoder.nframes[pos] += 1;
1360 // this is necessary since not all demuxers allow to seek even back to the start
1362 if !transcoder.create_demuxers(&mut demuxers, &full_reg, false) {
1363 println!("failed to re-create demuxer(s)");
1368 let mux_caps = mux_creator.get_capabilities();
1369 let mut out_sm = StreamManager::new();
1370 if !transcoder.negotiate_stream_map(&ism, mux_caps, &mut out_sm, &full_reg.enc_reg) {
1371 println!("cannot determine stream map");
1375 let ret = File::create(transcoder.output_name.as_str());
1377 println!("cannot open output file");
1380 let mut fw = FileWriter::new_write(ret.unwrap());
1381 let mut bw = ByteWriter::new(&mut fw);
1382 let ret = create_muxer(mux_creator, out_sm, &mut bw);
1383 if let Err(err) = ret {
1384 println!("cannot create muxer instance {:?}", err);
1387 let mut mux = ret.unwrap();
1388 parse_and_apply_options!(mux, &transcoder.mux_opts, "output");
1390 println!("Output {} muxer {}", transcoder.output_name, ofmt);
1391 for ostr in mux.get_streams() {
1392 println!(" #{}: {} {}", ostr.get_num(), ostr, ostr.get_info().get_name());
1395 let mut time = Instant::now();
1396 let show_interval = Duration::from_millis(100);
1397 let mut adata_size = 0;
1398 let mut vdata_size = 0;
1399 let mut cur_dmx = 0;
1401 let mut pktres = Err(DemuxerError::EOF);
1402 let mut src_dmx = 0;
1404 if !demuxers.iter().any(|(_, eof)| !eof) {
1407 let mut got_res = false;
1408 if !demuxers[cur_dmx].1 {
1409 pktres = demuxers[cur_dmx].0.get_frame();
1414 if cur_dmx >= demuxers.len() {
1422 if let Err(DemuxerError::EOF) = pktres { break; }
1423 if pktres.is_err() {
1424 println!("demuxing error");
1427 let mut pkt = pktres.unwrap();
1428 if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; }
1429 let src_id = pkt.get_stream().get_num() + is_offset[src_dmx];
1431 let newstream = ism.get_stream(src_id).unwrap();
1432 pkt.reassign(newstream, ts);
1434 if transcoder.verbose > 0 && time.elapsed() >= show_interval {
1435 if let Some(pts) = pkt.get_pts() {
1436 let cur_time = format_time(NATimeInfo::ts_to_time(pts, 1000, pkt.ts.tb_num, pkt.ts.tb_den));
1437 print!(" {}", cur_time);
1441 if !duration_string.is_empty() {
1442 print!(" / {}", duration_string);
1444 if transcoder.verbose > 1 {
1445 print!(" data sizes V: {} A: {}", vdata_size, adata_size);
1448 std::io::stdout().flush().unwrap();
1449 time = Instant::now();
1451 match transcoder.encoders[src_id] {
1452 OutputMode::Drop => {},
1453 OutputMode::Copy(dst_id) => {
1454 let dstr = mux.get_stream(dst_id as usize).unwrap();
1455 pkt.reassign(dstr, pkt.get_time_information());
1456 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1457 let pkt_size = pkt.get_buffer().len();
1458 match pkt.get_stream().get_media_type() {
1459 StreamType::Video => { vdata_size += pkt_size; },
1460 StreamType::Audio => { adata_size += pkt_size; },
1463 if mux.mux_frame(pkt).is_err() {
1464 println!("error muxing packet");
1468 OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) => {
1469 if let Some((ref mut dsupp, ref mut decoder, ref mut reorderer)) = transcoder.decoders[src_id] {
1470 let ret = decoder.decode(dsupp, &pkt);
1471 if let (true, Err(DecoderError::MissingReference)) = (transcoder.start != NATimePoint::None, &ret) {
1475 println!("error decoding stream {}", src_id);
1478 let frm = ret.unwrap();
1479 let tinfo = frm.get_info();
1480 reorderer.add_frame(frm);
1481 while let Some(frm) = reorderer.get_frame() {
1482 if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1485 while let Ok(Some(pkt)) = encoder.get_packet() {
1486 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1487 let pkt_size = pkt.get_buffer().len();
1488 match pkt.get_stream().get_media_type() {
1489 StreamType::Video => { vdata_size += pkt_size; },
1490 StreamType::Audio => { adata_size += pkt_size; },
1493 mux.mux_frame(pkt).unwrap();
1496 if let OutputConvert::Audio(ref mut acvt) = cvt {
1497 while let Some(ofrm) = acvt.get_frame(tinfo.clone()) {
1498 if encoder.encode(&ofrm).is_err() {
1501 while let Ok(Some(pkt)) = encoder.get_packet() {
1502 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1503 let pkt_size = pkt.get_buffer().len();
1504 adata_size += pkt_size;
1505 mux.mux_frame(pkt).unwrap();
1510 println!("no decoder for stream {}", src_id);
1516 'reord_flush_loop: for stream in ism.iter() {
1517 let src_id = stream.get_num();
1518 if let OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) = transcoder.encoders[src_id] {
1519 if let Some((_, _, ref mut reorderer)) = transcoder.decoders[src_id] {
1520 while let Some(frm) = reorderer.get_last_frames() {
1521 if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1524 while let Ok(Some(pkt)) = encoder.get_packet() {
1525 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'reord_flush_loop; }
1526 mux.mux_frame(pkt).unwrap();
1532 'flush_loop: for enc in transcoder.encoders.iter_mut() {
1534 OutputMode::Encode(str_id, ref mut encoder, _) => {
1535 let ret = encoder.flush();
1537 println!("error flushing encoder for stream {}", str_id);
1540 while let Ok(Some(pkt)) = encoder.get_packet() {
1541 if mux.mux_frame(pkt).is_err() {
1542 println!("error muxing packet");
1551 if transcoder.verbose > 0 {
1555 let ret = mux.end();
1557 println!("error at finalising muxing");