adapt to freshly-introduced encoder capabilities

[nihav-encoder.git] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index d0b8d4b117a9fe7eb26ee9632820a4fc81beb12e..409c677a5c4f2e81179e1ccd9e4480df7746e4c2 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,7 @@ extern crate nihav_registry;
 extern crate nihav_allstuff;
 
 use std::fs::File;
-use std::io::BufReader;
+use std::io::{BufReader, Write};
 use nihav_core::io::byteio::{FileReader, ByteReader};
 use nihav_core::frame::*;
 use nihav_core::options::*;
@@ -17,11 +17,28 @@ use nihav_core::soundcvt::*;
 use nihav_registry::detect;
 use nihav_registry::register;
 use std::env;
+use std::time::{Duration, Instant};
 
 mod demux;
 use crate::demux::*;
 mod 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() {
         println!("No custom options.");
@@ -82,6 +99,7 @@ struct Transcoder {
     no_audio:       bool,
     start:          NATimePoint,
     end:            NATimePoint,
+    verbose:        u8,
 }
 
 macro_rules! parse_and_apply_options {
@@ -688,7 +706,14 @@ println!("can't generate default channel map for {} channels", dainfo.channels);
 
 fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputConvert, frm: NAFrameRef, scale_opts: &[(String, String)]) -> bool {
     let buf = frm.get_buffer();
-    let cbuf = match cvt {
+    let cbuf = if let NABufferType::None = buf {
+        if (encoder.get_capabilities() & ENC_CAPS_SKIPFRAME) == 0 {
+            println!("encoder does not support skip frames, skipping");
+            return true;
+        }
+        buf
+    } else {
+        match cvt {
             OutputConvert::None => buf,
             OutputConvert::Video(ref mut scaler, ref mut dbuf) => {
                 let cur_ifmt = get_scale_fmt_from_pic(&buf);
@@ -717,7 +742,8 @@ fn encode_frame(dst_id: u32, encoder: &mut Box<dyn NAEncoder>, cvt: &mut OutputC
                 }
                 ret.unwrap()
             },
-        };
+        }
+    };
     let cfrm = NAFrame::new(frm.get_time_information(), frm.frame_type, frm.key, frm.get_info(), cbuf);
     encoder.encode(&cfrm).unwrap();
     true
@@ -747,6 +773,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");
@@ -931,6 +958,9 @@ fn main() {
                     return;
                 }
             },
+            "--verbose" | "-v" => transcoder.verbose = 1,
+            "-vv" => transcoder.verbose = 2,
+            "-v-" => transcoder.verbose = 0,
             _ => {
                 if args[arg_idx].starts_with("--istream") {
                     let opt0 = &args[arg_idx];
@@ -998,6 +1028,9 @@ fn main() {
         println!("cannot find demuxer for '{}'", transcoder.input_name.as_str());
         return;
     }
+    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();
@@ -1078,6 +1111,10 @@ 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);
+    let mut adata_size = 0;
+    let mut vdata_size = 0;
     'main_loop: loop {
         let pktres = dmx.get_frame();
         if let Err(DemuxerError::EOF) = pktres { break; }
@@ -1088,12 +1125,35 @@ 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 > 0 && 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);
+            }
+            if transcoder.verbose > 1 {
+                print!(" data sizes V: {} A: {}", vdata_size, adata_size);
+            }
+            print!("\r");
+            std::io::stdout().flush().unwrap();
+            time = Instant::now();
+        }
         match transcoder.encoders[src_id] {
             OutputMode::Drop => {},
             OutputMode::Copy(dst_id) => {
                 let dstr = mux.get_stream(dst_id as usize).unwrap();
                 pkt.reassign(dstr, pkt.get_time_information());
                 if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
+                let pkt_size = pkt.get_buffer().len();
+                match pkt.get_stream().get_media_type() {
+                    StreamType::Video => { vdata_size += pkt_size; },
+                    StreamType::Audio => { adata_size += pkt_size; },
+                    _ => {},
+                };
                 if mux.mux_frame(pkt).is_err() {
                     println!("error muxing packet");
                     break;
@@ -1117,6 +1177,12 @@ println!("stream {} - {} {}", i, s, info.get_name());
                         }
                         while let Ok(Some(pkt)) = encoder.get_packet() {
                             if transcoder.end != NATimePoint::None && !pkt.ts.less_than(transcoder.end) { break 'main_loop; }
+                            let pkt_size = pkt.get_buffer().len();
+                            match pkt.get_stream().get_media_type() {
+                                StreamType::Video => { vdata_size += pkt_size; },
+                                StreamType::Audio => { adata_size += pkt_size; },
+                                _ => {},
+                            };
                             mux.mux_frame(pkt).unwrap();
                         }
                     }
@@ -1162,6 +1228,9 @@ println!("stream {} - {} {}", i, s, info.get_name());
             _ => {},
         };
     }
+    if transcoder.verbose > 0 {
+        println!();
+    }
 
     let ret = mux.end();
     if ret.is_err() {