X-Git-Url: https://git.nihav.org/?p=nihav-encoder.git;a=blobdiff_plain;f=src%2Fmain.rs;h=fd1fdaefbc5cb5dabcb3eaa9edb76700b8d7d460;hp=0a36cc88da1c09579c9ec8da73ee75e675ce04c0;hb=91a15e39ebb3b9fef4e8806b191a3c10ddb8a27c;hpb=df37d3b1df616e2b0a13d49bf0a9fb639a1efe27

diff --git a/src/main.rs b/src/main.rs
index 0a36cc8..fd1fdae 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;
 use nihav_core::io::byteio::{FileReader, ByteReader};
 use nihav_core::frame::*;
 use nihav_core::options::*;
@@ -15,11 +16,11 @@ use nihav_core::scale::*;
 use nihav_core::soundcvt::*;
 use nihav_registry::detect;
 use nihav_registry::register;
-use nihav_allstuff::*;
 use std::env;
 
+mod demux;
+use crate::demux::*;
 mod null;
-use crate::null::*;
 
 fn print_options(name: &str, options: &[NAOptionDefinition]) {
     if options.is_empty() {
@@ -701,17 +702,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 +711,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 +724,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 +738,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 +746,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 +755,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 +769,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 +781,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 +796,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 +823,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,7 +863,7 @@ 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;
                 }
@@ -888,7 +879,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 +911,35 @@ 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<dyn ByteIO>;
+    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();
     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 +980,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 +990,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;
     }