move decoder creation into a separate transcoder function

diff --git a/src/main.rs b/src/main.rs
index 756f33ad624103d9b8524a72b11a116972f95d14..9dee3199e6351caed097d6b8f874eeab1861b893 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,7 +10,6 @@ use nihav_core::options::*;
 use nihav_core::codecs::*;
 use nihav_core::demuxers::*;
 use nihav_core::muxers::*;
-use nihav_core::reorder::*;
 use nihav_registry::detect;
 use nihav_registry::register;
 use nihav_hlblocks::demux::*;
@@ -489,67 +488,8 @@ fn main() {
         nstreams += sm.get_num_streams();
     }
 
-    for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
-        for i in 0..dmx.get_num_streams() {
-            let s = dmx.get_stream(i).unwrap();
-            if (transcoder.no_video && s.get_media_type() == StreamType::Video) ||
-                (transcoder.no_audio && s.get_media_type() == StreamType::Audio) {
-                transcoder.decoders.push(None);
-                continue;
-            }
-
-            let info = s.get_info();
-            let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
-            let str_id = (s.get_num() + is_off) as u32;
-            if let Some(create_dec) = decfunc {
-                let mut decoder = (create_dec)();
-                let mut dsupp = Box::new(NADecoderSupport::new());
-                let ret = decoder.init(&mut dsupp, info.clone());
-                if ret.is_err() {
-                    println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
-                    transcoder.debug_log(DebugLog::GENERAL, &format!("Error initialising decoder '{}' for stream {str_id}", info.get_name()));
-                    if !ignerr {
-                        return;
-                    } else {
-                        transcoder.decoders.push(None);
-                        continue;
-                    }
-                }
-                transcoder.apply_decoder_options(decoder.as_mut(), str_id);
-                let desc = register::get_codec_description(info.get_name());
-                let caps = if let Some(desc) = desc {
-                        desc.caps
-                    } else if s.get_media_type() == StreamType::Video {
-                        println!("No codec description found, using B-frame reorderer.");
-                        transcoder.debug_log(DebugLog::GENERAL, &format!("No codec description found for stream {str_id}, using B-frame reorderer"));
-                        register::CODEC_CAP_REORDER
-                    } else {
-                        0
-                    };
-                let reorderer: Box<dyn FrameReorderer> = if (caps & register::CODEC_CAP_COMPLEX_REORDER) != 0 {
-                        transcoder.debug_log(DebugLog::DECODE, &format!(" Stream {str_id} - complex reorderer"));
-                        Box::new(ComplexReorderer::new())
-                    } else if (caps & register::CODEC_CAP_REORDER) != 0 {
-                        transcoder.debug_log(DebugLog::DECODE, &format!(" Stream {str_id} - B-frame reorderer"));
-                        Box::new(IPBReorderer::new())
-                    } else {
-                        transcoder.debug_log(DebugLog::DECODE, &format!(" Stream {str_id} - no reorderer"));
-                        Box::new(NoReorderer::new())
-                    };
-                transcoder.decoders.push(Some(DecodeContext{ dsupp, decoder, reorderer }));
-            } else {
-                println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
-                transcoder.debug_log(DebugLog::GENERAL, &format!("No decoder found for stream {str_id} ({})", info.get_name()));
-                transcoder.decoders.push(None);
-            }
-        }
-        if transcoder.start != NATimePoint::None {
-            let ret = dmx.seek(transcoder.start);
-            if ret.is_err() {
-                println!(" failed to seek to {} error {:?}", transcoder.start, ret.err().unwrap());
-                transcoder.debug_log(DebugLog::GENERAL, &format!("Failed to seek to {}", transcoder.start));
-            }
-        }
+    if !transcoder.create_decoders(&full_reg, &is_offset, &mut demuxers, ignerr) {
+        return;
     }
 
     if skip_unknown {

diff --git a/src/transcoder.rs b/src/transcoder.rs
index f0922c3c1c5927a40fcea7134bbc0a3b6aee4cb5..5b7b0f5f9fd2a56f1794cd1f7e9a9218c03034db 100644 (file)
--- a/src/transcoder.rs
+++ b/src/transcoder.rs
@@ -8,6 +8,7 @@ use nihav_core::demuxers::*;
 use nihav_core::muxers::*;
 use nihav_core::reorder::*;
 use nihav_core::scale::*;
+use nihav_registry::register;
 
 use crate::acvt::*;
 use crate::palettise::*;
@@ -1378,6 +1379,71 @@ println!("encoder {} is not supported by output (expected {})", istr.id, istr.ge
         }
         true
     }
+    pub fn create_decoders(&mut self, full_reg: &FullRegister, is_offset: &[usize], demuxers: &mut [(DemuxerObject, bool)], ignerr: bool) -> bool {
+        for (&is_off, (dmx, _)) in is_offset.iter().zip(demuxers.iter_mut()) {
+            for i in 0..dmx.get_num_streams() {
+                let s = dmx.get_stream(i).unwrap();
+                if (self.no_video && s.get_media_type() == StreamType::Video) ||
+                    (self.no_audio && s.get_media_type() == StreamType::Audio) {
+                    self.decoders.push(None);
+                    continue;
+                }
+
+                let info = s.get_info();
+                let decfunc = full_reg.dec_reg.find_decoder(info.get_name());
+                let str_id = (s.get_num() + is_off) as u32;
+                if let Some(create_dec) = decfunc {
+                    let mut decoder = (create_dec)();
+                    let mut dsupp = Box::new(NADecoderSupport::new());
+                    let ret = decoder.init(&mut dsupp, info.clone());
+                    if ret.is_err() {
+                        println!("Error initialising decoder '{}' for stream {}", info.get_name(), str_id);
+                        self.debug_log(DebugLog::GENERAL, &format!("Error initialising decoder '{}' for stream {str_id}", info.get_name()));
+                        if !ignerr {
+                            return false;
+                        } else {
+                            self.decoders.push(None);
+                            continue;
+                        }
+                    }
+                    self.apply_decoder_options(decoder.as_mut(), str_id);
+                    let desc = register::get_codec_description(info.get_name());
+                    let caps = if let Some(desc) = desc {
+                            desc.caps
+                        } else if s.get_media_type() == StreamType::Video {
+                            println!("No codec description found, using B-frame reorderer.");
+                            self.debug_log(DebugLog::GENERAL, &format!("No codec description found for stream {str_id}, using B-frame reorderer"));
+                            register::CODEC_CAP_REORDER
+                        } else {
+                            0
+                        };
+                    let reorderer: Box<dyn FrameReorderer> = if (caps & register::CODEC_CAP_COMPLEX_REORDER) != 0 {
+                            self.debug_log(DebugLog::DECODE, &format!(" Stream {str_id} - complex reorderer"));
+                            Box::new(ComplexReorderer::new())
+                        } else if (caps & register::CODEC_CAP_REORDER) != 0 {
+                            self.debug_log(DebugLog::DECODE, &format!(" Stream {str_id} - B-frame reorderer"));
+                            Box::new(IPBReorderer::new())
+                        } else {
+                            self.debug_log(DebugLog::DECODE, &format!(" Stream {str_id} - no reorderer"));
+                            Box::new(NoReorderer::new())
+                        };
+                    self.decoders.push(Some(DecodeContext{ dsupp, decoder, reorderer }));
+                } else {
+                    println!("No decoder for stream {} ({}) is found", str_id, info.get_name());
+                    self.debug_log(DebugLog::GENERAL, &format!("No decoder found for stream {str_id} ({})", info.get_name()));
+                    self.decoders.push(None);
+                }
+            }
+            if self.start != NATimePoint::None {
+                let ret = dmx.seek(self.start);
+                if ret.is_err() {
+                    println!(" failed to seek to {} error {:?}", self.start, ret.err().unwrap());
+                    self.debug_log(DebugLog::GENERAL, &format!("Failed to seek to {}", self.start));
+                }
+            }
+        }
+        true
+    }
     pub fn debug_log(&mut self, level: u32, msg: &str) {
         if let Some(ref mut dbg) = self.debug {
             dbg.log(level, msg);