X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fmain.rs;h=191a8a6133c2d24175464ebc88995a6ba75ab317;hb=4dd9047c4ba7e1ee7f1e163e0c551d318497d6db;hp=0a36cc88da1c09579c9ec8da73ee75e675ce04c0;hpb=df37d3b1df616e2b0a13d49bf0a9fb639a1efe27;p=nihav-encoder.git diff --git a/src/main.rs b/src/main.rs index 0a36cc8..191a8a6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,6 +4,7 @@ extern crate nihav_registry; extern crate nihav_allstuff; use std::fs::File; +use std::io::{BufReader, Write}; use nihav_core::io::byteio::{FileReader, ByteReader}; use nihav_core::frame::*; use nihav_core::options::*; @@ -15,11 +16,28 @@ use nihav_core::scale::*; use nihav_core::soundcvt::*; use nihav_registry::detect; use nihav_registry::register; -use nihav_allstuff::*; use std::env; +use std::time::{Duration, Instant}; +mod demux; +use crate::demux::*; mod null; -use crate::null::*; + +fn format_time(ms: u64) -> String { + let s = ms / 1000; + let ds = (ms % 1000) / 100; + let (min, s) = (s / 60, s % 60); + let (h, min) = (min / 60, min % 60); + if h == 0 { + if min == 0 { + format!("{}.{}", s, ds) + } else { + format!("{}:{:02}.{}", min, s, ds) + } + } else { + format!("{}:{:02}:{:02}.{}", h, min, s, ds) + } +} fn print_options(name: &str, options: &[NAOptionDefinition]) { if options.is_empty() { @@ -81,6 +99,7 @@ struct Transcoder { no_audio: bool, start: NATimePoint, end: NATimePoint, + verbose: bool, } macro_rules! parse_and_apply_options { @@ -523,9 +542,72 @@ println!("encoder {} is not supported by output (expected {})", istr.id, istr.ge out_sm.add_stream_ref(istr); 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; + let mut oopts = OutputStreamOptions {id: out_id, enc_name: cname.to_owned(), enc_params: EncodeParameters::default(), enc_opts: Vec::new() }; + + let enc_create = enc_reg.find_encoder(cname); + if enc_create.is_none() { + println!("encoder '{}' not found", oopts.enc_name.as_str()); + return false; + } + let mut encoder = (enc_create.unwrap())(); + oopts.enc_params.format = istr.get_info().get_properties(); + oopts.enc_params.tb_num = istr.tb_num; + oopts.enc_params.tb_den = istr.tb_den; + let ret_eparams = encoder.negotiate_format(&oopts.enc_params); + if ret_eparams.is_err() { + println!("cannot negotiate encoding parameters"); + return false; + } + let ret_eparams = ret_eparams.unwrap(); + +//todo check for params mismatch + let cvt = match (&oopts.enc_params.format, &ret_eparams.format) { + (NACodecTypeInfo::Video(svinfo), NACodecTypeInfo::Video(dvinfo)) => { + if svinfo == dvinfo { + OutputConvert::None + } else { + let ofmt = ScaleInfo { fmt: dvinfo.format, width: dvinfo.width, height: dvinfo.height }; + let ret = NAScale::new_with_options(ofmt, ofmt, &self.scale_opts); + if ret.is_err() { + println!("cannot create scaler"); + return false; + } + let scaler = ret.unwrap(); + let ret = alloc_video_buffer(*dvinfo, 4); + if ret.is_err() { + println!("cannot create scaler buffer"); + return false; + } + let cvt_buf = ret.unwrap(); + OutputConvert::Video(scaler, cvt_buf) + } + }, + (NACodecTypeInfo::Audio(sainfo), NACodecTypeInfo::Audio(dainfo)) => { + if sainfo == dainfo { + OutputConvert::None + } else { + let dchmap = match dainfo.channels { + 1 => NAChannelMap::from_ms_mapping(0x4), + 2 => NAChannelMap::from_ms_mapping(0x3), + _ => { +println!("can't generate default channel map for {} channels", dainfo.channels); + return false; + }, + }; +//todo channelmap + OutputConvert::Audio(*dainfo, dchmap) + } + }, + _ => OutputConvert::None, + }; + let ret = encoder.init(out_id, ret_eparams); + if ret.is_err() { + println!("error initialising encoder"); + return false; + } + out_sm.add_stream_ref(ret.unwrap()); + self.encoders.push(OutputMode::Encode(out_id, encoder, cvt)); + self.ostr_opts.push(oopts); } true } @@ -683,6 +765,7 @@ fn main() { 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!(" --verbose - show time for the currently processed input"); println!(" --input inputfile - set input file"); println!(" --input-format fmt - force input format"); println!(" --demuxer-options options - set input demuxer options"); @@ -701,17 +784,7 @@ fn main() { return; } - let mut dmx_reg = RegisteredDemuxers::new(); - nihav_register_all_demuxers(&mut dmx_reg); - let mut dec_reg = RegisteredDecoders::new(); - nihav_register_all_decoders(&mut dec_reg); - - let mut mux_reg = RegisteredMuxers::new(); - nihav_register_all_muxers(&mut mux_reg); - mux_reg.add_muxer(NULL_MUXER); - let mut enc_reg = RegisteredEncoders::new(); - nihav_register_all_encoders(&mut enc_reg); - enc_reg.add_encoder(NULL_ENCODER); + let full_reg = FullRegister::new(); let mut transcoder = Transcoder::new(); @@ -720,9 +793,9 @@ fn main() { while arg_idx < args.len() { match args[arg_idx].as_str() { "--list-decoders" => { - if dec_reg.iter().len() > 0 { + if full_reg.dec_reg.iter().len() > 0 { println!("Registered decoders:"); - for dec in dec_reg.iter() { + for dec in full_reg.dec_reg.iter() { let cdesc = register::get_codec_description(dec.name); let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" }; println!(" {} ({})", dec.name, full_name); @@ -733,9 +806,9 @@ fn main() { printed_info = true; }, "--list-encoders" => { - if enc_reg.iter().len() > 0 { + if full_reg.enc_reg.iter().len() > 0 { println!("Registered encoders:"); - for enc in enc_reg.iter() { + for enc in full_reg.enc_reg.iter() { let cdesc = register::get_codec_description(enc.name); let full_name = if let Some(cd) = cdesc { cd.get_full_name() } else { "???" }; println!(" {} ({})", enc.name, full_name); @@ -747,7 +820,7 @@ fn main() { }, "--list-demuxers" => { print!("Registered demuxers:"); - for dmx in dmx_reg.iter() { + for dmx in full_reg.dmx_reg.iter() { print!(" {}", dmx.get_name()); } println!(); @@ -755,7 +828,7 @@ fn main() { }, "--list-muxers" => { print!("Registered muxers:"); - for mux in mux_reg.iter() { + for mux in full_reg.mux_reg.iter() { print!(" {}", mux.get_name()); } println!(); @@ -764,7 +837,7 @@ fn main() { "--query-decoder-options" => { next_arg!(args, arg_idx); let cname = args[arg_idx].as_str(); - if let Some(decfunc) = dec_reg.find_decoder(cname) { + if let Some(decfunc) = full_reg.dec_reg.find_decoder(cname) { let dec = (decfunc)(); let opts = dec.get_supported_options(); print_options(cname, opts); @@ -778,7 +851,7 @@ fn main() { let dname = args[arg_idx].as_str(); let mut mr = MemoryReader::new_read(&[]); let mut br = ByteReader::new(&mut mr); - if let Some(dmx_creator) = dmx_reg.find_demuxer(dname) { + if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) { let dmx = dmx_creator.new_demuxer(&mut br); let opts = dmx.get_supported_options(); print_options(dname, opts); @@ -790,7 +863,7 @@ fn main() { "--query-encoder-options" => { next_arg!(args, arg_idx); let cname = args[arg_idx].as_str(); - if let Some(encfunc) = enc_reg.find_encoder(cname) { + if let Some(encfunc) = full_reg.enc_reg.find_encoder(cname) { let enc = (encfunc)(); let opts = enc.get_supported_options(); print_options(cname, opts); @@ -805,7 +878,7 @@ fn main() { let mut data = []; let mut mw = MemoryWriter::new_write(&mut data); let mut bw = ByteWriter::new(&mut mw); - if let Some(mux_creator) = mux_reg.find_muxer(name) { + if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) { let mux = mux_creator.new_muxer(&mut bw); let opts = mux.get_supported_options(); print_options(name, opts); @@ -832,7 +905,7 @@ fn main() { }, "--demuxer-options" => { next_arg!(args, arg_idx); - if !transcoder.parse_demuxer_options(&args[arg_idx], &dmx_reg) { + if !transcoder.parse_demuxer_options(&args[arg_idx], &full_reg.dmx_reg) { println!("invalid demuxer option syntax"); return; } @@ -872,11 +945,12 @@ fn main() { }, "--muxer-options" => { next_arg!(args, arg_idx); - if !transcoder.parse_muxer_options(&args[arg_idx], &mux_reg) { + if !transcoder.parse_muxer_options(&args[arg_idx], &full_reg.mux_reg) { println!("invalid muxer option syntax"); return; } }, + "--verbose" | "-v" => transcoder.verbose = true, _ => { if args[arg_idx].starts_with("--istream") { let opt0 = &args[arg_idx]; @@ -888,7 +962,7 @@ fn main() { } else if args[arg_idx].starts_with("--ostream") { let opt0 = &args[arg_idx]; next_arg!(args, arg_idx); - if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &enc_reg) { + if !transcoder.parse_ostream_options(opt0, &args[arg_idx], &full_reg.enc_reg) { println!("invalid output stream option syntax"); return; } @@ -920,32 +994,38 @@ fn main() { println!("error opening input"); return; } - let mut file = res.unwrap(); - let mut fr = FileReader::new_read(&mut file); + let file = res.unwrap(); + let file = BufReader::new(file); + let mut fr = FileReader::new_read(file); let mut br = ByteReader::new(&mut fr); - - 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 + let (is_raw, start, end) = if transcoder.input_fmt.is_none() { + detect_tags(&mut br) } else { - println!("cannot detect input format"); - return; + (false, 0, None) }; - let ret = dmx_reg.find_demuxer(dmx_name); - if ret.is_none() { - println!("cannot find demuxer for '{}'", dmx_name); + + let mut nfr: Box; + if start != 0 || end.is_some() { + let file = fr.finish(); + nfr = Box::new(BoundedFileReader::new_read(file, start, end).unwrap()); + } else { + nfr = Box::new(fr); + } + let mut br = ByteReader::new(nfr.as_mut()); + + let mut dmx = DemuxerObject::create(&mut br, &full_reg, transcoder.input_name.as_str(), &transcoder.input_fmt, is_raw); + if dmx.is_none() { + println!("cannot find demuxer for '{}'", transcoder.input_name.as_str()); return; } - let dmx_fact = ret.unwrap(); - br.seek(SeekFrom::Start(0)).unwrap(); - let mut dmx = create_demuxer(dmx_fact, &mut br).unwrap(); + let duration = dmx.get_duration(); + let duration_string = if duration != 0 { format_time(duration) } else { String::new() }; + parse_and_apply_options!(dmx, &transcoder.demux_opts, "input"); for i in 0..dmx.get_num_streams() { let s = dmx.get_stream(i).unwrap(); let info = s.get_info(); - let decfunc = dec_reg.find_decoder(info.get_name()); + let decfunc = full_reg.dec_reg.find_decoder(info.get_name()); println!("stream {} - {} {}", i, s, info.get_name()); let str_id = s.get_num() as u32; if let Some(create_dec) = decfunc { @@ -986,7 +1066,7 @@ println!("stream {} - {} {}", i, s, info.get_name()); println!("Cannot guess muxer for output"); return; }; - let ret = mux_reg.find_muxer(output_fmt); + let ret = full_reg.mux_reg.find_muxer(output_fmt); let ofmt = output_fmt.to_string(); if ret.is_none() { @@ -996,7 +1076,7 @@ println!("stream {} - {} {}", i, s, info.get_name()); let mux_caps = mux_creator.get_capabilities(); let mut out_sm = StreamManager::new(); - if !transcoder.negotiate_stream_map(dmx.get_stream_manager(), mux_caps, &mut out_sm, &enc_reg) { + if !transcoder.negotiate_stream_map(dmx.get_stream_manager(), mux_caps, &mut out_sm, &full_reg.enc_reg) { println!("cannot determine stream map"); return; } @@ -1021,6 +1101,8 @@ println!("stream {} - {} {}", i, s, info.get_name()); println!(" #{}: {} {}", ostr.get_num(), ostr, ostr.get_info().get_name()); } + let mut time = Instant::now(); + let show_interval = Duration::from_millis(100); 'main_loop: loop { let pktres = dmx.get_frame(); if let Err(DemuxerError::EOF) = pktres { break; } @@ -1031,6 +1113,20 @@ println!("stream {} - {} {}", i, s, info.get_name()); let mut pkt = pktres.unwrap(); if transcoder.start != NATimePoint::None && pkt.ts.less_than(transcoder.start) { continue; } let src_id = pkt.get_stream().get_num(); + if transcoder.verbose && time.elapsed() >= show_interval { + if let Some(pts) = pkt.get_pts() { + let cur_time = format_time(NATimeInfo::ts_to_time(pts, 1000, pkt.ts.tb_num, pkt.ts.tb_den)); + print!(" {}", cur_time); + } else { + print!(" ???"); + } + if !duration_string.is_empty() { + print!(" / {}", duration_string); + } + print!("\r"); + std::io::stdout().flush().unwrap(); + time = Instant::now(); + } match transcoder.encoders[src_id] { OutputMode::Drop => {}, OutputMode::Copy(dst_id) => { @@ -1105,6 +1201,9 @@ println!("stream {} - {} {}", i, s, info.get_name()); _ => {}, }; } + if transcoder.verbose { + println!(); + } let ret = mux.end(); if ret.is_err() {