switch to ByteIO

diff --git a/src/demux.rs b/src/demux.rs
index 1dc78c5f190fcaefe8303cdd6fc401b45f919bf7..16070970dc41bc0530d000e33babd7ebe41aed9a 100644 (file)
--- a/src/demux.rs
+++ b/src/demux.rs
@@ -2,7 +2,7 @@ use std::io::SeekFrom;
 use nihav_core::codecs::*;
 use nihav_core::demuxers::*;
 use nihav_registry::detect;
 use nihav_core::codecs::*;
 use nihav_core::demuxers::*;
 use nihav_registry::detect;

-use nihav_core::io::byteio::ByteReader;
+use nihav_core::io::byteio::ByteIO;

 use nihav_allstuff::*;
 
 pub struct FullRegister {
 use nihav_allstuff::*;
 
 pub struct FullRegister {


@@ -29,13 +29,13 @@ impl FullRegister {
 pub struct RawStreamCtx<'a> {
     stream: NAStreamRef,
     pkt:    Box<dyn NAPacketiser + Send>,
 pub struct RawStreamCtx<'a> {
     stream: NAStreamRef,
     pkt:    Box<dyn NAPacketiser + Send>,

-    br:     &'a mut ByteReader<'a>,
+    br:     &'a mut dyn ByteIO,

     pts:    u64,
     seek:   SeekIndex,
 }
 
 impl<'a> RawStreamCtx<'a> {
     pts:    u64,
     seek:   SeekIndex,
 }
 
 impl<'a> RawStreamCtx<'a> {

-    fn new(stream: NAStreamRef, packetiser: Box<dyn NAPacketiser + Send>, br: &'a mut ByteReader<'a>) -> Self {
+    fn new(stream: NAStreamRef, packetiser: Box<dyn NAPacketiser + Send>, br: &'a mut dyn ByteIO) -> Self {

         let mut seek = SeekIndex::new();
         seek.add_stream(0);
         Self { stream, pkt: packetiser, br, pts: 0, seek }
         let mut seek = SeekIndex::new();
         seek.add_stream(0);
         Self { stream, pkt: packetiser, br, pts: 0, seek }


@@ -98,7 +98,7 @@ pub enum DemuxerObject<'a> {
 }
 
 impl<'a> DemuxerObject<'a> {
 }
 
 impl<'a> DemuxerObject<'a> {

-    pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, force_dmx: Option<&str>, is_raw: bool, opts: &[NAOption]) -> DemuxerObject<'a> {
+    pub fn create(br: &'a mut dyn ByteIO, reg: &FullRegister, name: &str, force_dmx: Option<&str>, is_raw: bool, opts: &[NAOption]) -> DemuxerObject<'a> {

         if !is_raw {
             let res = detect::detect_format(name, br);
             if let Some(dmx_name) = force_dmx {
         if !is_raw {
             let res = detect::detect_format(name, br);
             if let Some(dmx_name) = force_dmx {


@@ -304,7 +304,7 @@ impl<'a> DemuxerObject<'a> {
     }
 }
 
     }
 }
 

-pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
+pub fn detect_tags(br: &mut dyn ByteIO) -> (bool, u64, Option<u64>) {

     let mut is_raw = false;
     let mut start = 0;
     let mut end = None;
     let mut is_raw = false;
     let mut start = 0;
     let mut end = None;

diff --git a/src/main.rs b/src/main.rs
index f756c86b1a390ef0c5d4297a7da7408db6725a07..1a15e96d424cb32af52022f692fa450ac5bfb443 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -48,7 +48,7 @@ impl FrameOutput {
 }
 
 struct AudioOutput {
 }
 
 struct AudioOutput {

-    wwr:    WavWriter<'static>,
+    wwr:    WavWriter,

     wrote_header: bool,
 }
 
     wrote_header: bool,
 }
 


@@ -179,20 +179,18 @@ fn main() {
     let file = File::open(path).unwrap();
     let file = BufReader::new(file);
     let mut fr = FileReader::new_read(file);
     let file = File::open(path).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) = detect_tags(&mut br);
+    let (is_raw, start, end) = detect_tags(&mut fr);

 
 

-    let mut nfr: Box<dyn ByteIO>;
+    let mut br: Box<dyn ByteIO>;

     if start != 0 || end.is_some() {
         println!(" limiting range to {:X}-{:X}", start, end.unwrap_or(0));
         let file = fr.finish();
     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());
+        br = Box::new(BoundedFileReader::new_read(file, start, end).unwrap());

     } else {
     } else {

-        nfr = Box::new(fr);
+        br = Box::new(fr);

     }
     }

-    let mut br = ByteReader::new(nfr.as_mut());

     let full_reg = FullRegister::new();
     let full_reg = FullRegister::new();

-    let mut demuxer = DemuxerObject::create(&mut br, &full_reg, name, force_dmx, is_raw, &demux_opts);
+    let mut demuxer = DemuxerObject::create(br.as_mut(), &full_reg, name, force_dmx, is_raw, &demux_opts);

     if demuxer.is_none() {
         println!("No demuxer found!");
         return;
     if demuxer.is_none() {
         println!("No demuxer found!");
         return;

diff --git a/src/wavwriter.rs b/src/wavwriter.rs
index e32a4ec69a23fb5e7a84aa72e5dd7c2d9d53d549..782077b7b612352b239b4fc88091514c4ea31990 100644 (file)
--- a/src/wavwriter.rs
+++ b/src/wavwriter.rs
@@ -3,28 +3,28 @@ extern crate nihav_core;
 use nihav_core::io::byteio::*;
 use nihav_core::frame::*;
 use std::fs::File;
 use nihav_core::io::byteio::*;
 use nihav_core::frame::*;
 use std::fs::File;

-use std::io::SeekFrom;
+use std::io::{BufWriter,SeekFrom};

 
 

-pub struct WavWriter<'a> {
-    io: Box<ByteWriter<'a>>,
+pub struct WavWriter {
+    io: FileWriter<BufWriter<File>>,

     data_pos: u64,
     be: bool,
     bits: u8,
 }
 
     data_pos: u64,
     be: bool,
     bits: u8,
 }
 

-fn write_byte(wr: &mut ByteWriter, sample: u8) -> ByteIOResult<()> {
+fn write_byte(wr: &mut dyn ByteIO, sample: u8) -> ByteIOResult<()> {

     wr.write_byte(sample)
 }
 
     wr.write_byte(sample)
 }
 

-fn write_s16(wr: &mut ByteWriter, sample: i16) -> ByteIOResult<()> {
+fn write_s16(wr: &mut dyn ByteIO, sample: i16) -> ByteIOResult<()> {

     wr.write_u16le(sample as u16)
 }
 
     wr.write_u16le(sample as u16)
 }
 

-fn write_s32(wr: &mut ByteWriter, sample: i32) -> ByteIOResult<()> {
+fn write_s32(wr: &mut dyn ByteIO, sample: i32) -> ByteIOResult<()> {

     wr.write_u16le((sample >> 16) as u16)
 }
 
     wr.write_u16le((sample >> 16) as u16)
 }
 

-fn write_f32(wr: &mut ByteWriter, sample: f32) -> ByteIOResult<()> {
+fn write_f32(wr: &mut dyn ByteIO, sample: f32) -> ByteIOResult<()> {

     let mut out = (sample * 32768.0) as i32;
     if out < -32768 { out = -32768; }
     if out >  32767 { out =  32767; }
     let mut out = (sample * 32768.0) as i32;
     if out < -32768 { out = -32768; }
     if out >  32767 { out =  32767; }


@@ -58,13 +58,11 @@ macro_rules! write_data {
     })
 }
 
     })
 }
 

-impl<'a> WavWriter<'a> {
+impl WavWriter {

     pub fn new(name: &str) -> Self {
         let file = File::create(name).unwrap();
     pub fn new(name: &str) -> Self {
         let file = File::create(name).unwrap();

-        let file = std::io::BufWriter::new(file);
-        let fw   = Box::new(FileWriter::new_write(file));
-        let io   = ByteWriter::new(Box::leak(fw));
-        WavWriter { io: Box::new(io), data_pos: 0, be: false, bits: 0 }
+        let file = BufWriter::new(file);
+        WavWriter { io: FileWriter::new_write(file), data_pos: 0, be: false, bits: 0 }

     }
     pub fn write_header(&mut self, ainfo: NAAudioInfo) -> ByteIOResult<()> {
         let bits = ainfo.get_format().get_bits() as usize;
     }
     pub fn write_header(&mut self, ainfo: NAAudioInfo) -> ByteIOResult<()> {
         let bits = ainfo.get_format().get_bits() as usize;


@@ -164,7 +162,7 @@ impl<'a> WavWriter<'a> {
     }
 }
 
     }
 }
 

-impl<'a> Drop for WavWriter<'a> {
+impl Drop for WavWriter {

     #[allow(unused_variables)]
     fn drop(&mut self) {
         let size = self.io.tell();
     #[allow(unused_variables)]
     fn drop(&mut self) {
         let size = self.io.tell();