From: Kostya Shishkov Date: Mon, 18 Aug 2025 16:54:37 +0000 (+0200) Subject: switch to ByteIO X-Git-Url: https://git.nihav.org/?a=commitdiff_plain;h=refs%2Fheads%2Fmaster;p=nihav-encoder.git switch to ByteIO --- diff --git a/src/demux.rs b/src/demux.rs index 75b53e3..8533c95 100644 --- a/src/demux.rs +++ b/src/demux.rs @@ -3,7 +3,7 @@ use nihav_core::codecs::*; use nihav_core::demuxers::*; use nihav_core::muxers::*; use nihav_registry::detect; -use nihav_core::io::byteio::ByteReader; +use nihav_core::io::byteio::ByteIO; use nihav_allstuff::*; use crate::null::*; use crate::imgseq::*; @@ -42,35 +42,34 @@ pub struct RawStreamCtx<'a> { stream: NAStreamRef, sm: StreamManager, packetiser: Box, - br: &'a mut ByteReader<'a>, + br: &'a mut dyn ByteIO, pts: u64, } impl<'a> RawStreamCtx<'a> { - fn new(stream: NAStreamRef, packetiser: Box, br: &'a mut ByteReader<'a>) -> Self { + fn new(stream: NAStreamRef, packetiser: Box, br: &'a mut dyn ByteIO) -> Self { let mut sm = StreamManager::new(); sm.add_stream_ref(stream.clone()); Self { stream, sm, packetiser, br, pts: 0 } } } -type ReaderBox<'a> = SBBox, ByteReader<'a>>; +type ReaderBox = Box; pub enum DemuxerObject<'a> { None, - Normal(SBBox, Demuxer<'a>>), - Raw(SBBox, RawDemuxer<'a>>, Vec>>, bool), - RawStream(SBBox, RawStreamCtx<'a>>), + Normal(SBBox>), + Raw(SBBox>, Vec>>, bool), + RawStream(SBBox>), ImageSequence(ImgSeqDemuxer), } impl<'a> 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(); + pub fn create(mut br: ReaderBox, reg: &FullRegister, name: &str, ifmt: &Option, is_raw: bool, print_info: bool) -> DemuxerObject<'a> { 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) { + } else if let Some((dname, score)) = detect::detect_format(name, &mut *br) { if print_info { println!("detected {} with score {:?}", dname, score); } @@ -85,9 +84,9 @@ impl<'a> DemuxerObject<'a> { if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) { br.seek(SeekFrom::Start(0)).unwrap(); - let ret = SelfBorrow::try_new(brb, |br_| { + let ret = SelfBorrow::try_new(br, |br_| { unsafe { - create_demuxer(dmx_fact, br_.as_mut().unwrap().get_object_mut()).ok() + create_demuxer(dmx_fact, (*br_).as_mut()).ok() } }); if let Some(dmx) = ret { @@ -107,9 +106,9 @@ impl<'a> DemuxerObject<'a> { } if let Some(rdmx_fact) = reg.rdmx_reg.find_demuxer(dmx_name) { br.seek(SeekFrom::Start(0)).unwrap(); - let ret = SelfBorrow::try_new(brb, |br_| { + let ret = SelfBorrow::try_new(br, |br_| { unsafe { - create_raw_demuxer(rdmx_fact, br_.as_mut().unwrap().get_object_mut()).ok() + create_raw_demuxer(rdmx_fact, (*br_).as_mut()).ok() } }); if let Some(dmx) = ret { @@ -131,14 +130,14 @@ impl<'a> DemuxerObject<'a> { } } for rdmx in reg.rdmx_reg.iter() { - if rdmx.check_format(br) { + if rdmx.check_format(&mut *br) { if print_info { println!("detected {} as {}", name, rdmx.get_name()); } br.seek(SeekFrom::Start(0)).unwrap(); - let ret = SelfBorrow::try_new(brb, |br_| { + let ret = SelfBorrow::try_new(br, |br_| { unsafe { - create_raw_demuxer(*rdmx, br_.as_mut().unwrap().get_object_mut()).ok() + create_raw_demuxer(*rdmx, (*br_).as_mut()).ok() } }); if let Some(dmx) = ret { @@ -180,13 +179,13 @@ impl<'a> DemuxerObject<'a> { println!("found raw stream of type {} for {}", pname, name); } let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap(); - let rctx = SelfBorrow::new(brb, |br_| { + let rctx = SelfBorrow::new(br, |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()) + RawStreamCtx::new(stream, packetiser, (*br_).as_mut()) } }); DemuxerObject::RawStream(rctx) @@ -365,7 +364,7 @@ impl<'a> NAOptionHandler for DemuxerObject<'a> { } } -pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option) { +pub fn detect_tags(br: &mut dyn ByteIO) -> (bool, u64, Option) { let mut is_raw = false; let mut start = 0; let mut end = None; diff --git a/src/imgseq.rs b/src/imgseq.rs index 7de339b..6d6f598 100644 --- a/src/imgseq.rs +++ b/src/imgseq.rs @@ -246,8 +246,7 @@ impl<'a> NAOptionHandler for ImgSeqDemuxerCreator<'a> { } fn read_pnm_header(file: &mut BufReader, pgmyuv: bool) -> DemuxerResult { - let mut fr = FileReader::new_read(file); - let mut br = ByteReader::new(&mut fr); + let mut br = FileReader::new_read(file); let mut magic = [0; 2]; br.read_buf(&mut magic)?; @@ -311,7 +310,7 @@ fn read_pnm_header(file: &mut BufReader, pgmyuv: bool) -> DemuxerResult DemuxerResult { +fn read_number(br: &mut dyn ByteIO) -> DemuxerResult { let mut val = 0; loop { let c = br.read_byte()?; diff --git a/src/main.rs b/src/main.rs index 4db5f1a..bca697a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -248,8 +248,7 @@ fn main() { "--query-demuxer-options" => { next_arg!(args, arg_idx); let dname = args[arg_idx].as_str(); - let mut mr = MemoryReader::new_read(&[]); - let mut br = ByteReader::new(&mut mr); + let mut br = MemoryReader::new_read(&[]); if let Some(dmx_creator) = full_reg.dmx_reg.find_demuxer(dname) { let dmx = dmx_creator.new_demuxer(&mut br); let opts = dmx.get_supported_options(); @@ -275,8 +274,7 @@ fn main() { next_arg!(args, arg_idx); let name = args[arg_idx].as_str(); let mut data = []; - let mut mw = MemoryWriter::new_write(&mut data); - let mut bw = ByteWriter::new(&mut mw); + let mut bw = MemoryWriter::new_write(&mut data); if let Some(mux_creator) = full_reg.mux_reg.find_muxer(name) { let mux = mux_creator.new_muxer(&mut bw); let opts = mux.get_supported_options(); @@ -574,8 +572,7 @@ fn main() { println!("cannot open output file"); return; } - let mut fw = FileWriter::new_write(ret.unwrap()); - let mut bw = ByteWriter::new(&mut fw); + let mut bw = FileWriter::new_write(ret.unwrap()); let ret = create_muxer(mux_creator, out_sm, &mut bw); if let Err(err) = ret { println!("cannot create muxer instance {:?}", err); diff --git a/src/null.rs b/src/null.rs index f9e5ed8..5d06ce1 100644 --- a/src/null.rs +++ b/src/null.rs @@ -59,11 +59,11 @@ pub const NULL_ENCODER: EncoderInfo = EncoderInfo { name: "null", get_encoder }; #[derive(Default)] struct NullMuxer<'a> { - bw: PhantomData<&'a mut ByteWriter<'a>>, + bw: PhantomData<&'a mut dyn ByteIO>, } impl<'a> NullMuxer<'a> { - fn new(_bw: &'a mut ByteWriter<'a>) -> Self { Self::default() } + fn new(_bw: &'a mut dyn ByteIO) -> Self { Self::default() } } impl<'a> MuxCore<'a> for NullMuxer<'a> { @@ -90,7 +90,7 @@ impl<'a> NAOptionHandler for NullMuxer<'a> { pub struct NullMuxerCreator {} impl MuxerCreator for NullMuxerCreator { - fn new_muxer<'a>(&self, bw: &'a mut ByteWriter<'a>) -> Box + 'a> { + fn new_muxer<'a>(&self, bw: &'a mut dyn ByteIO) -> Box + 'a> { Box::new(NullMuxer::new(bw)) } fn get_name(&self) -> &'static str { "null" } diff --git a/src/transcoder.rs b/src/transcoder.rs index 5104037..f5520f5 100644 --- a/src/transcoder.rs +++ b/src/transcoder.rs @@ -1193,24 +1193,18 @@ println!("encoder {} is not supported by output (expected {})", istr.id, istr.ge let file = res.unwrap(); let file = BufReader::new(file); let mut fr = FileReader::new_read(file); - let mut br = ByteReader::new(&mut fr); let (is_raw, start, end) = if ifmt.is_none() { - detect_tags(&mut br) + detect_tags(&mut fr) } else { (false, 0, None) }; - let nfr: Box = if start != 0 || end.is_some() { + let sb: Box = if start != 0 || end.is_some() { let file = fr.finish(); Box::new(BoundedFileReader::new_read(file, start, end).unwrap()) } else { Box::new(fr) }; - let sb = SelfBorrow::new(nfr, |rd| { - unsafe { - ByteReader::new(rd.as_mut().unwrap().as_mut()) - } - }); let mut dmx = DemuxerObject::create(sb, full_reg, name, ifmt, is_raw, print_info); if dmx.is_none() {