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 nihav_core::io::byteio::{FileReader, ByteReader};
   8 use nihav_core::frame::*;
   9 use nihav_core::options::*;
  10 use nihav_core::codecs::*;
  11 use nihav_core::demuxers::*;
  12 use nihav_core::muxers::*;
  13 use nihav_core::reorder::*;
  14 use nihav_core::scale::*;
  15 use nihav_core::soundcvt::*;
  16 use nihav_registry::detect;
  17 use nihav_registry::register;
  18 use nihav_allstuff::*;
  19 use std::env;
  20
  21 mod null;
  22 use crate::null::*;
  23
  24 fn print_options(name: &str, options: &[NAOptionDefinition]) {
  25     if options.is_empty() {
  26         println!("No custom options.");
  27     } else {
  28         println!("Options for '{}'", name);
  29         for opt in options.iter() {
  30             println!(" {}", opt);
  31         }
  32     }
  33 }
  34
  35 struct OptionArgs {
  36     name:   String,
  37     value:  Option<String>,
  38 }
  39
  40 struct InputStreamOptions {
  41     id:             u32,
  42     drop:           bool,
  43     dec_opts:       Vec<OptionArgs>,
  44 }
  45
  46 struct OutputStreamOptions {
  47     id:             u32,
  48     enc_params:     EncodeParameters,
  49     enc_name:       String,
  50     enc_opts:       Vec<OptionArgs>,
  51 }
  52
  53 enum OutputConvert {
  54     Video(NAScale, NABufferType),
  55     Audio(NAAudioInfo, NAChannelMap),
  56     None,
  57 }
  58
  59 enum OutputMode {
  60     Drop,
  61     Copy(u32),
  62     Encode(u32, Box<dyn NAEncoder>, OutputConvert),
  63 }
  64
  65 #[derive(Default)]
  66 struct Transcoder {
  67     input_name:     String,
  68     input_fmt:      Option<String>,
  69     output_name:    String,
  70     output_fmt:     Option<String>,
  71     demux_opts:     Vec<OptionArgs>,
  72     mux_opts:       Vec<OptionArgs>,
  73     istr_opts:      Vec<InputStreamOptions>,
  74     ostr_opts:      Vec<OutputStreamOptions>,
  75     decoders:       Vec<Option<(Box<NADecoderSupport>, Box<dyn NADecoder>, Box<dyn FrameReorderer>)>>,
  76     encoders:       Vec<OutputMode>,
  77     no_video:       bool,
  78     no_audio:       bool,
  79     start:          NATimePoint,
  80     end:            NATimePoint,
  81 }
  82
  83 macro_rules! parse_and_apply_options {
  84     ($obj: expr, $in_opts: expr, $name: expr) => {
  85         let mut opts = Vec::with_capacity($in_opts.len());
  86         let opt_def = $obj.get_supported_options();
  87         for opt in $in_opts.iter() {
  88             let mut found = false;
  89             for opt_def in opt_def.iter() {
  90                 if opt.name == opt_def.name {
  91                     let arg = if let Some(ref str) = opt.value { Some(str) } else { None };
  92                     let ret = opt_def.parse(&opt.name, arg);
  93                     if ret.is_err() {
  94                         println!("invalid option {} for {}", opt.name, $name);
  95                     } else {
  96                         let (val, _) = ret.unwrap();
  97                         opts.push(val);
  98                     }
  99                     found = true;
 100                 }
 101             }
 102             if !found {
 103                 println!("  ignoring option '{}' for {}", opt.name, $name);
 104             }
 105         }
 106         $obj.set_options(opts.as_slice());
 107     }
 108 }
 109
 110 impl Transcoder {
 111     fn new() -> Self { Self::default() }
 112     fn parse_istream_options(&mut self, opt0: &str, opt1: &str) -> bool {
 113         let (_, strno) = opt0.split_at(9);
 114         let ret = strno.parse::<u32>();
 115         if ret.is_err() { return false; }
 116         let streamno = ret.unwrap();
 117
 118         let sidx = if let Some(idx) = self.istr_opts.iter().position(|str| str.id == streamno) {
 119                 idx
 120             } else {
 121                 self.istr_opts.push(InputStreamOptions {id: streamno, drop: false, dec_opts: Vec::new() });
 122                 self.istr_opts.len() - 1
 123             };
 124         let istr = &mut self.istr_opts[sidx];
 125
 126         for opt in opt1.split(',') {
 127             let oval: Vec<_> = opt.split('=').collect();
 128             if oval.len() == 1 {
 129                 match oval[0] {
 130                     "drop" => { istr.drop = true; },
 131                     _ => {
 132                         istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
 133                     },
 134                 };
 135             } else if oval.len() == 2 {
 136                 istr.dec_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 137             } else {
 138                 println!("unrecognized option '{}'", opt);
 139             }
 140         }
 141         true
 142     }
 143     fn parse_ostream_options(&mut self, opt0: &str, opt1: &str, enc_reg: &RegisteredEncoders) -> bool {
 144         let (_, strno) = opt0.split_at(9);
 145         let ret = strno.parse::<u32>();
 146         if ret.is_err() { return false; }
 147         let streamno = ret.unwrap();
 148
 149         let sidx = if let Some(idx) = self.ostr_opts.iter().position(|str| str.id == streamno) {
 150                 idx
 151             } else {
 152                 self.ostr_opts.push(OutputStreamOptions {id: streamno, enc_name: String::new(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() });
 153                 self.ostr_opts.len() - 1
 154             };
 155         let ostr = &mut self.ostr_opts[sidx];
 156
 157         for opt in opt1.split(',') {
 158             let oval: Vec<_> = opt.split('=').collect();
 159             if oval.len() == 1 {
 160                 match oval[0] {
 161                     "flip" => {
 162                         if ostr.enc_params.format == NACodecTypeInfo::None {
 163                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 164                         }
 165                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 166                             vinfo.flipped = true;
 167                         } else {
 168                             println!("video option for audio stream");
 169                         }
 170                     },
 171                     "noflip" => {
 172                         if ostr.enc_params.format == NACodecTypeInfo::None {
 173                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 174                         }
 175                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 176                             vinfo.flipped = false;
 177                         } else {
 178                             println!("video option for audio stream");
 179                         }
 180                     },
 181                     _ => {
 182                         ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
 183                     },
 184                 };
 185             } else if oval.len() == 2 {
 186 //todo parse encoder options, store, init later
 187                 match oval[0] {
 188                     "encoder" => {
 189                         if enc_reg.find_encoder(oval[1]).is_some() {
 190                             ostr.enc_name = oval[1].to_string();
 191                         } else {
 192                             println!("unknown encoder '{}'", oval[1]);
 193                             ostr.enc_name = oval[1].to_string();
 194                         }
 195                     },
 196                     "width" => {
 197                         if ostr.enc_params.format == NACodecTypeInfo::None {
 198                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 199                         }
 200                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 201                             let ret = oval[1].parse::<usize>();
 202                             if let Ok(val) = ret {
 203                                 vinfo.width = val;
 204                             } else {
 205                                 println!("invalid width");
 206                             }
 207                         } else {
 208                             println!("video option for audio stream");
 209                         }
 210                     },
 211                     "height" => {
 212                         if ostr.enc_params.format == NACodecTypeInfo::None {
 213                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 214                         }
 215                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 216                             let ret = oval[1].parse::<usize>();
 217                             if let Ok(val) = ret {
 218                                 vinfo.height = val;
 219                             } else {
 220                                 println!("invalid height");
 221                             }
 222                         } else {
 223                             println!("video option for audio stream");
 224                         }
 225                     },
 226                     "pixfmt" => {
 227                         if ostr.enc_params.format == NACodecTypeInfo::None {
 228                             ostr.enc_params.format = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, YUV420_FORMAT));
 229                         }
 230                         if let NACodecTypeInfo::Video(ref mut vinfo) = ostr.enc_params.format {
 231                             let ret = oval[1].parse::<NAPixelFormaton>();
 232                             if let Ok(val) = ret {
 233                                 vinfo.format = val;
 234                             } else {
 235                                 println!("invalid pixel format");
 236                             }
 237                         } else {
 238                             println!("video option for audio stream");
 239                         }
 240                     },
 241                     "srate" => {
 242                         if ostr.enc_params.format == NACodecTypeInfo::None {
 243                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_S16_FORMAT, 0));
 244                         }
 245                         if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
 246                             let ret = oval[1].parse::<u32>();
 247                             if let Ok(val) = ret {
 248                                 ainfo.sample_rate = val;
 249                             } else {
 250                                 println!("invalid sampling rate");
 251                             }
 252                         } else {
 253                             println!("audio option for video stream");
 254                         }
 255                     },
 256                     "channels" => {
 257                         if ostr.enc_params.format == NACodecTypeInfo::None {
 258                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_S16_FORMAT, 0));
 259                         }
 260                         if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
 261                             let ret = oval[1].parse::<u8>();
 262                             if let Ok(val) = ret {
 263                                 ainfo.channels = val;
 264                             } else {
 265                                 println!("invalid number of channels");
 266                             }
 267                         } else {
 268                             println!("audio option for video stream");
 269                         }
 270                     },
 271                     "block_len" => {
 272                         if ostr.enc_params.format == NACodecTypeInfo::None {
 273                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_S16_FORMAT, 0));
 274                         }
 275                         if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
 276                             let ret = oval[1].parse::<usize>();
 277                             if let Ok(val) = ret {
 278                                 ainfo.block_len = val;
 279                             } else {
 280                                 println!("invalid block_length");
 281                             }
 282                         } else {
 283                             println!("audio option for video stream");
 284                         }
 285                     },
 286                     "sfmt" => {
 287                         if ostr.enc_params.format == NACodecTypeInfo::None {
 288                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_S16_FORMAT, 0));
 289                         }
 290                         if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
 291                             let ret = oval[1].parse::<NASoniton>();
 292                             if let Ok(val) = ret {
 293                                 ainfo.format = val;
 294                             } else {
 295                                 println!("invalid audio format");
 296                             }
 297                         } else {
 298                             println!("audio option for video stream");
 299                         }
 300                     },
 301 // todo channel map negotiation
 302                     /*"chmap" => {
 303                         if ostr.enc_params.format == NACodecTypeInfo::None {
 304                             ostr.enc_params.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 0, SND_S16_FORMAT, 0));
 305                         }
 306                         if let NACodecTypeInfo::Audio(ref mut ainfo) = ostr.enc_params.format {
 307                             let ret = oval[1].parse::<NAChannelMap>();
 308                             if let Ok(val) = ret {
 309                                 ainfo.chmap = val;
 310                             } else {
 311                                 println!("invalid channel map");
 312                             }
 313                         } else {
 314                             println!("audio option for video stream");
 315                         }
 316                     },*/
 317                     "bitrate" => {
 318                         let ret = oval[1].parse::<u32>();
 319                         if let Ok(val) = ret {
 320                             ostr.enc_params.bitrate = val;
 321                         } else {
 322                             println!("invalid bitrate value");
 323                         }
 324                     },
 325                     "quality" => {
 326                         let ret = oval[1].parse::<u8>();
 327                         if let Ok(val) = ret {
 328                             ostr.enc_params.quality = val;
 329                         } else {
 330                             println!("invalid quality value");
 331                         }
 332                     },
 333                     _ => {
 334                         ostr.enc_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 335                     },
 336                 }
 337             } else {
 338                 println!("unrecognized option '{}'", opt);
 339             }
 340         }
 341         true
 342     }
 343     fn parse_demuxer_options(&mut self, opts: &str, dmx_reg: &RegisteredDemuxers) -> bool {
 344         for opt in opts.split(',') {
 345             let oval: Vec<_> = opt.split('=').collect();
 346             if oval.len() == 1 {
 347                 self.demux_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
 348             } else if oval.len() == 2 {
 349                 if oval[0] == "format" {
 350                     if dmx_reg.find_demuxer(oval[1]).is_some() {
 351                         self.input_fmt = Some(oval[1].to_string());
 352                     } else {
 353                         println!("unknown demuxer format '{}'", oval[1]);
 354                     }
 355                 } else {
 356                     self.demux_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 357                 }
 358             } else {
 359                 println!("unrecognized option '{}'", opt);
 360             }
 361         }
 362         true
 363     }
 364     fn parse_muxer_options(&mut self, opts: &str, mux_reg: &RegisteredMuxers) -> bool {
 365         for opt in opts.split(',') {
 366             let oval: Vec<_> = opt.split('=').collect();
 367             if oval.len() == 1 {
 368                 self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: None });
 369             } else if oval.len() == 2 {
 370                 if oval[0] == "format" {
 371                     if mux_reg.find_muxer(oval[1]).is_some() {
 372                         self.output_fmt = Some(oval[1].to_string());
 373                     } else {
 374                         println!("unknown muxer format '{}'", oval[1]);
 375                     }
 376                 } else {
 377                     self.mux_opts.push(OptionArgs{ name: oval[0].to_string(), value: Some(oval[1].to_string()) });
 378                 }
 379             } else {
 380                 println!("unrecognized option '{}'", opt);
 381             }
 382         }
 383         true
 384     }
 385     fn apply_decoder_options(&self, dec: &mut NADecoder, str_id: u32) {
 386         if let Some(str_idx) = self.istr_opts.iter().position(|str| str.id == str_id) {
 387             let dec_opts = dec.get_supported_options();
 388             if dec_opts.is_empty() { return; }
 389             let name = format!("input stream {}", str_id);
 390             parse_and_apply_options!(dec, &self.istr_opts[str_idx].dec_opts, name);
 391         }
 392     }
 393     fn register_output_stream(&mut self, cname: &str, istr: NAStreamRef, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
 394         let out_id = out_sm.get_num_streams() as u32;
 395         if let Some(str_idx) = self.istr_opts.iter().position(|str| str.id == (istr.get_num() as u32)) {
 396             if self.istr_opts[str_idx].drop {
 397                 self.encoders.push(OutputMode::Drop);
 398                 return true;
 399             }
 400         }
 401
 402         if let Some(str_idx) = self.ostr_opts.iter().position(|str| str.id == out_id) {
 403             let oopts = &mut self.ostr_opts[str_idx];
 404             if oopts.enc_name.as_str() == "copy" && (cname == "any" || istr.get_info().get_name() == cname) {
 405                 out_sm.add_stream_ref(istr.clone());
 406                 self.encoders.push(OutputMode::Copy(out_id));
 407             } else if cname == "any" || oopts.enc_name.as_str() == cname {
 408                 let enc_create = enc_reg.find_encoder(oopts.enc_name.as_str());
 409                 if enc_create.is_none() {
 410                     println!("encoder '{}' not found", oopts.enc_name.as_str());
 411                     return false;
 412                 }
 413                 let mut encoder = (enc_create.unwrap())();
 414                 let forced_out = oopts.enc_params.format != NACodecTypeInfo::None;
 415                 if oopts.enc_params.format == NACodecTypeInfo::None {
 416                     oopts.enc_params.format = istr.get_info().get_properties();
 417                 }
 418                 if oopts.enc_params.tb_num == 0 {
 419                     oopts.enc_params.tb_num = istr.tb_num;
 420                     oopts.enc_params.tb_den = istr.tb_den;
 421                 }
 422                 let ret_eparams = encoder.negotiate_format(&oopts.enc_params);
 423                 if ret_eparams.is_err() {
 424                     println!("cannot negotiate encoding parameters");
 425                     return false;
 426                 }
 427                 let ret_eparams = ret_eparams.unwrap();
 428
 429 //todo check for params mismatch
 430                 let cvt = match (&oopts.enc_params.format, &ret_eparams.format) {
 431                         (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => {
 432                             if svinfo == dvinfo && !forced_out {
 433                                 OutputConvert::None
 434                             } else {
 435                                 let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height };
 436                                 let ret = NAScale::new(ofmt, ofmt);
 437                                 if ret.is_err() {
 438                                     println!("cannot create scaler");
 439                                     return false;
 440                                 }
 441                                 let scaler = ret.unwrap();
 442                                 let ret = alloc_video_buffer(*dvinfo, 4);
 443                                 if ret.is_err() {
 444                                     println!("cannot create scaler buffer");
 445                                     return false;
 446                                 }
 447                                 let cvt_buf = ret.unwrap();
 448                                 OutputConvert::Video(scaler, cvt_buf)
 449                             }
 450                         },
 451                         (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => {
 452                             if sainfo == dainfo {
 453                                 OutputConvert::None
 454                             } else {
 455                                 let dchmap = match dainfo.channels {
 456                                         1 => NAChannelMap::from_ms_mapping(0x4),
 457                                         2 => NAChannelMap::from_ms_mapping(0x3),
 458                                         _ => {
 459 println!("can't generate default channel map for {} channels", dainfo.channels);
 460                                             return false;
 461                                         },
 462                                     };
 463 //todo channelmap
 464                                 OutputConvert::Audio(*dainfo, dchmap)
 465                             }
 466                         },
 467                         _ => OutputConvert::None,
 468                     };
 469                 let ret = encoder.init(out_id, ret_eparams);
 470                 if ret.is_err() {
 471                     println!("error initialising encoder");
 472                     return false;
 473                 }
 474                 out_sm.add_stream_ref(ret.unwrap());
 475
 476                 let name = format!("output stream {}", out_id);
 477                 parse_and_apply_options!(encoder, &oopts.enc_opts, name);
 478
 479                 self.encoders.push(OutputMode::Encode(out_id, encoder, cvt));
 480             } else {
 481 println!("encoder {} is not supported by output (expected {})", istr.id, istr.get_info().get_name());
 482                 return false;
 483             }
 484         } else {
 485             if cname == "any" || istr.get_info().get_name() == cname {
 486                 out_sm.add_stream_ref(istr.clone());
 487                 self.encoders.push(OutputMode::Copy(out_id));
 488             } else {
 489 println!("stream {} ({}) can't be handled", istr.id, istr.get_info().get_name());
 490 // todo autoselect encoder?
 491                 return false;
 492             }
 493         }
 494         true
 495     }
 496     fn map_single(&mut self, cname: &str, ctype: StreamType, src_sm: &StreamManager, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
 497         let mut found_stream = false;
 498         for istr in src_sm.iter() {
 499             if istr.get_media_type() != ctype || found_stream {
 500                 self.encoders.push(OutputMode::Drop);
 501             } else {
 502                 if !self.register_output_stream(cname, istr, out_sm, enc_reg) {
 503                     return false;
 504                 }
 505                 found_stream = true;
 506             }
 507         }
 508         found_stream
 509     }
 510     fn negotiate_stream_map(&mut self, src_sm: &StreamManager, mux_caps: MuxerCapabilities, out_sm: &mut StreamManager, enc_reg: &RegisteredEncoders) -> bool {
 511         match mux_caps {
 512             MuxerCapabilities::SingleVideo(cname) => {
 513                 if self.no_video { return false; }
 514                 self.map_single(cname, StreamType::Video, src_sm, out_sm, enc_reg)
 515             },
 516             MuxerCapabilities::SingleAudio(cname) => {
 517                 if self.no_audio { return false; }
 518                 self.map_single(cname, StreamType::Audio, src_sm, out_sm, enc_reg)
 519             },
 520             MuxerCapabilities::SingleVideoAndAudio(vname, aname) => {
 521                 let mut found_vid = false;
 522                 let mut found_aud = false;
 523                 for istr in src_sm.iter() {
 524                     if istr.get_media_type() == StreamType::Video && !found_vid && !self.no_video {
 525                         if !self.register_output_stream(vname, istr, out_sm, enc_reg) {
 526                             return false;
 527                         }
 528                         found_vid = true;
 529                     } else if istr.get_media_type() == StreamType::Audio && !found_aud && !self.no_audio {
 530                         if !self.register_output_stream(aname, istr, out_sm, enc_reg) {
 531                             return false;
 532                         }
 533                         found_aud = true;
 534                     } else {
 535                         self.encoders.push(OutputMode::Drop);
 536                     }
 537                 }
 538                 found_vid | found_aud
 539             },
 540             MuxerCapabilities::OnlyVideo => {
 541                 if self.no_video { return false; }
 542
 543                 let mut found_vid = false;
 544                 for istr in src_sm.iter() {
 545                     if istr.get_media_type() == StreamType::Video && !found_vid {
 546                         if !self.register_output_stream("any", istr, out_sm, enc_reg) {
 547                             return false;
 548                         }
 549                         found_vid = true;
 550                     } else {
 551                         self.encoders.push(OutputMode::Drop);
 552                     }
 553                 }
 554                 found_vid
 555             },
 556             MuxerCapabilities::OnlyAudio => {
 557                 if self.no_audio { return false; }
 558
 559                 let mut found_aud = false;
 560                 for istr in src_sm.iter() {
 561                     if istr.get_media_type() == StreamType::Audio && !found_aud {
 562                         if !self.register_output_stream("any", istr, out_sm, enc_reg) {
 563                             return false;
 564                         }
 565                         found_aud = true;
 566                     } else {
 567                         self.encoders.push(OutputMode::Drop);
 568                     }
 569                 }
 570                 found_aud
 571             },
 572             MuxerCapabilities::Universal => {
 573                 for istr in src_sm.iter() {
 574                     if (istr.get_media_type() == StreamType::Video && self.no_video) ||
 575                         (istr.get_media_type() == StreamType::Audio && self.no_audio) {
 576                         self.encoders.push(OutputMode::Drop);
 577                         continue;
 578                     }
 579                     if !self.register_output_stream("any", istr, out_sm, enc_reg) {
 580                         return false;
 581                     }
 582                 }
 583                 true
 584             },
 585         }
 586     }
 587 }
 588
 589 fn encode_frame(dst_id: u32, encoder: &mut Box<NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef) -> bool {
 590     let buf = frm.get_buffer();
 591     let cbuf = match cvt {
 592             OutputConvert::None => buf,
 593             OutputConvert::Video(ref mut scaler, ref mut dbuf) => {
 594                 let cur_ifmt = get_scale_fmt_from_pic(&buf);
 595                 let last_ifmt = scaler.get_in_fmt();
 596                 if cur_ifmt != last_ifmt {
 597                     let ofmt = scaler.get_out_fmt();
 598                     let ret = NAScale::new(cur_ifmt, ofmt);
 599                     if ret.is_err() {
 600                         println!("error re-initialising scaler for {} -> {}", cur_ifmt, ofmt);
 601                         return false;
 602                     }
 603                     *scaler = ret.unwrap();
 604                 }
 605                 let ret = scaler.convert(&buf, dbuf);
 606                 if ret.is_err() {
 607                     println!("error converting frame for encoding");
 608                     return false;
 609                 }
 610                 dbuf.clone()
 611             },
 612             OutputConvert::Audio(ref dinfo, ref dchmap) => {
 613                 let ret = convert_audio_frame(&buf, dinfo, dchmap);
 614                 if ret.is_err() {
 615                     println!("error converting audio for stream {}", dst_id);
 616                     return false;
 617                 }
 618                 ret.unwrap()
 619             },
 620         };
 621     let cfrm = NAFrame::new(frm.get_time_information(), frm.frame_type, frm.key, frm.get_info(), cbuf);
 622     encoder.encode(&cfrm).unwrap();
 623     true
 624 }
 625
 626 macro_rules! next_arg {
 627     ($args: expr, $arg_idx: expr) => {
 628         if $arg_idx + 1 >= $args.len() {
 629             println!("codec name is required");
 630         }
 631         $arg_idx += 1;
 632     }
 633 }
 634
 635 fn main() {
 636     let args: Vec<_> = env::args().collect();
 637
 638     if args.len() == 1 {
 639         println!("usage: nihav-encoder [-noout] [-vn] [-an] input [lastpts]");
 640         return;
 641     }
 642
 643     let mut dmx_reg = RegisteredDemuxers::new();
 644     nihav_register_all_demuxers(&mut dmx_reg);
 645     let mut dec_reg = RegisteredDecoders::new();
 646     nihav_register_all_decoders(&mut dec_reg);
 647
 648     let mut mux_reg = RegisteredMuxers::new();
 649     nihav_register_all_muxers(&mut mux_reg);
 650     mux_reg.add_muxer(NULL_MUXER);
 651     let mut enc_reg = RegisteredEncoders::new();
 652     nihav_register_all_encoders(&mut enc_reg);
 653     enc_reg.add_encoder(NULL_ENCODER);
 654
 655     let mut transcoder = Transcoder::new();
 656
 657     let mut arg_idx = 1;
 658     let mut printed_info = false;
 659     while arg_idx < args.len() {
 660         match args[arg_idx].as_str() {
 661             "--list-decoders" => {
 662                 if dec_reg.iter().len() > 0 {
 663                     println!("Registered decoders:");
 664                     for dec in dec_reg.iter() {
 665                         let cdesc = register::get_codec_description(dec.name);
 666                         let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
 667                         println!(" {} ({})", dec.name, full_name);
 668                     }
 669                 } else {
 670                     println!("No registered decoders.");
 671                 }
 672                 printed_info = true;
 673             },
 674             "--list-encoders" => {
 675                 if enc_reg.iter().len() > 0 {
 676                     println!("Registered encoders:");
 677                     for enc in enc_reg.iter() {
 678                         let cdesc = register::get_codec_description(enc.name);
 679                         let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" };
 680                         println!(" {} ({})", enc.name, full_name);
 681                     }
 682                 } else {
 683                     println!("No registered encoders.");
 684                 }
 685                 printed_info = true;
 686             },
 687             "--list-demuxers" => {
 688                 print!("Registered demuxers:");
 689                 for dmx in dmx_reg.iter() {
 690                     print!(" {}", dmx.get_name());
 691                 }
 692                 println!();
 693                 printed_info = true;
 694             },
 695             "--list-muxers" => {
 696                 print!("Registered muxers:");
 697                 for mux in mux_reg.iter() {
 698                     print!(" {}", mux.get_name());
 699                 }
 700                 println!();
 701                 printed_info = true;
 702             },
 703             "--query-decoder-options" => {
 704                 next_arg!(args, arg_idx);
 705                 let cname = args[arg_idx].as_str();
 706                 if let Some(decfunc) = dec_reg.find_decoder(cname) {
 707                     let dec = (decfunc)();
 708                     let opts = dec.get_supported_options();
 709                     print_options(cname, opts);
 710                 } else {
 711                     println!("codec {} is not found", cname);
 712                 }
 713                 printed_info = true;
 714             },
 715             "--query-demuxer-options" => {
 716                 next_arg!(args, arg_idx);
 717                 let dname = args[arg_idx].as_str();
 718                 let mut mr = MemoryReader::new_read(&[]);
 719                 let mut br = ByteReader::new(&mut mr);
 720                 if let Some(dmx_creator) = dmx_reg.find_demuxer(dname) {
 721                     let dmx = dmx_creator.new_demuxer(&mut br);
 722                     let opts = dmx.get_supported_options();
 723                     print_options(dname, opts);
 724                 } else {
 725                     println!("demuxer {} is not found", dname);
 726                 }
 727                 printed_info = true;
 728             },
 729             "--query-encoder-options" => {
 730                 next_arg!(args, arg_idx);
 731                 let cname = args[arg_idx].as_str();
 732                 if let Some(encfunc) = enc_reg.find_encoder(cname) {
 733                     let enc = (encfunc)();
 734                     let opts = enc.get_supported_options();
 735                     print_options(cname, opts);
 736                 } else {
 737                     println!("codec {} is not found", cname);
 738                 }
 739                 printed_info = true;
 740             },
 741             "--query-muxer-options" => {
 742                 next_arg!(args, arg_idx);
 743                 let name = args[arg_idx].as_str();
 744                 let mut data = [];
 745                 let mut mw = MemoryWriter::new_write(&mut data);
 746                 let mut bw = ByteWriter::new(&mut mw);
 747                 if let Some(mux_creator) = mux_reg.find_muxer(name) {
 748                     let mux = mux_creator.new_muxer(&mut bw);
 749                     let opts = mux.get_supported_options();
 750                     print_options(name, opts);
 751                 } else {
 752                     println!("muxer {} is not found", name);
 753                 }
 754                 printed_info = true;
 755             },
 756             "--input" | "-i" => {
 757                 next_arg!(args, arg_idx);
 758                 transcoder.input_name = args[arg_idx].clone();
 759             },
 760             "--input-format" => {
 761                 next_arg!(args, arg_idx);
 762                 transcoder.input_fmt = Some(args[arg_idx].clone());
 763             },
 764             "--output" | "-o" => {
 765                 next_arg!(args, arg_idx);
 766                 transcoder.output_name = args[arg_idx].clone();
 767             },
 768             "--output-format" => {
 769                 next_arg!(args, arg_idx);
 770                 transcoder.output_fmt = Some(args[arg_idx].clone());
 771             },
 772             "--demuxer-options" => {
 773                 next_arg!(args, arg_idx);
 774                 if !transcoder.parse_demuxer_options(&args[arg_idx], &dmx_reg) {
 775                     println!("invalid demuxer option syntax");
 776                     return;
 777                 }
 778             },
 779             "--no-video" | "-vn" => {
 780                 transcoder.no_video = true;
 781             },
 782             "--no-audio" | "-an" => {
 783                 transcoder.no_audio = true;
 784             },
 785             "--start" => {
 786                 next_arg!(args, arg_idx);
 787                 let ret = args[arg_idx].parse::<NATimePoint>();
 788                 if let Ok(val) = ret {
 789                     transcoder.start = val;
 790                 } else {
 791                     println!("invalid start time");
 792                     return;
 793                 }
 794             },
 795             "--end" => {
 796                 next_arg!(args, arg_idx);
 797                 let ret = args[arg_idx].parse::<NATimePoint>();
 798                 if let Ok(val) = ret {
 799                     transcoder.end = val;
 800                 } else {
 801                     println!("invalid end time");
 802                     return;
 803                 }
 804             },
 805             "--muxer-options" => {
 806                 next_arg!(args, arg_idx);
 807                 if !transcoder.parse_muxer_options(&args[arg_idx], &mux_reg) {
 808                     println!("invalid muxer option syntax");
 809                     return;
 810                 }
 811             },
 812             _ => {
 813                 if args[arg_idx].starts_with("--istream") {
 814                     let opt0 = &args[arg_idx];
 815                     next_arg!(args, arg_idx);
 816                     if !transcoder.parse_istream_options(opt0, &args[arg_idx]) {
 817                         println!("invalid input stream option syntax");
 818                         return;
 819                     }
 820                 } else if args[arg_idx].starts_with("--ostream") {
 821                     let opt0 = &args[arg_idx];
 822                     next_arg!(args, arg_idx);
 823                     if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &enc_reg) {
 824                         println!("invalid output stream option syntax");
 825                         return;
 826                     }
 827                 } else if args[arg_idx].starts_with("--") {
 828                     println!("unknown option");
 829                 } else {
 830                     println!("unrecognized argument");
 831                 }
 832             },
 833         };
 834         arg_idx += 1;
 835     }
 836
 837     if printed_info {
 838         return;
 839     }
 840
 841     if transcoder.input_name.len() == 0 {
 842         println!("no input name provided");
 843         return;
 844     }
 845     if transcoder.output_name.len() == 0 {
 846         println!("no output name provided");
 847         return;
 848     }
 849
 850     let res = File::open(transcoder.input_name.as_str());
 851     if res.is_err() {
 852         println!("error opening input");
 853         return;
 854     }
 855     let mut file = res.unwrap();
 856     let mut fr = FileReader::new_read(&mut file);
 857     let mut br = ByteReader::new(&mut fr);
 858
 859     let dmx_name = if let Some(ref str) = transcoder.input_fmt {
 860             str.as_str()
 861         } else {
 862             if let Some((dmx_name, score)) = detect::detect_format(transcoder.input_name.as_str(), &mut br) {
 863                 println!("detected {} with score {:?}", dmx_name, score);
 864                 dmx_name
 865             } else {
 866                 println!("cannot detect input format");
 867                 return;
 868             }
 869         };
 870     let ret = dmx_reg.find_demuxer(dmx_name);
 871     if ret.is_none() {
 872         println!("cannot find demuxer for '{}'", dmx_name);
 873         return;
 874     }
 875     let dmx_fact = ret.unwrap();
 876     br.seek(SeekFrom::Start(0)).unwrap();
 877     let mut dmx = create_demuxer(dmx_fact, &mut br).unwrap();
 878     parse_and_apply_options!(dmx, &transcoder.demux_opts, "input");
 879     for i in 0..dmx.get_num_streams() {
 880         let s = dmx.get_stream(i).unwrap();
 881         let info = s.get_info();
 882         let decfunc = dec_reg.find_decoder(info.get_name());
 883 println!("stream {} - {} {}", i, s, info.get_name());
 884         let str_id = s.get_num() as u32;
 885         if let Some(create_dec) = decfunc {
 886             let mut dec = (create_dec)();
 887             let mut dsupp = Box::new(NADecoderSupport::new());
 888             let ret = dec.init(&mut dsupp, info.clone());
 889             if ret.is_err() {
 890                 println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
 891                 return;
 892             }
 893             transcoder.apply_decoder_options(dec.as_mut(), str_id);
 894             let desc = register::get_codec_description(info.get_name());
 895             let has_b = if let Some(desc) = desc {
 896                     desc.has_reorder()
 897                 } else {
 898                     println!("No codec description found, using B-frame reorderer.");
 899                     true
 900                 };
 901             let reord: Box<dyn FrameReorderer> = if has_b { Box::new(IPBReorderer::new()) } else { Box::new(NoReorderer::new()) };
 902             transcoder.decoders.push(Some((dsupp, dec, reord)));
 903         } else {
 904             println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
 905             transcoder.decoders.push(None);
 906         }
 907     }
 908     if transcoder.start != NATimePoint::None {
 909         let ret = dmx.seek(transcoder.start);
 910         if ret.is_err() {
 911             println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
 912         }
 913     }
 914
 915     let output_fmt = if let Some(ref str) = transcoder.output_fmt {
 916             str
 917         } else {
 918             if let Some(str) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
 919                 str
 920             } else {
 921                 println!("Cannot guess muxer for output");
 922                 return;
 923             }
 924         };
 925     let ret = mux_reg.find_muxer(output_fmt);
 926     let ofmt = output_fmt.to_string();
 927
 928     if ret.is_none() {
 929         println!("cannot find muxer '{}'", output_fmt);
 930     }
 931     let mux_creator = ret.unwrap();
 932
 933     let mux_caps = mux_creator.get_capabilities();
 934     let mut out_sm = StreamManager::new();
 935     if !transcoder.negotiate_stream_map(dmx.get_stream_manager(), mux_caps, &mut out_sm, &enc_reg) {
 936         println!("cannot determine stream map");
 937         return;
 938     }
 939
 940     let ret = File::create(transcoder.output_name.as_str());
 941     if ret.is_err() {
 942         println!("cannot open output file");
 943         return;
 944     }
 945     let mut fw = FileWriter::new_write(ret.unwrap());
 946     let mut bw = ByteWriter::new(&mut fw);
 947     let ret = create_muxer(mux_creator, out_sm, &mut bw);
 948     if let Err(err) = ret {
 949         println!("cannot create muxer instance {:?}", err);
 950         return;
 951     }
 952     let mut mux = ret.unwrap();
 953     parse_and_apply_options!(mux, &transcoder.mux_opts, "output");
 954
 955     println!("Output {} muxer {}", transcoder.output_name, ofmt);
 956     for ostr in mux.get_streams() {
 957         println!(" #{}: {} {}", ostr.get_num(), ostr, ostr.get_info().get_name());
 958     }
 959
 960     'main_loop: loop {
 961         let pktres = dmx.get_frame();
 962         if let Err(DemuxerError::EOF) = pktres { break; }
 963         if pktres.is_err() {
 964             println!("demuxing error");
 965             break;
 966         }
 967         let mut pkt = pktres.unwrap();
 968         if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; }
 969         let src_id = pkt.get_stream().get_num();
 970         match transcoder.encoders[src_id] {
 971             OutputMode::Drop => {},
 972             OutputMode::Copy(dst_id) => {
 973                 let dstr = mux.get_stream(dst_id as usize).unwrap();
 974                 pkt.reassign(dstr, pkt.get_time_information());
 975                 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
 976                 if mux.mux_frame(pkt).is_err() {
 977                     println!("error muxing packet");
 978                     break;
 979                 }
 980             },
 981             OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) => {
 982                 if let Some((ref mut dsupp, ref mut decoder, ref mut reorderer)) = transcoder.decoders[src_id] {
 983                     let ret = decoder.decode(dsupp, &pkt);
 984                     if let (true, Err(DecoderError::MissingReference)) = (transcoder.start != NATimePoint::None, &ret) {
 985                         continue;
 986                     }
 987                     if ret.is_err() {
 988                         println!("error decoding stream {}", src_id);
 989                         break;
 990                     }
 991                     let frm = ret.unwrap();
 992                     reorderer.add_frame(frm);
 993                     while let Some(frm) = reorderer.get_frame() {
 994                         if !encode_frame(dst_id, encoder, cvt, frm) {
 995                             break;
 996                         }
 997                         while let Ok(Some(pkt)) = encoder.get_packet() {
 998                             if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
 999                             mux.mux_frame(pkt).unwrap();
1000                         }
1001                     }
1002                 } else {
1003                     println!("no decoder for stream {}", src_id);
1004                     break;
1005                 }
1006             },
1007         };
1008     }
1009     'reord_flush_loop: for str in dmx.get_streams() {
1010         let src_id = str.get_num();
1011         if let OutputMode::Encode(dst_id, ref mut encoder, ref mut cvt) = transcoder.encoders[src_id] {
1012             if let Some((_, _, ref mut reorderer)) = transcoder.decoders[src_id] {
1013                 while let Some(frm) = reorderer.get_last_frames() {
1014                     if !encode_frame(dst_id, encoder, cvt, frm) {
1015                         break;
1016                     }
1017                     while let Ok(Some(pkt)) = encoder.get_packet() {
1018                         if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'reord_flush_loop; }
1019                         mux.mux_frame(pkt).unwrap();
1020                     }
1021                 }
1022             }
1023         }
1024     }
1025     'flush_loop: for enc in transcoder.encoders.iter_mut() {
1026         match enc {
1027             OutputMode::Encode(str_id, ref mut encoder, _) => {
1028                 let ret = encoder.flush();
1029                 if ret.is_err() {
1030                     println!("error flushing encoder for stream {}", str_id);
1031                     break;
1032                 } else {
1033                     while let Ok(Some(pkt)) = encoder.get_packet() {
1034                         if mux.mux_frame(pkt).is_err() {
1035                             println!("error muxing packet");
1036                             break 'flush_loop;
1037                         }
1038                     }
1039                 }
1040             },
1041             _ => {},
1042         };
1043     }
1044
1045     let ret = mux.end();
1046     if ret.is_err() {
1047         println!("error at finalising muxing");
1048     }
1049 }