X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fdemux.rs;h=19b5f242c337ec4047624c44acb8db3683ff9ca4;hb=e47b21140303d901f723d4638b08cdefa06a19d4;hp=73ed14fa503ffa36ba09d6ccaf1f595d58dedc47;hpb=5ec8115fa8878cba1649346e52e65f5414f64b75;p=nihav-encoder.git diff --git a/src/demux.rs b/src/demux.rs index 73ed14f..19b5f24 100644 --- a/src/demux.rs +++ b/src/demux.rs @@ -6,6 +6,8 @@ use nihav_registry::detect; 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, @@ -41,52 +43,72 @@ pub struct RawStreamCtx<'a> { sm: StreamManager, packetiser: Box, br: &'a mut ByteReader<'a>, + pts: u64, } impl<'a> RawStreamCtx<'a> { fn new(stream: NAStreamRef, packetiser: Box, br: &'a mut ByteReader<'a>) -> Self { let mut sm = StreamManager::new(); sm.add_stream_ref(stream.clone()); - Self { stream, sm, packetiser, br } + Self { stream, sm, packetiser, br, pts: 0 } } } +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 != "" { - println!("trying demuxer {} on {}", dmx_name, name); + if !dmx_name.is_empty() { + 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); } } if ifmt.is_some() { return DemuxerObject::None; } - if dmx_name != "" { - println!("trying raw demuxer {} on {}", dmx_name, name); + if !dmx_name.is_empty() { + 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)(); pkts.push(Some(packetiser)); @@ -99,11 +121,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)); @@ -128,67 +156,82 @@ impl<'a> DemuxerObject<'a> { break; } } - if pname != "" { - println!("found raw stream of type {} for {}", pname, name); + if !pname.is_empty() { + 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 } } + pub fn create_imgseq(isd: ImgSeqDemuxer) -> Self { + DemuxerObject::ImageSequence(isd) + } pub fn is_none(&self) -> bool { - match *self { - DemuxerObject::None => true, - _ => false, - } + matches!(*self, DemuxerObject::None) } 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.get_object().stream.duration, 1000, ctx.get_object().stream.tb_num, ctx.get_object().stream.tb_den) + }, _ => 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::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()) { @@ -227,10 +270,17 @@ 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()) { - Ok(Some(packet)) => return Ok(packet), + Ok(Some(mut packet)) => { + if packet.get_pts().is_none() && packet.get_duration().is_some() { + packet.ts.pts = Some(ctx.pts); + } + ctx.pts += packet.get_duration().unwrap_or(0); + return Ok(packet); + }, Ok(None) => {}, Err(DecoderError::ShortData) => {}, _ => return Err(DemuxerError::InvalidData), @@ -241,7 +291,13 @@ impl<'a> DemuxerObject<'a> { }, Err(_) => { match ctx.packetiser.get_packet(ctx.stream.clone()) { - Ok(Some(packet)) => return Ok(packet), + Ok(Some(mut packet)) => { + if packet.get_pts().is_none() && packet.get_duration().is_some() { + packet.ts.pts = Some(ctx.pts); + } + ctx.pts += packet.get_duration().unwrap_or(0); + return Ok(packet); + }, Ok(None) | Err(DecoderError::ShortData) => return Err(DemuxerError::EOF), _ => return Err(DemuxerError::InvalidData), }; @@ -249,13 +305,15 @@ impl<'a> DemuxerObject<'a> { }; } }, + DemuxerObject::ImageSequence(ref mut ctx) => ctx.get_frame(), _ => 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), + 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), } } @@ -264,22 +322,25 @@ 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, } }