src/main.rs

   1 extern crate nihav_core;
   2 extern crate nihav_codec_support;
   3 extern crate nihav_registry;
   4 extern crate nihav_allstuff;
   5
   6 use std::fs::File;
   7 use std::io::{BufReader, Write};
   8 use std::pin::Pin;
   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;
  19 use std::env;
  20 use std::time::{Duration, Instant};
  21
  22 mod demux;
  23 use crate::demux::*;
  24 mod null;
  25 mod acvt;
  26 use crate::acvt::*;
  27 mod imgseq;
  28 use crate::imgseq::*;
  29
  30 #[derive(Clone,Copy,Default,PartialEq)]
  31 enum RegisterResult {
  32     #[default]
  33     Ok,
  34     Ignored,
  35     Failed,
  36 }
  37
  38 pub struct SelfBorrow<T, U> {
  39     bval: T,
  40     dst:  Option<U>,
  41 }
  42
  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{
  47             bval: src,
  48             dst: None,
  49         });
  50         let ptr = &mut obj.bval as *mut T;
  51         obj.dst = Some(create(ptr));
  52         obj
  53     }
  54     fn get_object(&self) -> &U {
  55         if let Some(ref dst) = self.dst {
  56             dst
  57         } else {
  58             unreachable!()
  59         }
  60     }
  61     fn get_object_mut(&mut self) -> &mut U {
  62         if let Some(ref mut dst) = self.dst {
  63             dst
  64         } else {
  65             unreachable!()
  66         }
  67     }
  68 }
  69
  70 impl<T, U> Drop for SelfBorrow<T, U> {
  71     fn drop(&mut self) {
  72         self.dst = None;
  73     }
  74 }
  75
  76 pub type SBBox<T, U> = Pin<Box<SelfBorrow<T, U>>>;
  77
  78 const SND_NO_FORMAT: NASoniton = NASoniton { bits: 0, be: false, packed: false, planar: false, float: false, signed: false };
  79
  80 fn format_time(ms: u64) -> String {
  81     let s = ms / 1000;
  82     let ds = (ms % 1000) / 100;
  83     let (min, s) = (s / 60, s % 60);
  84     let (h, min) = (min / 60, min % 60);
  85     if h == 0 {
  86         if min == 0 {
  87             format!("{}.{}", s, ds)
  88         } else {
  89             format!("{}:{:02}.{}", min, s, ds)
  90         }
  91     } else {
  92         format!("{}:{:02}:{:02}.{}", h, min, s, ds)
  93     }
  94 }
  95
  96 fn print_options(name: &str, options: &[NAOptionDefinition]) {
  97     if options.is_empty() {
  98         println!("No custom options.");
  99     } else {
 100         println!("Options for '{}'", name);
 101         for opt in options.iter() {
 102             println!(" {}", opt);
 103         }
 104     }
 105 }
 106
 107 fn parse_bitrate(strval: &str) -> Result<u32, ()> {
 108     let mut val = 0;
 109     let mut has_suffix = false;
 110     for ch in strval.chars() {
 111         match ch {
 112             _ if has_suffix => return Err(()),
 113             '0'..='9' => {
 114                 if val >= std::u32::MAX / 100 {
 115                     return Err(());
 116                 }
 117                 val = val * 10 + ch.to_digit(10).unwrap_or(0);
 118             },
 119             'k' | 'K' => {
 120                 if val >= std::u32::MAX / 1000 {
 121                     return Err(());
 122                 }
 123                 val *= 1000;
 124                 has_suffix = true;
 125             },
 126             'm' | 'M' => {
 127                 if val >= std::u32::MAX / 1000000 {
 128                     return Err(());
 129                 }
 130                 val *= 1000000;
 131                 has_suffix = true;
 132             },
 133             _ => return Err(()),
 134         };
 135     }
 136     Ok(val)
 137 }
 138
 139 struct OptionArgs {
 140     name:   String,
 141     value:  Option<String>,
 142 }
 143
 144 struct InputStreamOptions {
 145     id:             u32,
 146     drop:           bool,
 147     dec_opts:       Vec<OptionArgs>,
 148 }
 149
 150 struct OutputStreamOptions {
 151     id:             u32,
 152     enc_params:     EncodeParameters,
 153     enc_name:       String,
 154     enc_opts:       Vec<OptionArgs>,
 155 }
 156
 157 enum OutputConvert {
 158     Video(NAScale, NABufferType),
 159     Audio(AudioConverter),
 160     None,
 161 }
 162
 163 #[allow(clippy::large_enum_variant)]
 164 enum OutputMode {
 165     Drop,
 166     Copy(u32),
 167     Encode(u32, Box<dyn NAEncoder>, OutputConvert),
 168 }
 169
 170 #[derive(Default)]
 171 #[allow(clippy::type_complexity)]
 172 struct Transcoder {
 173     input_name:     [Option<String>; 16],
 174     input_fmt:      [Option<String>; 16],
 175     output_name:    String,
 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>,
 184     no_video:       bool,
 185     no_audio:       bool,
 186     start:          NATimePoint,
 187     end:            NATimePoint,
 188     verbose:        u8,
 189 }
 190
 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;
 202                 }
 203                 if matches {
 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 {
 207                         opts.push(val);
 208                     } else {
 209                         println!("invalid option {} for {}", opt.name, $name);
 210                     }
 211                     found = true;
 212                 }
 213             }
 214             if !found {
 215                 println!("  ignoring option '{}' for {}", opt.name, $name);
 216             }
 217         }
 218         $obj.set_options(opts.as_slice());
 219     }
 220 }
 221
 222 impl Transcoder {
 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();
 229
 230         let sidx = if let Some(idx) = self.istr_opts.iter().position(|el| el.id == streamno) {
 231                 idx
 232             } else {
 233                 self.istr_opts.push(InputStreamOptions {id: streamno, drop: false, dec_opts: Vec::new() });
 234                 self.istr_opts.len() - 1
 235             };
 236         let istr = &mut self.istr_opts[sidx];
 237
 238         for opt in opt1.split(',') {
 239             let oval: Vec<_> = opt.split('=').collect();
 240             if oval.len() == 1 {
 241                 match oval[0] {
 242                     "drop" => { istr.drop = true; },
 243                     _ => {
 244                         istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
 245                     },
 246                 };
 247             } else if oval.len() == 2 {
 248                 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 249             } else {
 250                 println!("unrecognized option '{}'", opt);
 251             }
 252         }
 253         true
 254     }
 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();
 260
 261         let sidx = if let Some(idx) = self.ostr_opts.iter().position(|el| el.id == streamno) {
 262                 idx
 263             } else {
 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
 266             };
 267         let ostr = &mut self.ostr_opts[sidx];
 268
 269         for opt in opt1.split(',') {
 270             let oval: Vec<_> = opt.split('=').collect();
 271             if oval.len() == 1 {
 272                 match oval[0] {
 273                     "flip" => {
 274                         if ostr.enc_params.format == NACodecTypeInfo::None {
 275                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 276                         }
 277                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 278                             vinfo.flipped = true;
 279                         } else {
 280                             println!("video option for audio stream");
 281                         }
 282                     },
 283                     "noflip" => {
 284                         if ostr.enc_params.format == NACodecTypeInfo::None {
 285                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 286                         }
 287                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 288                             vinfo.flipped = false;
 289                         } else {
 290                             println!("video option for audio stream");
 291                         }
 292                     },
 293                     _ => {
 294                         ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
 295                     },
 296                 };
 297             } else if oval.len() == 2 {
 298 //todo parse encoder options, store, init later
 299                 match oval[0] {
 300                     "timebase" => {
 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;
 310                             } else {
 311                                 println!("invalid timebase value");
 312                             }
 313                         } else {
 314                             println!("invalid timebase format (should be num/den)");
 315                         }
 316                     },
 317                     "encoder" => {
 318                         if enc_reg.find_encoder(oval[1]).is_some() {
 319                             ostr.enc_name = oval[1].to_string();
 320                         } else {
 321                             println!("unknown encoder '{}'", oval[1]);
 322                             ostr.enc_name = oval[1].to_string();
 323                         }
 324                     },
 325                     "width" => {
 326                         if ostr.enc_params.format == NACodecTypeInfo::None {
 327                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 328                         }
 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 {
 332                                 vinfo.width = val;
 333                             } else {
 334                                 println!("invalid width");
 335                             }
 336                         } else {
 337                             println!("video option for audio stream");
 338                         }
 339                     },
 340                     "height" => {
 341                         if ostr.enc_params.format == NACodecTypeInfo::None {
 342                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 343                         }
 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 {
 347                                 vinfo.height = val;
 348                             } else {
 349                                 println!("invalid height");
 350                             }
 351                         } else {
 352                             println!("video option for audio stream");
 353                         }
 354                     },
 355                     "pixfmt" => {
 356                         if ostr.enc_params.format == NACodecTypeInfo::None {
 357                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 358                         }
 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 {
 362                                 vinfo.format = val;
 363                             } else {
 364                                 println!("invalid pixel format");
 365                             }
 366                         } else {
 367                             println!("video option for audio stream");
 368                         }
 369                     },
 370                     "srate" => {
 371                         if ostr.enc_params.format == NACodecTypeInfo::None {
 372                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
 373                         }
 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;
 378                             } else {
 379                                 println!("invalid sampling rate");
 380                             }
 381                         } else {
 382                             println!("audio option for video stream");
 383                         }
 384                     },
 385                     "channels" => {
 386                         if ostr.enc_params.format == NACodecTypeInfo::None {
 387                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
 388                         }
 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;
 393                             } else {
 394                                 println!("invalid number of channels");
 395                             }
 396                         } else {
 397                             println!("audio option for video stream");
 398                         }
 399                     },
 400                     "block_len" => {
 401                         if ostr.enc_params.format == NACodecTypeInfo::None {
 402                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
 403                         }
 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;
 408                             } else {
 409                                 println!("invalid block_length");
 410                             }
 411                         } else {
 412                             println!("audio option for video stream");
 413                         }
 414                     },
 415                     "sfmt" => {
 416                         if ostr.enc_params.format == NACodecTypeInfo::None {
 417                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
 418                         }
 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 {
 422                                 ainfo.format = val;
 423                             } else {
 424                                 println!("invalid audio format");
 425                             }
 426                         } else {
 427                             println!("audio option for video stream");
 428                         }
 429                     },
 430 // todo channel map negotiation
 431                     /*"chmap" => {
 432                         if ostr.enc_params.format == NACodecTypeInfo::None {
 433                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_NO_FORMAT, 0));
 434                         }
 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 {
 438                                 ainfo.chmap = val;
 439                             } else {
 440                                 println!("invalid channel map");
 441                             }
 442                         } else {
 443                             println!("audio option for video stream");
 444                         }
 445                     },*/
 446                     "bitrate" => {
 447                         let ret = parse_bitrate(oval[1]);
 448                         if let Ok(val) = ret {
 449                             ostr.enc_params.bitrate = val;
 450                         } else {
 451                             println!("invalid bitrate value");
 452                         }
 453                     },
 454                     "quality" => {
 455                         let ret = oval[1].parse::<u8>();
 456                         if let Ok(val) = ret {
 457                             ostr.enc_params.quality = val;
 458                         } else {
 459                             println!("invalid quality value");
 460                         }
 461                     },
 462                     _ => {
 463                         ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 464                     },
 465                 }
 466             } else {
 467                 println!("unrecognized option '{}'", opt);
 468             }
 469         }
 470         true
 471     }
 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();
 475             if oval.len() == 1 {
 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());
 481                     } else {
 482                         println!("unknown demuxer format '{}'", oval[1]);
 483                     }
 484                 } else {
 485                     self.demux_opts[input_no].push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 486                 }
 487             } else {
 488                 println!("unrecognized option '{}'", opt);
 489             }
 490         }
 491         true
 492     }
 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();
 496             if oval.len() == 1 {
 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());
 502                     } else {
 503                         println!("unknown muxer format '{}'", oval[1]);
 504                     }
 505                 } else {
 506                     self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 507                 }
 508             } else {
 509                 println!("unrecognized option '{}'", opt);
 510             }
 511         }
 512         true
 513     }
 514     fn parse_scale_options(&mut self, opts: &str) -> bool {
 515         for opt in opts.split(',') {
 516             let oval: Vec<_> = opt.split('=').collect();
 517             if oval.len() == 1 {
 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()));
 521             } else {
 522                 println!("unrecognized option '{}'", opt);
 523                 return false;
 524             }
 525         }
 526         true
 527     }
 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);
 534         }
 535     }
 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;
 542             }
 543         }
 544
 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;
 555                 }
 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();
 561                 } else {
 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;
 566                             }
 567                             if dvinfo.height == 0 {
 568                                 dvinfo.height = svinfo.height;
 569                             }
 570                         },
 571                         (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(ref mut dainfo)) => {
 572                             if dainfo.sample_rate == 0 {
 573                                 dainfo.sample_rate = sainfo.sample_rate;
 574                             }
 575                             if dainfo.format == SND_NO_FORMAT {
 576                                 dainfo.format = sainfo.format;
 577                             }
 578                             if dainfo.channels == 0 {
 579                                 dainfo.channels = sainfo.channels;
 580                             }
 581                             if dainfo.block_len == 0 {
 582                                 dainfo.block_len = sainfo.block_len;
 583                             }
 584                         },
 585                         _ => {},
 586                     };
 587                 }
 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;
 591                 }
 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;
 596                 }
 597                 let ret_eparams = ret_eparams.unwrap();
 598
 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 {
 603                                 OutputConvert::None
 604                             } else {
 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);
 607                                 if ret.is_err() {
 608                                     println!("cannot create scaler");
 609                                     return RegisterResult::Failed;
 610                                 }
 611                                 let scaler = ret.unwrap();
 612                                 let ret = alloc_video_buffer(*dvinfo, 4);
 613                                 if ret.is_err() {
 614                                     println!("cannot create scaler buffer");
 615                                     return RegisterResult::Failed;
 616                                 }
 617                                 let cvt_buf = ret.unwrap();
 618                                 OutputConvert::Video(scaler, cvt_buf)
 619                             }
 620                         },
 621                         (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
 622                             if sainfo == dainfo {
 623                                 OutputConvert::None
 624                             } else {
 625                                 let dchmap = match dainfo.channels {
 626                                         1 => NAChannelMap::from_ms_mapping(0x4),
 627                                         2 => NAChannelMap::from_ms_mapping(0x3),
 628                                         _ => {
 629 println!("can't generate default channel map for {} channels", dainfo.channels);
 630                                             return RegisterResult::Failed;
 631                                         },
 632                                     };
 633                                 let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
 634 //todo channelmap
 635                                 OutputConvert::Audio(acvt)
 636                             }
 637                         },
 638                         _ => OutputConvert::None,
 639                     };
 640                 let name = format!("output stream {}", out_id);
 641                 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
 642
 643                 let ret = encoder.init(out_id, ret_eparams);
 644                 if ret.is_err() {
 645                     println!("error initialising encoder");
 646                     return RegisterResult::Failed;
 647                 }
 648                 out_sm.add_stream_ref(ret.unwrap());
 649
 650                 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
 651
 652                 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
 653             } else {
 654 println!("encoder {} is not supported by output (expected {})", istr.id, istr.get_info().get_name());
 655                 return RegisterResult::Failed;
 656             }
 657         } else if cname == "any" || istr.get_info().get_name() == cname {
 658             out_sm.add_stream((*istr).clone());
 659             self.encoders.push(OutputMode::Copy(out_id));
 660         } else {
 661             let mut oopts = OutputStreamOptions {id: out_id, enc_name: cname.to_owned(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() };
 662
 663             let enc_create = enc_reg.find_encoder(cname);
 664             if enc_create.is_none() {
 665                 println!("encoder '{}' not found", oopts.enc_name.as_str());
 666                 return RegisterResult::Failed;
 667             }
 668             let mut encoder = (enc_create.unwrap())();
 669             oopts.enc_params.format = istr.get_info().get_properties();
 670             oopts.enc_params.tb_num = istr.tb_num;
 671             oopts.enc_params.tb_den = istr.tb_den;
 672             let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
 673             if ret_eparams.is_err() {
 674                 println!("cannot negotiate encoding parameters");
 675                 return RegisterResult::Failed;
 676             }
 677             let ret_eparams = ret_eparams.unwrap();
 678
 679 //todo check for params mismatch
 680             let cvt = match (&oopts.enc_params.format, &ret_eparams.format) {
 681                     (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
 682                         if svinfo == dvinfo {
 683                             OutputConvert::None
 684                         } else {
 685                             let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
 686                             let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts);
 687                             if ret.is_err() {
 688                                 println!("cannot create scaler");
 689                                 return RegisterResult::Failed;
 690                             }
 691                             let scaler = ret.unwrap();
 692                             let ret = alloc_video_buffer(*dvinfo, 4);
 693                             if ret.is_err() {
 694                                 println!("cannot create scaler buffer");
 695                                 return RegisterResult::Failed;
 696                             }
 697                             let cvt_buf = ret.unwrap();
 698                             OutputConvert::Video(scaler, cvt_buf)
 699                         }
 700                     },
 701                     (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
 702                         if sainfo == dainfo {
 703                             OutputConvert::None
 704                         } else {
 705                             let dchmap = match dainfo.channels {
 706                                     1 => NAChannelMap::from_ms_mapping(0x4),
 707                                     2 => NAChannelMap::from_ms_mapping(0x3),
 708                                     _ => {
 709 println!("can't generate default channel map for {} channels", dainfo.channels);
 710                                         return RegisterResult::Failed;
 711                                     },
 712                                 };
 713 //todo channelmap
 714                             let acvt = AudioConverter::new(sainfo, dainfo, dchmap);
 715                             OutputConvert::Audio(acvt)
 716                         }
 717                     },
 718                     _ => OutputConvert::None,
 719                 };
 720             let ret = encoder.init(out_id, ret_eparams);
 721             if ret.is_err() {
 722                 println!("error initialising encoder");
 723                 return RegisterResult::Failed;
 724             }
 725             out_sm.add_stream_ref(ret.unwrap());
 726             self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
 727             self.ostr_opts.push(oopts);
 728         }
 729         RegisterResult::Ok
 730     }
 731     fn map_single(&mut self, cname: &str, ctype: StreamType, src_sm: &StreamManager, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
 732         let mut found_stream = false;
 733         for istr in src_sm.iter() {
 734             if istr.get_media_type() != ctype || found_stream {
 735                 self.encoders.push(OutputMode::Drop);
 736             } else {
 737                 match self.register_output_stream(cname, istr, out_sm, enc_reg) {
 738                     RegisterResult::Ok     => found_stream = true,
 739                     RegisterResult::Failed => return false,
 740                     RegisterResult::Ignored => {},
 741                 };
 742             }
 743         }
 744         found_stream
 745     }
 746     fn negotiate_stream_map(&mut self, src_sm: &StreamManager, mux_caps: MuxerCapabilities, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
 747         match mux_caps {
 748             MuxerCapabilities::SingleVideo(cname) => {
 749                 if self.no_video { return false; }
 750                 self.map_single(cname, StreamType::Video, src_sm, out_sm, enc_reg)
 751             },
 752             MuxerCapabilities::SingleAudio(cname) => {
 753                 if self.no_audio { return false; }
 754                 self.map_single(cname, StreamType::Audio, src_sm, out_sm, enc_reg)
 755             },
 756             MuxerCapabilities::SingleVideoAndAudio(vname, aname) => {
 757                 let mut found_vid = false;
 758                 let mut found_aud = false;
 759                 for istr in src_sm.iter() {
 760                     if istr.get_media_type() == StreamType::Video && !found_vid && !self.no_video {
 761                         match self.register_output_stream(vname, istr, out_sm, enc_reg) {
 762                             RegisterResult::Ok     => found_vid = true,
 763                             RegisterResult::Failed => return false,
 764                             RegisterResult::Ignored => {},
 765                         };
 766                     } else if istr.get_media_type() == StreamType::Audio && !found_aud && !self.no_audio {
 767                         match self.register_output_stream(aname, istr, out_sm, enc_reg) {
 768                             RegisterResult::Ok     => found_aud = true,
 769                             RegisterResult::Failed => return false,
 770                             RegisterResult::Ignored => {},
 771                         };
 772                     } else {
 773                         self.encoders.push(OutputMode::Drop);
 774                     }
 775                 }
 776                 found_vid | found_aud
 777             },
 778             MuxerCapabilities::OnlyVideo => {
 779                 if self.no_video { return false; }
 780
 781                 let mut found_vid = false;
 782                 for istr in src_sm.iter() {
 783                     if istr.get_media_type() == StreamType::Video && !found_vid {
 784                         match self.register_output_stream("any", istr, out_sm, enc_reg) {
 785                             RegisterResult::Ok     => found_vid = true,
 786                             RegisterResult::Failed => return false,
 787                             RegisterResult::Ignored => {},
 788                         };
 789                     } else {
 790                         self.encoders.push(OutputMode::Drop);
 791                     }
 792                 }
 793                 found_vid
 794             },
 795             MuxerCapabilities::OnlyAudio => {
 796                 if self.no_audio { return false; }
 797
 798                 let mut found_aud = false;
 799                 for istr in src_sm.iter() {
 800                     if istr.get_media_type() == StreamType::Audio && !found_aud {
 801                         match self.register_output_stream("any", istr, out_sm, enc_reg) {
 802                             RegisterResult::Ok     => found_aud = true,
 803                             RegisterResult::Failed => return false,
 804                             RegisterResult::Ignored => {},
 805                         };
 806                     } else {
 807                         self.encoders.push(OutputMode::Drop);
 808                     }
 809                 }
 810                 found_aud
 811             },
 812             MuxerCapabilities::Universal => {
 813                 for istr in src_sm.iter() {
 814                     if (istr.get_media_type() == StreamType::Video && self.no_video) ||
 815                         (istr.get_media_type() == StreamType::Audio && self.no_audio) {
 816                         self.encoders.push(OutputMode::Drop);
 817                         continue;
 818                     }
 819                     if self.register_output_stream("any", istr, out_sm, enc_reg) == RegisterResult::Failed {
 820                         return false;
 821                     }
 822                 }
 823                 true
 824             },
 825         }
 826     }
 827 }
 828
 829 fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef, scale_opts: &[(String, String)]) -> bool {
 830     let buf = frm.get_buffer();
 831     let cbuf = if let NABufferType::None = buf {
 832         if (encoder.get_capabilities() & ENC_CAPS_SKIPFRAME) == 0 {
 833             match cvt {
 834                 OutputConvert::Video(_, ref mut dbuf) => dbuf.clone(),
 835                 _ => {
 836                     println!("encoder does not support skip frames, skipping");
 837                     return true;
 838                 },
 839             }
 840         } else {
 841             buf
 842         }
 843     } else {
 844         match cvt {
 845             OutputConvert::None => buf,
 846             OutputConvert::Video(ref mut scaler, ref mut dbuf) => {
 847                 let cur_ifmt = get_scale_fmt_from_pic(&buf);
 848                 let last_ifmt = scaler.get_in_fmt();
 849                 if cur_ifmt != last_ifmt {
 850                     let ofmt = scaler.get_out_fmt();
 851                     let ret = NAScale::new_with_options(cur_ifmt, ofmt, scale_opts);
 852                     if ret.is_err() {
 853                         println!("error re-initialising scaler for {} -> {}", cur_ifmt, ofmt);
 854                         return false;
 855                     }
 856                     *scaler = ret.unwrap();
 857                 }
 858                 let ret = scaler.convert(&buf, dbuf);
 859                 if ret.is_err() {
 860                     println!("error converting frame for encoding");
 861                     return false;
 862                 }
 863                 dbuf.clone()
 864             },
 865             OutputConvert::Audio(ref mut acvt) => {
 866                 if !acvt.queue_frame(buf, frm.get_time_information()) {
 867                     println!("error converting audio for stream {}", dst_id);
 868                     return false;
 869                 }
 870                 return true;
 871             },
 872         }
 873     };
 874     let cfrm = NAFrame::new(frm.get_time_information(), frm.frame_type, frm.key, frm.get_info(), cbuf);
 875     encoder.encode(&cfrm).unwrap();
 876     true
 877 }
 878
 879 macro_rules! next_arg {
 880     ($args: expr, $arg_idx: expr) => {
 881         if $arg_idx + 1 >= $args.len() {
 882             println!("codec name is required");
 883         }
 884         $arg_idx += 1;
 885     }
 886 }
 887
 888 macro_rules! parse_id {
 889     ($val: expr, $stype: expr, $maxval: expr) => {
 890         if $val.is_empty() {
 891             0
 892         } else if let Ok(val) = $val.parse::<usize>() {
 893             if val < $maxval {
 894                 val
 895             } else {
 896                 println!("{} number should be below {}", $stype, $maxval);
 897                 return;
 898             }
 899         } else {
 900             println!("invalid {} number '{}'", $stype, $val);
 901             return;
 902         }
 903     }
 904 }
 905
 906 #[allow(clippy::single_match)]
 907 fn main() {
 908     let args: Vec<_> = env::args().collect();
 909
 910     if args.len() == 1 {
 911         println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
 912         println!(" use nihav-encoder --help to list all available options");
 913         return;
 914     }
 915     if args.len() == 2 && (args[1] == "--help" || args[1] == "-h") {
 916         println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
 917         println!(" query options:");
 918         println!("  --list-{{decoders,encoders,demuxers,muxers}} - lists all available decoders/encoders/demuxers/muxers");
 919         println!("  --query-{{decoder,encoder,demuxer,muxer}}-options name - lists all options recognized by that decoder/encoder/demuxer/muxer");
 920         println!(" processing options:");
 921         println!("  --verbose                   - show time for the currently processed input");
 922         println!("  --input inputfile           - set input file");
 923         println!("  --input-format fmt          - force input format");
 924         println!("  --demuxer-options options   - set input demuxer options");
 925         println!("  --scale-options options     - set scaler options");
 926         println!("  --output outputfile         - set output file");
 927         println!("  --output-format fmt         - force output format");
 928         println!("  --muxer-options options     - set output muxer options");
 929         println!("  --no-audio                  - do not decode audio streams");
 930         println!("  --no-video                  - do not decode video streams");
 931         println!("  --start starttime           - start decoding from given position");
 932         println!("  --end endtime               - end decoding at given position");
 933         println!("  --istreamX options          - set options for input stream X");
 934         println!("  --ostreamX options          - set options for output stream X");
 935         println!();
 936         println!(" (de)muxer and stream options are passed as comma-separated list e.g. --ostream0 width=320,height=240,flip");
 937         return;
 938     }
 939
 940     let full_reg = FullRegister::new();
 941
 942     let mut transcoder = Transcoder::new();
 943
 944     let mut arg_idx = 1;
 945     let mut printed_info = false;
 946     while arg_idx < args.len() {
 947         match args[arg_idx].as_str() {
 948             "--list-decoders" => {
 949                 if full_reg.dec_reg.iter().len() > 0 {
 950                     println!("Registered decoders:");
 951                     for dec in full_reg.dec_reg.iter() {
 952                         let cdesc = register::get_codec_description(dec.name);
 953                         let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
 954                         println!(" {} ({})", dec.name, full_name);
 955                     }
 956                 } else {
 957                     println!("No registered decoders.");
 958                 }
 959                 printed_info = true;
 960             },
 961             "--list-encoders" => {
 962                 if full_reg.enc_reg.iter().len() > 0 {
 963                     println!("Registered encoders:");
 964                     for enc in full_reg.enc_reg.iter() {
 965                         let cdesc = register::get_codec_description(enc.name);
 966                         let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
 967                         println!(" {} ({})", enc.name, full_name);
 968                     }
 969                 } else {
 970                     println!("No registered encoders.");
 971                 }
 972                 printed_info = true;
 973             },
 974             "--list-demuxers" => {
 975                 print!("Registered demuxers:");
 976                 for dmx in full_reg.dmx_reg.iter() {
 977                     print!(" {}", dmx.get_name());
 978                 }
 979                 println!();
 980                 printed_info = true;
 981             },
 982             "--list-muxers" => {
 983                 print!("Registered muxers:");
 984                 for mux in full_reg.mux_reg.iter() {
 985                     print!(" {}", mux.get_name());
 986                 }
 987                 println!();
 988                 printed_info = true;
 989             },
 990             "--query-decoder-options" => {
 991                 next_arg!(args, arg_idx);
 992                 let cname = args[arg_idx].as_str();
 993                 if let Some(decfunc) = full_reg.dec_reg.find_decoder(cname) {
 994                     let dec = (decfunc)();
 995                     let opts = dec.get_supported_options();
 996                     print_options(cname, opts);
 997                 } else {
 998                     println!("codec {} is not found", cname);
 999                 }
1000                 printed_info = true;
1001             },
1002             "--query-demuxer-options" => {
1003                 next_arg!(args, arg_idx);
1004                 let dname = args[arg_idx].as_str();
1005                 let mut mr = MemoryReader::new_read(&[]);
1006                 let mut br = ByteReader::new(&mut mr);
1007                 if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) {
1008                     let dmx = dmx_creator.new_demuxer(&mut br);
1009                     let opts = dmx.get_supported_options();
1010                     print_options(dname, opts);
1011                 } else {
1012                     println!("demuxer {} is not found", dname);
1013                 }
1014                 printed_info = true;
1015             },
1016             "--query-encoder-options" => {
1017                 next_arg!(args, arg_idx);
1018                 let cname = args[arg_idx].as_str();
1019                 if let Some(encfunc) = full_reg.enc_reg.find_encoder(cname) {
1020                     let enc = (encfunc)();
1021                     let opts = enc.get_supported_options();
1022                     print_options(cname, opts);
1023                 } else {
1024                     println!("codec {} is not found", cname);
1025                 }
1026                 printed_info = true;
1027             },
1028             "--query-muxer-options" => {
1029                 next_arg!(args, arg_idx);
1030                 let name = args[arg_idx].as_str();
1031                 let mut data = [];
1032                 let mut mw = MemoryWriter::new_write(&mut data);
1033                 let mut bw = ByteWriter::new(&mut mw);
1034                 if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) {
1035                     let mux = mux_creator.new_muxer(&mut bw);
1036                     let opts = mux.get_supported_options();
1037                     print_options(name, opts);
1038                 } else {
1039                     println!("muxer {} is not found", name);
1040                 }
1041                 printed_info = true;
1042             },
1043             "--output" | "-o" => {
1044                 next_arg!(args, arg_idx);
1045                 transcoder.output_name = args[arg_idx].clone();
1046             },
1047             "--output-format" => {
1048                 next_arg!(args, arg_idx);
1049                 transcoder.output_fmt = Some(args[arg_idx].clone());
1050             },
1051             "--scale-options" => {
1052                 next_arg!(args, arg_idx);
1053                 if !transcoder.parse_scale_options(&args[arg_idx]) {
1054                     println!("invalid scale option syntax");
1055                     return;
1056                 }
1057             },
1058             "--no-video" | "-vn" => {
1059                 transcoder.no_video = true;
1060             },
1061             "--no-audio" | "-an" => {
1062                 transcoder.no_audio = true;
1063             },
1064             "--start" => {
1065                 next_arg!(args, arg_idx);
1066                 let ret = args[arg_idx].parse::<NATimePoint>();
1067                 if let Ok(val) = ret {
1068                     transcoder.start = val;
1069                 } else {
1070                     println!("invalid start time");
1071                     return;
1072                 }
1073             },
1074             "--end" => {
1075                 next_arg!(args, arg_idx);
1076                 let ret = args[arg_idx].parse::<NATimePoint>();
1077                 if let Ok(val) = ret {
1078                     transcoder.end = val;
1079                 } else {
1080                     println!("invalid end time");
1081                     return;
1082                 }
1083             },
1084             "--muxer-options" => {
1085                 next_arg!(args, arg_idx);
1086                 if !transcoder.parse_muxer_options(&args[arg_idx], &full_reg.mux_reg) {
1087                     println!("invalid muxer option syntax");
1088                     return;
1089                 }
1090             },
1091             "--verbose" | "-v" => transcoder.verbose = 1,
1092             "-vv" => transcoder.verbose = 2,
1093             "-v-" => transcoder.verbose = 0,
1094             _ => {
1095                 if args[arg_idx].starts_with("--istream") {
1096                     let opt0 = &args[arg_idx];
1097                     next_arg!(args, arg_idx);
1098                     if !transcoder.parse_istream_options(opt0, &args[arg_idx]) {
1099                         println!("invalid input stream option syntax");
1100                         return;
1101                     }
1102                 } else if args[arg_idx].starts_with("--ostream") {
1103                     let opt0 = &args[arg_idx];
1104                     next_arg!(args, arg_idx);
1105                     if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &full_reg.enc_reg) {
1106                         println!("invalid output stream option syntax");
1107                         return;
1108                     }
1109                 } else if args[arg_idx].starts_with("--input-format") {
1110                     let id = parse_id!(&args[arg_idx][14..], "input format", transcoder.input_fmt.len());
1111                     next_arg!(args, arg_idx);
1112                     transcoder.input_fmt[id] = Some(args[arg_idx].clone());
1113                 } else if args[arg_idx].starts_with("--input") { // should be after --input-format
1114                     let id = parse_id!(&args[arg_idx][7..], "input", transcoder.input_name.len());
1115                     next_arg!(args, arg_idx);
1116                     transcoder.input_name[id] = Some(args[arg_idx].clone());
1117                 } else if args[arg_idx].starts_with("-i") {
1118                     let id = parse_id!(&args[arg_idx][2..], "input", transcoder.input_name.len());
1119                     next_arg!(args, arg_idx);
1120                     transcoder.input_name[id] = Some(args[arg_idx].clone());
1121                 } else if args[arg_idx].starts_with("--demuxer-options") {
1122                     let id = parse_id!(&args[arg_idx][17..], "input options", transcoder.demux_opts.len());
1123                     next_arg!(args, arg_idx);
1124                     if !transcoder.parse_demuxer_options(&args[arg_idx], &full_reg.dmx_reg, id) {
1125                         println!("invalid demuxer option syntax");
1126                         return;
1127                     }
1128                 } else if args[arg_idx].starts_with("--") {
1129                     println!("unknown option '{}'", args[arg_idx]);
1130                 } else {
1131                     println!("unrecognized argument '{}'", args[arg_idx]);
1132                 }
1133             },
1134         };
1135         arg_idx += 1;
1136     }
1137
1138     if printed_info {
1139         return;
1140     }
1141
1142     if transcoder.input_name.iter().flatten().count() == 0 {
1143         println!("no input name(s) provided");
1144         return;
1145     }
1146     if transcoder.output_name.is_empty() {
1147         println!("no output name provided");
1148         return;
1149     }
1150
1151     let mut demuxers = Vec::with_capacity(1);
1152     let mut isn_start = 0;
1153     for (i, (iname, ifmt)) in transcoder.input_name.iter().zip(
1154             transcoder.input_fmt.iter()).enumerate() {
1155         match (iname, ifmt.as_ref().map(|s| s.as_str())) {
1156             (Some(name), Some("imgseq")) => {
1157                 println!("trying image sequence {}", name);
1158                 let mut isdc = ImgSeqDemuxerCreator::new(name.as_str());
1159                 parse_and_apply_options!(isdc, &transcoder.demux_opts[i], "input");
1160                 let isd = if let Ok(ctx) = isdc.open() {
1161                         ctx
1162                     } else {
1163                         println!("failed to create image sequence demuxer!");
1164                         return;
1165                     };
1166                 let dmx = DemuxerObject::create_imgseq(isd);
1167                 for i in 0..dmx.get_num_streams() {
1168                     let s = dmx.get_stream(i).unwrap();
1169                     let info = s.get_info();
1170                     println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
1171                 }
1172                 isn_start += dmx.get_num_streams();
1173                 demuxers.push((dmx, false))
1174             },
1175             (Some(name), _) => {
1176                 let res = File::open(name);
1177                 if res.is_err() {
1178                     println!("error opening input");
1179                     return;
1180                 }
1181                 let file = res.unwrap();
1182                 let file = BufReader::new(file);
1183                 let mut fr = FileReader::new_read(file);
1184                 let mut br = ByteReader::new(&mut fr);
1185                 let (is_raw, start, end) = if ifmt.is_none() {
1186                         detect_tags(&mut br)
1187                     } else {
1188                         (false, 0, None)
1189                     };
1190
1191                 let nfr: Box<dyn ByteIO> = if start != 0 || end.is_some() {
1192                         let file = fr.finish();
1193                         Box::new(BoundedFileReader::new_read(file, start, end).unwrap())
1194                     } else {
1195                         Box::new(fr)
1196                     };
1197                 let sb = SelfBorrow::new(nfr, |rd| {
1198                         unsafe {
1199                             ByteReader::new(rd.as_mut().unwrap().as_mut())
1200                         }
1201                     });
1202
1203                 let mut dmx = DemuxerObject::create(sb, &full_reg, name, ifmt, is_raw, true);
1204                 if dmx.is_none() {
1205                     println!("cannot find demuxer for '{}'", name);
1206                     return;
1207                 }
1208                 parse_and_apply_options!(dmx, &transcoder.demux_opts[i], "input");
1209                 for i in 0..dmx.get_num_streams() {
1210                     let s = dmx.get_stream(i).unwrap();
1211                     let info = s.get_info();
1212                     println!(" stream {}({}) - {} {}", i, i + isn_start, s, info.get_name());
1213                 }
1214                 isn_start += dmx.get_num_streams();
1215                 demuxers.push((dmx, false));
1216             },
1217             _ => {},
1218         };
1219     }
1220
1221     let duration = demuxers.iter().fold(0u64, |mindur, (dmx, _)| {
1222             let dur = dmx.get_duration();
1223             if dur > 0 {
1224                 mindur.min(dur)
1225             } else {
1226                 mindur
1227             }
1228         });
1229     let duration_string = if duration != 0 { format_time(duration) } else { String::new() };
1230
1231     let mut ism = StreamManager::new();
1232     let mut is_offset = Vec::with_capacity(demuxers.len());
1233     let mut start = 0;
1234     let mut nstreams = 0;
1235     for (dmx, _) in demuxers.iter() {
1236         is_offset.push(nstreams);
1237         let sm = dmx.get_stream_manager();
1238         let max_id = sm.iter().fold(0u32, |id, strm| id.max(strm.id));
1239         for stream in sm.iter() {
1240             let mut newstream = (*stream).clone();
1241             newstream.id += start;
1242             ism.add_stream(newstream);
1243         }
1244         start += max_id + 1;
1245         nstreams += sm.get_num_streams();
1246     }
1247
1248     for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
1249         for i in 0..dmx.get_num_streams() {
1250             let s = dmx.get_stream(i).unwrap();
1251             let info = s.get_info();
1252             let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
1253             let str_id = (s.get_num() + is_off) as u32;
1254             if let Some(create_dec) = decfunc {
1255                 let mut dec = (create_dec)();
1256                 let mut dsupp = Box::new(NADecoderSupport::new());
1257                 let ret = dec.init(&mut dsupp, info.clone());
1258                 if ret.is_err() {
1259                     println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
1260                     return;
1261                 }
1262                 transcoder.apply_decoder_options(dec.as_mut(), str_id);
1263                 let desc = register::get_codec_description(info.get_name());
1264                 let has_b = if let Some(desc) = desc {
1265                         desc.has_reorder()
1266                     } else {
1267                         println!("No codec description found, using B-frame reorderer.");
1268                         true
1269                     };
1270                 let reord: Box<dyn FrameReorderer> = if has_b { Box::new(IPBReorderer::new()) } else { Box::new(NoReorderer::new()) };
1271                 transcoder.decoders.push(Some((dsupp, dec, reord)));
1272             } else {
1273                 println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
1274                 transcoder.decoders.push(None);
1275             }
1276         }
1277         if transcoder.start != NATimePoint::None {
1278             let ret = dmx.seek(transcoder.start);
1279             if ret.is_err() {
1280                 println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
1281             }
1282         }
1283     }
1284
1285     let output_fmt = if let Some(ref fmtname) = transcoder.output_fmt {
1286             fmtname
1287         } else if transcoder.output_name.as_str() == "/dev/null" {
1288             "null"
1289         } else if let Some(fmtname) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
1290             fmtname
1291         } else {
1292             println!("Cannot guess muxer for output");
1293             return;
1294         };
1295     let ret = full_reg.mux_reg.find_muxer(output_fmt);
1296     let ofmt = output_fmt.to_string();
1297
1298     if ret.is_none() {
1299         println!("cannot find muxer '{}'", output_fmt);
1300         return;
1301     }
1302     let mux_creator = ret.unwrap();
1303
1304     let mux_caps = mux_creator.get_capabilities();
1305     let mut out_sm = StreamManager::new();
1306     if !transcoder.negotiate_stream_map(&ism, mux_caps, &mut out_sm, &full_reg.enc_reg) {
1307         println!("cannot determine stream map");
1308         return;
1309     }
1310
1311     let ret = File::create(transcoder.output_name.as_str());
1312     if ret.is_err() {
1313         println!("cannot open output file");
1314         return;
1315     }
1316     let mut fw = FileWriter::new_write(ret.unwrap());
1317     let mut bw = ByteWriter::new(&mut fw);
1318     let ret = create_muxer(mux_creator, out_sm, &mut bw);
1319     if let Err(err) = ret {
1320         println!("cannot create muxer instance {:?}", err);
1321         return;
1322     }
1323     let mut mux = ret.unwrap();
1324     parse_and_apply_options!(mux, &transcoder.mux_opts, "output");
1325
1326     println!("Output {} muxer {}", transcoder.output_name, ofmt);
1327     for ostr in mux.get_streams() {
1328         println!(" #{}: {} {}", ostr.get_num(), ostr, ostr.get_info().get_name());
1329     }
1330
1331     let mut time = Instant::now();
1332     let show_interval = Duration::from_millis(100);
1333     let mut adata_size = 0;
1334     let mut vdata_size = 0;
1335     let mut cur_dmx = 0;
1336     'main_loop: loop {
1337         let mut pktres = Err(DemuxerError::EOF);
1338         let mut src_dmx = 0;
1339         loop {
1340             if !demuxers.iter().any(|(_, eof)| !eof) {
1341                 break;
1342             }
1343             let mut got_res = false;
1344             if !demuxers[cur_dmx].1 {
1345                 pktres = demuxers[cur_dmx].0.get_frame();
1346                 got_res = true;
1347                 src_dmx = cur_dmx;
1348             }
1349             cur_dmx += 1;
1350             if cur_dmx >= demuxers.len() {
1351                 cur_dmx = 0;
1352             }
1353             if got_res {
1354                 break;
1355             }
1356         }
1357
1358         if let Err(DemuxerError::EOF) = pktres { break; }
1359         if pktres.is_err() {
1360             println!("demuxing error");
1361             break;
1362         }
1363         let mut pkt = pktres.unwrap();
1364         if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; }
1365         let src_id = pkt.get_stream().get_num() + is_offset[src_dmx];
1366         let ts = pkt.ts;
1367         let newstream = ism.get_stream(src_id).unwrap();
1368         pkt.reassign(newstream, ts);
1369
1370         if transcoder.verbose > 0 && time.elapsed() >= show_interval {
1371             if let Some(pts) = pkt.get_pts() {
1372                  let cur_time = format_time(NATimeInfo::ts_to_time(pts, 1000, pkt.ts.tb_num, pkt.ts.tb_den));
1373                 print!(" {}", cur_time);
1374             } else {
1375                 print!(" ???");
1376             }
1377             if !duration_string.is_empty() {
1378                 print!(" / {}", duration_string);
1379             }
1380             if transcoder.verbose > 1 {
1381                 print!(" data sizes V: {} A: {}", vdata_size, adata_size);
1382             }
1383             print!("\r");
1384             std::io::stdout().flush().unwrap();
1385             time = Instant::now();
1386         }
1387         match transcoder.encoders[src_id] {
1388             OutputMode::Drop => {},
1389             OutputMode::Copy(dst_id) => {
1390                 let dstr = mux.get_stream(dst_id as usize).unwrap();
1391                 pkt.reassign(dstr, pkt.get_time_information());
1392                 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1393                 let pkt_size = pkt.get_buffer().len();
1394                 match pkt.get_stream().get_media_type() {
1395                     StreamType::Video => { vdata_size += pkt_size; },
1396                     StreamType::Audio => { adata_size += pkt_size; },
1397                     _ => {},
1398                 };
1399                 if mux.mux_frame(pkt).is_err() {
1400                     println!("error muxing packet");
1401                     break;
1402                 }
1403             },
1404             OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) => {
1405                 if let Some((ref mut dsupp, ref mut decoder, ref mut reorderer)) = transcoder.decoders[src_id] {
1406                     let ret = decoder.decode(dsupp, &pkt);
1407                     if let (true, Err(DecoderError::MissingReference)) = (transcoder.start != NATimePoint::None, &ret) {
1408                         continue;
1409                     }
1410                     if ret.is_err() {
1411                         println!("error decoding stream {}", src_id);
1412                         break;
1413                     }
1414                     let frm = ret.unwrap();
1415                     let tinfo = frm.get_info();
1416                     reorderer.add_frame(frm);
1417                     while let Some(frm) = reorderer.get_frame() {
1418                         if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1419                             break;
1420                         }
1421                         while let Ok(Some(pkt)) = encoder.get_packet() {
1422                             if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1423                             let pkt_size = pkt.get_buffer().len();
1424                             match pkt.get_stream().get_media_type() {
1425                                 StreamType::Video => { vdata_size += pkt_size; },
1426                                 StreamType::Audio => { adata_size += pkt_size; },
1427                                 _ => {},
1428                             };
1429                             mux.mux_frame(pkt).unwrap();
1430                         }
1431                     }
1432                     if let OutputConvert::Audio(ref mut acvt) = cvt {
1433                         while let Some(ofrm) = acvt.get_frame(tinfo.clone()) {
1434                             if encoder.encode(&ofrm).is_err() {
1435                                 break;
1436                             }
1437                             while let Ok(Some(pkt)) = encoder.get_packet() {
1438                                 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
1439                                 let pkt_size = pkt.get_buffer().len();
1440                                 adata_size += pkt_size;
1441                                 mux.mux_frame(pkt).unwrap();
1442                             }
1443                         }
1444                     }
1445                 } else {
1446                     println!("no decoder for stream {}", src_id);
1447                     break;
1448                 }
1449             },
1450         };
1451     }
1452     'reord_flush_loop: for stream in ism.iter() {
1453         let src_id = stream.get_num();
1454         if let OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) = transcoder.encoders[src_id] {
1455             if let Some((_, _, ref mut reorderer)) = transcoder.decoders[src_id] {
1456                 while let Some(frm) = reorderer.get_last_frames() {
1457                     if !encode_frame(dst_id, encoder, cvt, frm, &transcoder.scale_opts) {
1458                         break;
1459                     }
1460                     while let Ok(Some(pkt)) = encoder.get_packet() {
1461                         if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'reord_flush_loop; }
1462                         mux.mux_frame(pkt).unwrap();
1463                     }
1464                 }
1465             }
1466         }
1467     }
1468     'flush_loop: for enc in transcoder.encoders.iter_mut() {
1469         match enc {
1470             OutputMode::Encode(str_id, ref mut encoder, _) => {
1471                 let ret = encoder.flush();
1472                 if ret.is_err() {
1473                     println!("error flushing encoder for stream {}", str_id);
1474                     break;
1475                 } else {
1476                     while let Ok(Some(pkt)) = encoder.get_packet() {
1477                         if mux.mux_frame(pkt).is_err() {
1478                             println!("error muxing packet");
1479                             break 'flush_loop;
1480                         }
1481                     }
1482                 }
1483             },
1484             _ => {},
1485         };
1486     }
1487     if transcoder.verbose > 0 {
1488         println!();
1489     }
1490
1491     let ret = mux.end();
1492     if ret.is_err() {
1493         println!("error at finalising muxing");
1494     }
1495 }