None,
}
+#[allow(clippy::large_enum_variant)]
enum OutputMode {
Drop,
Copy(u32),
}
#[derive(Default)]
+#[allow(clippy::type_complexity)]
struct Transcoder {
input_name: String,
input_fmt: Option<String>,
if opt.name == opt_def.name {
let arg = if let Some(ref str) = opt.value { Some(str) } else { None };
let ret = opt_def.parse(&opt.name, arg);
- if ret.is_err() {
- println!("invalid option {} for {}", opt.name, $name);
- } else {
- let (val, _) = ret.unwrap();
+ if let Ok((val, _)) = ret {
opts.push(val);
+ } else {
+ println!("invalid option {} for {}", opt.name, $name);
}
found = true;
}
}
true
}
- fn apply_decoder_options(&self, dec: &mut NADecoder, str_id: u32) {
+ fn apply_decoder_options(&self, dec: &mut dyn NADecoder, str_id: u32) {
if let Some(str_idx) = self.istr_opts.iter().position(|str| str.id == str_id) {
let dec_opts = dec.get_supported_options();
if dec_opts.is_empty() { return; }
if let Some(str_idx) = self.ostr_opts.iter().position(|str| str.id == out_id) {
let oopts = &mut self.ostr_opts[str_idx];
if oopts.enc_name.as_str() == "copy" && (cname == "any" || istr.get_info().get_name() == cname) {
- out_sm.add_stream_ref(istr.clone());
+ out_sm.add_stream_ref(istr);
self.encoders.push(OutputMode::Copy(out_id));
} else if cname == "any" || oopts.enc_name.as_str() == cname {
let enc_create = enc_reg.find_encoder(oopts.enc_name.as_str());
println!("encoder {} is not supported by output (expected {})", istr.id, istr.get_info().get_name());
return false;
}
+ } else if cname == "any" || istr.get_info().get_name() == cname {
+ out_sm.add_stream_ref(istr);
+ self.encoders.push(OutputMode::Copy(out_id));
} else {
- if cname == "any" || istr.get_info().get_name() == cname {
- out_sm.add_stream_ref(istr.clone());
- self.encoders.push(OutputMode::Copy(out_id));
- } else {
println!("stream {} ({}) can't be handled", istr.id, istr.get_info().get_name());
// todo autoselect encoder?
- return false;
- }
+ return false;
}
true
}
}
}
-fn encode_frame(dst_id: u32, encoder: &mut Box<NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef) -> bool {
+fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef) -> bool {
let buf = frm.get_buffer();
let cbuf = match cvt {
OutputConvert::None => buf,
}
}
+#[allow(clippy::single_match)]
fn main() {
let args: Vec<_> = env::args().collect();
if args.len() == 1 {
- println!("usage: nihav-encoder [-noout] [-vn] [-an] input [lastpts]");
+ println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
+ println!(" use nihav-encoder --help to list all available options");
+ return;
+ }
+ if args.len() == 2 && (args[1] == "--help" || args[1] == "-h") {
+ println!("usage: nihav-encoder [options] --input inputfile --output outputfile");
+ println!(" query options:");
+ println!(" --list-{{decoders,encoders,demuxers,muxers}} - lists all available decoders/encoders/demuxers/muxers");
+ println!(" --query-{{decoder,encoder,demuxer,muxer}}-options name - lists all options recognized by that decoder/encoder/demuxer/muxer");
+ println!(" processing options:");
+ println!(" --input inputfile - set input file");
+ println!(" --input-format fmt - force input format");
+ println!(" --demuxer-options options - set input demuxer options");
+ println!(" --output outputfile - set output file");
+ println!(" --output-format fmt - force output format");
+ println!(" --muxer-options options - set output muxer options");
+ println!(" --no-audio - do not decode audio streams");
+ println!(" --no-video - do not decode video streams");
+ println!(" --start starttime - start decoding from given position");
+ println!(" --end endtime - end decoding at given position");
+ println!(" --istreamX options - set options for input stream X");
+ println!(" --ostreamX options - set options for output stream X");
+ println!();
+ println!(" (de)muxer and stream options are passed as comma-separated list e.g. --ostream0 width=320,height=240,flip");
return;
}
return;
}
- if transcoder.input_name.len() == 0 {
+ if transcoder.input_name.is_empty() {
println!("no input name provided");
return;
}
- if transcoder.output_name.len() == 0 {
+ if transcoder.output_name.is_empty() {
println!("no output name provided");
return;
}
let dmx_name = if let Some(ref str) = transcoder.input_fmt {
str.as_str()
+ } else if let Some((dmx_name, score)) = detect::detect_format(transcoder.input_name.as_str(), &mut br) {
+ println!("detected {} with score {:?}", dmx_name, score);
+ dmx_name
} else {
- if let Some((dmx_name, score)) = detect::detect_format(transcoder.input_name.as_str(), &mut br) {
- println!("detected {} with score {:?}", dmx_name, score);
- dmx_name
- } else {
- println!("cannot detect input format");
- return;
- }
+ println!("cannot detect input format");
+ return;
};
let ret = dmx_reg.find_demuxer(dmx_name);
if ret.is_none() {
let output_fmt = if let Some(ref str) = transcoder.output_fmt {
str
+ } else if let Some(str) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
+ str
} else {
- if let Some(str) = detect::detect_format_by_name(transcoder.output_name.as_str()) {
- str
- } else {
- println!("Cannot guess muxer for output");
- return;
- }
+ println!("Cannot guess muxer for output");
+ return;
};
let ret = mux_reg.find_muxer(output_fmt);
let ofmt = output_fmt.to_string();