X-Git-Url: https://git.nihav.org/?p=nihav-encoder.git;a=blobdiff_plain;f=src%2Fdemux.rs;fp=src%2Fdemux.rs;h=9f6739de3bd4559184ad2ff22adc81e147c193b2;hp=61ddbaf08646d747fb052a6a61cbcd0e9f61cfe1;hb=4a835a2a1473188ae03bd7e495c8569c373de550;hpb=60dc08af39f51c44bff95b106337c60191912197

diff --git a/src/demux.rs b/src/demux.rs
index 61ddbaf..9f6739d 100644
--- a/src/demux.rs
+++ b/src/demux.rs
@@ -7,6 +7,7 @@ use nihav_core::io::byteio::ByteReader;
 use nihav_allstuff::*;
 use crate::null::*;
 use crate::imgseq::*;
+use crate::{SBBox, SelfBorrow};
 
 pub struct FullRegister {
     pub dmx_reg:    RegisteredDemuxers,
@@ -53,16 +54,19 @@ impl<'a> RawStreamCtx<'a> {
     }
 }
 
+type ReaderBox<'a> = SBBox<Box<dyn ByteIO>, ByteReader<'a>>;
+
 pub enum DemuxerObject<'a> {
     None,
-    Normal(Demuxer<'a>),
-    Raw(RawDemuxer<'a>, Vec<Option<Box<dyn NAPacketiser + Send>>>, bool),
-    RawStream(RawStreamCtx<'a>),
+    Normal(SBBox<ReaderBox<'a>, Demuxer<'a>>),
+    Raw(SBBox<ReaderBox<'a>, RawDemuxer<'a>>, Vec<Option<Box<dyn NAPacketiser + Send>>>, bool),
+    RawStream(SBBox<ReaderBox<'a>, RawStreamCtx<'a>>),
     ImageSequence(ImgSeqDemuxer),
 }
 
 impl<'a> DemuxerObject<'a> {
-    pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, ifmt: &Option<String>, is_raw: bool) -> DemuxerObject<'a> {
+    pub fn create(mut brb: ReaderBox<'a>, reg: &FullRegister, name: &str, ifmt: &Option<String>, is_raw: bool) -> DemuxerObject<'a> {
+        let br = brb.get_object_mut();
         if !is_raw {
             let dmx_name = if let Some(ref dname) = ifmt {
                     dname.as_str()
@@ -76,7 +80,12 @@ impl<'a> DemuxerObject<'a> {
                 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();
+
+                    let dmx = SelfBorrow::new(brb, |br_| {
+                            unsafe {
+                                create_demuxer(dmx_fact, br_.as_mut().unwrap().get_object_mut()).unwrap()
+                            }
+                        });
                     return DemuxerObject::Normal(dmx);
                 }
             }
@@ -87,9 +96,13 @@ impl<'a> DemuxerObject<'a> {
                 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 dmx = SelfBorrow::new(brb, |br_| {
+                            unsafe {
+                                create_raw_demuxer(rdmx_fact, br_.as_mut().unwrap().get_object_mut()).unwrap()
+                            }
+                        });
                     let mut pkts = Vec::new();
-                    for stream in dmx.get_streams() {
+                    for stream in dmx.get_object().get_streams() {
                         if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
                             let packetiser = (pcreate)();
                             pkts.push(Some(packetiser));
@@ -104,9 +117,13 @@ impl<'a> DemuxerObject<'a> {
                 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 dmx = SelfBorrow::new(brb, |br_| {
+                            unsafe {
+                                create_raw_demuxer(*rdmx, br_.as_mut().unwrap().get_object_mut()).unwrap()
+                            }
+                        });
                     let mut pkts = Vec::new();
-                    for stream in dmx.get_streams() {
+                    for stream in dmx.get_object().get_streams() {
                         if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
                             let packetiser = (pcreate)();
                             pkts.push(Some(packetiser));
@@ -134,11 +151,16 @@ impl<'a> DemuxerObject<'a> {
         if !pname.is_empty() {
             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(RawStreamCtx::new(stream, packetiser, br))
+            let rctx = SelfBorrow::new(brb, |br_| {
+                    unsafe {
+                        let mut packetiser = (pcreate)();
+                        packetiser.add_data(&buf[..size]);
+                        let stream = packetiser.parse_stream(0).unwrap();
+                        packetiser.reset();
+                        RawStreamCtx::new(stream, packetiser, br_.as_mut().unwrap().get_object_mut())
+                    }
+                });
+            DemuxerObject::RawStream(rctx)
         } else {
             DemuxerObject::None
         }
@@ -151,10 +173,10 @@ impl<'a> DemuxerObject<'a> {
     }
     pub fn get_duration(&self) -> u64 {
         match *self {
-            DemuxerObject::Normal(ref dmx) => dmx.get_duration(),
-            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_duration(),
+            DemuxerObject::Normal(ref dmx) => dmx.get_object().get_duration(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_duration(),
             DemuxerObject::RawStream(ref ctx) => {
-                NATimeInfo::ts_to_time(ctx.stream.duration, 1000, ctx.stream.tb_num, ctx.stream.tb_den)
+                NATimeInfo::ts_to_time(ctx.get_object().stream.duration, 1000, ctx.get_object().stream.tb_num, ctx.get_object().stream.tb_den)
             },
             _ => 0,
         }
@@ -162,43 +184,44 @@ impl<'a> DemuxerObject<'a> {
     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::Normal(ref dmx) => dmx.get_object().get_num_streams(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_num_streams(),
             DemuxerObject::RawStream(_) => 1,
             DemuxerObject::ImageSequence(_) => 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 ctx) if idx == 0 => Some(ctx.stream.clone()),
+            DemuxerObject::Normal(ref dmx) => dmx.get_object().get_stream(idx),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_stream(idx),
+            DemuxerObject::RawStream(ref ctx) if idx == 0 => Some(ctx.get_object().stream.clone()),
             DemuxerObject::ImageSequence(ref ctx) if idx == 0 => Some(ctx.stream.clone()),
             _ => None,
         }
     }
-    pub fn get_streams(&self) -> StreamIter {
+    /*pub fn get_streams(&self) -> StreamIter {
         match *self {
-            DemuxerObject::Normal(ref dmx) => dmx.get_streams(),
-            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_streams(),
-            DemuxerObject::RawStream(ref ctx) => ctx.sm.iter(),
+            DemuxerObject::Normal(ref dmx) => dmx.get_object().get_streams(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_streams(),
+            DemuxerObject::RawStream(ref ctx) => ctx.get_object().sm.iter(),
             DemuxerObject::ImageSequence(ref ctx) => ctx.sm.iter(),
             _ => unreachable!(),
         }
-    }
+    }*/
     pub fn get_stream_manager(&self) -> &StreamManager {
         match *self {
-            DemuxerObject::Normal(ref dmx) => dmx.get_stream_manager(),
-            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_stream_manager(),
-            DemuxerObject::RawStream(ref ctx) => &ctx.sm,
+            DemuxerObject::Normal(ref dmx) => dmx.get_object().get_stream_manager(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_stream_manager(),
+            DemuxerObject::RawStream(ref ctx) => &ctx.get_object().sm,
             DemuxerObject::ImageSequence(ref ctx) => &ctx.sm,
             _ => unreachable!(),
         }
     }
     pub fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
         match *self {
-            DemuxerObject::Normal(ref mut dmx) => dmx.get_frame(),
+            DemuxerObject::Normal(ref mut dmx) => dmx.get_object_mut().get_frame(),
             DemuxerObject::Raw(ref mut dmx, ref mut packetisers, ref mut eof) => {
+                let dmx = dmx.get_object_mut();
                 loop {
                     let mut has_some = false;
                     for (stream, p) in dmx.get_streams().zip(packetisers.iter_mut()) {
@@ -237,6 +260,7 @@ impl<'a> DemuxerObject<'a> {
                 }
             },
             DemuxerObject::RawStream(ref mut ctx) => {
+                let ctx = ctx.get_object_mut();
                 let mut buf = [0; 65536];
                 loop {
                     match ctx.packetiser.get_packet(ctx.stream.clone()) {
@@ -277,8 +301,8 @@ impl<'a> DemuxerObject<'a> {
     }
     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),
+            DemuxerObject::Normal(ref mut dmx) => dmx.get_object_mut().seek(seek_time),
+            DemuxerObject::Raw(ref mut dmx, _, _) => dmx.get_object_mut().seek(seek_time),
             DemuxerObject::ImageSequence(ref mut ctx) => ctx.seek(seek_time),
             _ => Err(DemuxerError::NotImplemented),
         }
@@ -288,24 +312,24 @@ impl<'a> DemuxerObject<'a> {
 impl<'a> NAOptionHandler for DemuxerObject<'a> {
     fn get_supported_options(&self) -> &[NAOptionDefinition] {
         match *self {
-            DemuxerObject::Normal(ref dmx) => dmx.get_supported_options(),
-            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_supported_options(),
+            DemuxerObject::Normal(ref dmx) => dmx.get_object().get_supported_options(),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().get_supported_options(),
             DemuxerObject::ImageSequence(ref ctx) => ctx.get_supported_options(),
             _ => &[],
         }
     }
     fn set_options(&mut self, options: &[NAOption]) {
         match *self {
-            DemuxerObject::Normal(ref mut dmx) => dmx.set_options(options),
-            DemuxerObject::Raw(ref mut dmx, _, _) => dmx.set_options(options),
+            DemuxerObject::Normal(ref mut dmx) => dmx.get_object_mut().set_options(options),
+            DemuxerObject::Raw(ref mut dmx, _, _) => dmx.get_object_mut().set_options(options),
             DemuxerObject::ImageSequence(ref mut ctx) => ctx.set_options(options),
             _ => {},
         }
     }
     fn query_option_value(&self, name: &str) -> Option<NAValue> {
         match *self {
-            DemuxerObject::Normal(ref dmx) => dmx.query_option_value(name),
-            DemuxerObject::Raw(ref dmx, _, _) => dmx.query_option_value(name),
+            DemuxerObject::Normal(ref dmx) => dmx.get_object().query_option_value(name),
+            DemuxerObject::Raw(ref dmx, _, _) => dmx.get_object().query_option_value(name),
             DemuxerObject::ImageSequence(ref ctx) => ctx.query_option_value(name),
             _ => None,
         }