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