X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fdemux.rs;h=58eed7fc3f04e8c9c1ef36754572463ee5289a09;hb=HEAD;hp=61ddbaf08646d747fb052a6a61cbcd0e9f61cfe1;hpb=90683bc3ac9d2adbe4a6b7239e727a36bd513678;p=nihav-encoder.git diff --git a/src/demux.rs b/src/demux.rs index 61ddbaf..58eed7f 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,30 +54,42 @@ impl<'a> RawStreamCtx<'a> { } } +type ReaderBox<'a> = SBBox, ByteReader<'a>>; + pub enum DemuxerObject<'a> { None, - Normal(Demuxer<'a>), - Raw(RawDemuxer<'a>, Vec>>, bool), - RawStream(RawStreamCtx<'a>), + Normal(SBBox, Demuxer<'a>>), + Raw(SBBox, RawDemuxer<'a>>, Vec>>, bool), + RawStream(SBBox, RawStreamCtx<'a>>), ImageSequence(ImgSeqDemuxer), } impl<'a> DemuxerObject<'a> { - pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, ifmt: &Option, is_raw: bool) -> DemuxerObject<'a> { + pub fn create(mut brb: ReaderBox<'a>, reg: &FullRegister, name: &str, ifmt: &Option, is_raw: bool, print_info: bool) -> DemuxerObject<'a> { + let br = brb.get_object_mut(); if !is_raw { let dmx_name = if let Some(ref dname) = ifmt { dname.as_str() } else if let Some((dname, score)) = detect::detect_format(name, br) { - println!("detected {} with score {:?}", dname, score); + if print_info { + println!("detected {} with score {:?}", dname, score); + } dname } else { "" }; if !dmx_name.is_empty() { - println!("trying demuxer {} on {}", dmx_name, name); + if print_info { + 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); } } @@ -84,14 +97,21 @@ impl<'a> DemuxerObject<'a> { return DemuxerObject::None; } if !dmx_name.is_empty() { - println!("trying raw demuxer {} on {}", dmx_name, name); + if print_info { + 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)(); + let mut packetiser = (pcreate)(); + packetiser.attach_stream(stream); pkts.push(Some(packetiser)); } else { pkts.push(None); @@ -102,11 +122,17 @@ impl<'a> DemuxerObject<'a> { } for rdmx in reg.rdmx_reg.iter() { if rdmx.check_format(br) { - println!("detected {} as {}", name, rdmx.get_name()); + if print_info { + 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)); @@ -132,13 +158,20 @@ impl<'a> DemuxerObject<'a> { } } if !pname.is_empty() { - println!("found raw stream of type {} for {}", pname, name); + if print_info { + 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 +184,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 +195,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 { 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 { 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 +271,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 +312,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 +323,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 { 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, }