add utility code for supporting various kinds of input
authorKostya Shishkov <kostya.shishkov@gmail.com>
Wed, 17 Nov 2021 13:06:48 +0000 (14:06 +0100)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Wed, 17 Nov 2021 17:15:47 +0000 (18:15 +0100)
src/demux.rs [new file with mode: 0644]
src/main.rs

diff --git a/src/demux.rs b/src/demux.rs
new file mode 100644 (file)
index 0000000..4ef1f15
--- /dev/null
@@ -0,0 +1,265 @@
+use std::io::SeekFrom;
+use nihav_core::codecs::*;
+use nihav_core::demuxers::*;
+use nihav_registry::detect;
+use nihav_core::io::byteio::ByteReader;
+use nihav_allstuff::*;
+
+pub struct FullRegister {
+    pub dmx_reg:    RegisteredDemuxers,
+    pub rdmx_reg:   RegisteredRawDemuxers,
+    pub pkt_reg:    RegisteredPacketisers,
+    pub dec_reg:    RegisteredDecoders,
+}
+
+impl FullRegister {
+    pub fn new() -> Self {
+        let mut dmx_reg = RegisteredDemuxers::new();
+        nihav_register_all_demuxers(&mut dmx_reg);
+        let mut rdmx_reg = RegisteredRawDemuxers::new();
+        nihav_register_all_raw_demuxers(&mut rdmx_reg);
+        let mut dec_reg = RegisteredDecoders::new();
+        nihav_register_all_decoders(&mut dec_reg);
+        let mut pkt_reg = RegisteredPacketisers::new();
+        nihav_register_all_packetisers(&mut pkt_reg);
+        Self { dmx_reg, rdmx_reg, pkt_reg, dec_reg }
+    }
+}
+
+pub enum DemuxerObject<'a> {
+    None,
+    Normal(Demuxer<'a>),
+    Raw(RawDemuxer<'a>, Vec<Option<Box<dyn NAPacketiser + Send>>>, bool),
+    RawStream(Box<dyn NAPacketiser + Send>, NAStreamRef, &'a mut ByteReader<'a>),
+}
+
+impl<'a> DemuxerObject<'a> {
+    pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, is_raw: bool) -> DemuxerObject<'a> {
+        if !is_raw {
+            let res = detect::detect_format(name, br);
+            let (dmx_name, _) = res.unwrap_or(("", detect::DetectionScore::No));
+            if dmx_name != "" {
+                println!("trying demuxer {} on {}", dmx_name, name);
+                if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) {
+                    br.seek(SeekFrom::Start(0)).unwrap();
+                    let dmx = create_demuxer(dmx_fact, br).unwrap();
+                    return DemuxerObject::Normal(dmx);
+                }
+            }
+            if dmx_name != "" {
+                println!("trying raw demuxer {} on {}", dmx_name, name);
+                if let Some(rdmx_fact) = reg.rdmx_reg.find_demuxer(dmx_name) {
+                    br.seek(SeekFrom::Start(0)).unwrap();
+                    let dmx = create_raw_demuxer(rdmx_fact, br).unwrap();
+                    let mut pkts = Vec::new();
+                    for stream in dmx.get_streams() {
+                        if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
+                            let packetiser = (pcreate)();
+                            pkts.push(Some(packetiser));
+                        } else {
+                            pkts.push(None);
+                        }
+                    }
+                    return DemuxerObject::Raw(dmx, pkts, false);
+                }
+            }
+            for rdmx in reg.rdmx_reg.iter() {
+                if rdmx.check_format(br) {
+                    println!("detected {} as {}", name, rdmx.get_name());
+                    br.seek(SeekFrom::Start(0)).unwrap();
+                    let dmx = create_raw_demuxer(*rdmx, br).unwrap();
+                    let mut pkts = Vec::new();
+                    for stream in dmx.get_streams() {
+                        if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
+                            let packetiser = (pcreate)();
+                            pkts.push(Some(packetiser));
+                        } else {
+                            pkts.push(None);
+                        }
+                    }
+                    return DemuxerObject::Raw(dmx, pkts, false);
+                }
+            }
+        }
+        br.seek(SeekFrom::Start(0)).unwrap();
+        let mut buf = vec![0; 1048576];
+        let size = br.peek_buf(&mut buf).unwrap();
+        let mut pname = "";
+
+        for pinfo in reg.pkt_reg.iter() {
+            let mut packetiser = (pinfo.get_packetiser)();
+            packetiser.add_data(&buf[..size]);
+            if packetiser.parse_stream(0).is_ok() {
+                pname = pinfo.name;
+                break;
+            }
+        }
+        if pname != "" {
+            println!("found raw stream of type {} for {}", pname, name);
+            let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap();
+            let mut packetiser = (pcreate)();
+            packetiser.add_data(&buf[..size]);
+            let stream = packetiser.parse_stream(0).unwrap();
+            packetiser.reset();
+            DemuxerObject::RawStream(packetiser, stream, br)
+        } else {
+            DemuxerObject::None
+        }
+    }
+    pub fn is_none(&self) -> bool {
+        match *self {
+            DemuxerObject::None => true,
+            _ => false,
+        }
+    }
+    pub fn get_duration(&self) -> u64 {
+        match *self {
+            DemuxerObject::Normal(ref dmx) => dmx.get_duration(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_duration(),
+            _ => 0,
+        }
+    }
+    pub fn get_num_streams(&self) -> usize {
+        match *self {
+            DemuxerObject::None => 0,
+            DemuxerObject::Normal(ref dmx) => dmx.get_num_streams(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_num_streams(),
+            DemuxerObject::RawStream(_, _, _) => 1,
+        }
+    }
+    pub fn get_stream(&self, idx: usize) -> Option<NAStreamRef> {
+        match *self {
+            DemuxerObject::Normal(ref dmx) => dmx.get_stream(idx),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream(idx),
+            DemuxerObject::RawStream(_, ref stream, _) if idx == 0 => Some(stream.clone()),
+            _ => None,
+        }
+    }
+    pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
+        match *self {
+            DemuxerObject::Normal(ref mut dmx) => dmx.get_frame(),
+            DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
+                loop {
+                    let mut has_some = false;
+                    for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
+                        if let Some(ref mut pkts) = p {
+                            match pkts.get_packet(stream.clone()) {
+                                Ok(Some(pkt)) => return Ok(pkt),
+                                Ok(None) | Err(DecoderError::ShortData) => {
+                                    if *eof {
+                                        *p = None;
+                                    }
+                                },
+                                Err(err) => {
+                                    println!("packetisation error {:?}", err);
+                                    return Err(DemuxerError::InvalidData);
+                                }
+                            };
+                            has_some |= p.is_some();
+                        }
+                    }
+                    if !has_some {
+                        return Err(DemuxerError::EOF);
+                    }
+                    if let Ok(data) = dmx.get_data() {
+                        let id = data.get_stream().get_id();
+                        for (i, stream) in dmx.get_streams().enumerate() {
+                            if stream.get_id() == id {
+                                if let Some(ref mut pkts) = packetisers[i] {
+                                    pkts.add_data(&data.get_buffer());
+                                }
+                                break;
+                            }
+                        }
+                    } else {
+                        *eof = true;
+                    }
+                }
+            },
+            DemuxerObject::RawStream(ref mut pkt, ref stream, ref mut br) => {
+                let mut buf = [0; 1048576];
+                loop {
+                    match pkt.get_packet(stream.clone()) {
+                        Ok(Some(packet)) => return Ok(packet),
+                        Ok(None) => {},
+                        Err(DecoderError::ShortData) => {},
+                        _ => return Err(DemuxerError::InvalidData),
+                    };
+                    match br.read_buf_some(&mut buf) {
+                        Ok(size) => {
+                            pkt.add_data(&buf[..size]);
+                        },
+                        Err(_) => {
+                            match pkt.get_packet(stream.clone()) {
+                                Ok(Some(packet)) => return Ok(packet),
+                                Ok(None) | Err(DecoderError::ShortData) => return Err(DemuxerError::EOF),
+                                _ => return Err(DemuxerError::InvalidData),
+                            };
+                        },
+                    };
+                }
+            },
+            _ => unreachable!(),
+        }
+    }
+    pub fn seek(&mut self, seek_time: NATimePoint) -> DemuxerResult<()> {
+        match *self {
+            DemuxerObject::Normal(ref mut dmx) => dmx.seek(seek_time),
+            DemuxerObject::Raw(ref mut dmx, _, _) => dmx.seek(seek_time),
+            _ => Err(DemuxerError::NotImplemented),
+        }
+    }
+}
+
+pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
+    let mut is_raw = false;
+    let mut start = 0;
+    let mut end = None;
+
+    // check for ID3v{2-4}
+    let mut buf = [0; 5];
+    br.peek_buf(&mut buf).unwrap();
+    if &buf[0..3] == b"ID3" && buf[3] > 0 && buf[3] < 5 && buf[4] == 0 { //ID3 tag found, must be a raw stream
+        br.read_skip(6).unwrap();
+        let mut size = 0;
+        for _ in 0..4 {
+            let b = br.read_byte().unwrap();
+            if (b & 0x80) != 0 {
+                println!("Invalid ID3 size");
+                break;
+            }
+            size = (size << 7) | u64::from(b);
+        }
+        start = size + 10;
+        is_raw = true;
+    }
+    // check for ID3v1
+    br.seek(SeekFrom::End(-128)).unwrap();
+    let off = br.tell();
+    br.peek_buf(&mut buf[..3]).unwrap();
+    if &buf[0..3] == b"TAG" {
+        end = Some(off);
+    }
+    // check for APETAG
+    let mut buf = [0; 8];
+    if let Some(off) = end {
+        br.seek(SeekFrom::Start(off - 32)).unwrap();
+    } else {
+        br.seek(SeekFrom::End(-32)).unwrap();
+    }
+    let off = br.tell();
+    br.read_buf(&mut buf).unwrap();
+    if &buf == b"APETAGEX" {
+        let ver     = br.read_u32le().unwrap();
+        let size    = u64::from(br.read_u32le().unwrap());
+        let _items  = br.read_u32le().unwrap();
+        let flags   = br.read_u32le().unwrap();
+        if ver == 1000 || (flags & 0x80000000) == 0 {
+            end = Some(off - size + 32);
+        } else {
+            end = Some(off - size);
+        }
+    }
+
+    (is_raw, start, end)
+}
index 6d29d46..8280799 100644 (file)
@@ -3,18 +3,17 @@ extern crate nihav_codec_support;
 extern crate nihav_registry;
 extern crate nihav_allstuff;
 
-use std::io::{SeekFrom, Write, BufReader};
+use std::io::{Write, BufReader};
 use std::fs::File;
 use std::path::Path;
-use nihav_core::io::byteio::{FileReader, ByteReader};
 use nihav_core::frame::*;
 use nihav_core::codecs::*;
 use nihav_core::demuxers::*;
 use nihav_codec_support::imgwrite::*;
-use nihav_registry::detect;
-use nihav_allstuff::*;
 use std::env;
 
+mod demux;
+use demux::*;
 mod wavwriter;
 use crate::wavwriter::WavWriter;
 
@@ -165,29 +164,28 @@ fn main() {
 
     let path = Path::new(name);
     let file = File::open(path).unwrap();
-    let mut file = BufReader::new(file);
-    let dmx_fact;
-    let mut fr = FileReader::new_read(&mut file);
+    let file = BufReader::new(file);
+    let mut fr = FileReader::new_read(file);
     let mut br = ByteReader::new(&mut fr);
-    let res = detect::detect_format(name, &mut br);
-    if res.is_none() {
-        println!("cannot detect format for {}", name);
+    let (is_raw, start, end) = detect_tags(&mut br);
+
+    let mut nfr: Box<dyn ByteIO>;
+    if start != 0 || end.is_some() {
+        println!(" limiting range to {:X}-{:X}", start, end.unwrap_or(0));
+        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 full_reg = FullRegister::new();
+    let mut demuxer = DemuxerObject::create(&mut br, &full_reg, name, is_raw);
+    if demuxer.is_none() {
+        println!("No demuxer found!");
         return;
     }
-    let (dmx_name, _) = res.unwrap();
-println!("trying demuxer {} on {}", dmx_name, name);
-
-    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);
-
-    dmx_fact = dmx_reg.find_demuxer(dmx_name).unwrap();
-    br.seek(SeekFrom::Start(0)).unwrap();
-    let mut dmx = create_demuxer(dmx_fact, &mut br).unwrap();
-
     if seek_time != NATimePoint::None {
-        let ret = dmx.seek(seek_time);
+        let ret = demuxer.seek(seek_time);
         if ret.is_err() {
 println!(" seek error {:?}", ret.err().unwrap());
         }
@@ -197,17 +195,17 @@ println!(" seek error {:?}", ret.err().unwrap());
     let mut sids: Vec<u32> = Vec::new();
     let mut writers: Vec<Outputter> = Vec::new();
     let dec_opts = [NAOption{name: FRAME_SKIP_OPTION, value: NAValue::String(smode.to_string())}];
-    let duration = dmx.get_duration();
+    let duration = demuxer.get_duration();
     if duration != 0 {
         let s = duration / 1000;
         let m = s / 60;
         let h = m / 60;
         println!(" total duration {}:{:02}:{:02}.{}", h, m % 60, s % 60, (duration / 100) % 10);
     }
-    for i in 0..dmx.get_num_streams() {
-        let s = dmx.get_stream(i).unwrap();
+    for i in 0..demuxer.get_num_streams() {
+        let s = demuxer.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_id();
         let mut has_out = false;
@@ -262,7 +260,7 @@ println!("stream {} - {} {}", i, s, info.get_name());
 
     let mut frmnum = 0;
     loop {
-        let pktres = dmx.get_frame();
+        let pktres = demuxer.get_frame();
         if let Err(e) = pktres {
             if e == DemuxerError::EOF { break; }
         }