X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fdemuxers%2Favi.rs;h=37bfa3bae5891818aa64e1fd596cc33f4ce820ef;hb=750b299cebf79e53a0ce37c59afdadec8f527c7b;hp=56cf023e50309c71f71ae2863ae9b1d09e82e106;hpb=aa7dab8e525e1e55470f696bb567d94a3d331e03;p=nihav.git

diff --git a/src/demuxers/avi.rs b/src/demuxers/avi.rs
index 56cf023..37bfa3b 100644
--- a/src/demuxers/avi.rs
+++ b/src/demuxers/avi.rs
@@ -1,8 +1,8 @@
 use super::*;
 use register;
 use super::DemuxerError::*;
-use io::byteio::*;
-use frame::*;
+//use io::byteio::*;
+//use frame::*;
 use formats::*;
 
 macro_rules! mktag {
@@ -39,11 +39,9 @@ impl StreamState {
 
 #[allow(dead_code)]
 struct AVIDemuxer<'a> {
-    opened:         bool,
     src:            &'a mut ByteReader<'a>,
     cur_frame:      Vec<u64>,
     num_streams:    u8,
-    dmx:            Demuxer,
     size:           usize,
     movi_size:      usize,
     sstate:         StreamState,
@@ -59,43 +57,51 @@ enum RIFFTag {
 
 struct RIFFParser {
     tag:   RIFFTag,
-    parse: fn(&mut AVIDemuxer, size: usize) -> DemuxerResult<usize>,
+    parse: fn(&mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize>,
 }
 
-impl<'a> Demux<'a> for AVIDemuxer<'a> {
+impl<'a> DemuxCore<'a> for AVIDemuxer<'a> {
     #[allow(unused_variables)]
-    fn open(&mut self) -> DemuxerResult<()> {
-        self.read_header()?;
-        self.opened = true;
+    fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
+        self.read_header(strmgr)?;
         Ok(())
     }
 
-    fn get_num_streams(&self) -> usize { self.dmx.get_num_streams() }
-    fn get_stream(&self, idx: usize) -> Option<Rc<NAStream>> { self.dmx.get_stream(idx) }
-
-    fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
-        if !self.opened { return Err(NoSuchInput); }
+    fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
         if self.movi_size == 0 { return Err(EOF); }
         let mut tag: [u8; 4] = [0; 4];
         loop {
             if (self.src.tell() & 1) == 1 {
                 self.src.read_skip(1)?;
                 self.movi_size -= 1;
+                if self.movi_size == 0 { return Err(EOF); }
             }
             self.src.read_buf(&mut tag)?;
             let size = self.src.read_u32le()? as usize;
             if mktag!(tag) == mktag!(b"JUNK") {
                 self.movi_size -= size + 8;
                 self.src.read_skip(size)?;
+                if self.movi_size == 0 { return Err(EOF); }
+                continue;
+            }
+            if mktag!(tag) == mktag!(b"LIST") {
+                self.movi_size -= 12;
+                self.src.read_skip(4)?;
+                if self.movi_size == 0 { return Err(EOF); }
                 continue;
             }
             if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
                 return Err(InvalidData);
             }
             let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
-            let str = self.dmx.get_stream(stream_no as usize);
+            let str = strmgr.get_stream(stream_no as usize);
             if let None = str { return Err(InvalidData); }
             let stream = str.unwrap();
+            if size == 0 {
+                self.movi_size -= 8;
+                if self.movi_size == 0 { return Err(EOF); }
+                continue;
+            }
             let (tb_num, tb_den) = stream.get_timebase();
             let ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den);
             let pkt = self.src.read_packet(stream, ts, false, size)?;
@@ -108,7 +114,6 @@ impl<'a> Demux<'a> for AVIDemuxer<'a> {
 
     #[allow(unused_variables)]
     fn seek(&mut self, time: u64) -> DemuxerResult<()> {
-        if !self.opened { return Err(NoSuchInput); }
         Err(NotImplemented)
     }
 }
@@ -118,18 +123,16 @@ impl<'a> AVIDemuxer<'a> {
         AVIDemuxer {
             cur_frame: Vec::new(),
             num_streams: 0,
-            opened: false,
             src: io,
             size: 0,
             movi_size: 0,
             sstate: StreamState::new(),
             tb_num: 0,
             tb_den: 0,
-            dmx: Demuxer::new()
         }
     }
 
-    fn parse_chunk(&mut self, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
+    fn parse_chunk(&mut self, strmgr: &mut StreamManager, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
         if csize < 8 { return Err(InvalidData); }
         if depth > 42 { return Err(InvalidData); }
 
@@ -139,36 +142,49 @@ impl<'a> AVIDemuxer<'a> {
         if RIFFTag::Chunk(tag) == end_tag {
             return Ok((size, true));
         }
-        let ltag = if is_list_tag(tag) { self.src.read_u32be()? } else { 0 };
+        let is_list = is_list_tag(tag);
+        let ltag = if is_list { self.src.read_u32be()? } else { 0 };
         if RIFFTag::List(tag, ltag) == end_tag {
             return Ok((size, true));
         }
 
         for i in 0..CHUNKS.len() {
             if RIFFTag::Chunk(tag) == CHUNKS[i].tag {
-                let psize = (CHUNKS[i].parse)(self, size)?;
+                let psize = (CHUNKS[i].parse)(self, strmgr, size)?;
                 if psize != size { return Err(InvalidData); }
+                if (psize & 1) == 1 { self.src.read_skip(1)?; }
                 return Ok((size + 8, false));
             }
             if RIFFTag::List(tag, ltag) == CHUNKS[i].tag {
                 let mut rest_size = size - 4;
-                let psize = (CHUNKS[i].parse)(self, rest_size)?;
+                let psize = (CHUNKS[i].parse)(self, strmgr, rest_size)?;
                 if psize > rest_size { return Err(InvalidData); }
                 rest_size -= psize;
                 while rest_size > 0 {
-                    let (psize, _) = self.parse_chunk(end_tag, rest_size, depth+1)?;
+                    let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?;
                     if psize > rest_size { return Err(InvalidData); }
                     rest_size -= psize;
+                    if (psize & 1) == 1 {
+                        if rest_size > 0 {
+                            rest_size -= 1;
+                        }
+                    }
                 }
 
                 return Ok((size + 8, false));
             }
         }
-        self.src.read_skip(size)?;
+        if !is_list {
+            self.src.read_skip(size)?;
+        } else {
+            if size < 4 { return Err(InvalidData); }
+            self.src.read_skip(size - 4)?;
+        }
+        if (size & 1) == 1 { self.src.read_skip(1)?; }
         return Ok((size + 8, false));
     }
 
-    fn read_header(&mut self) -> DemuxerResult<()> {
+    fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
         let riff_tag = self.src.read_u32be()?;
         let size     = self.src.read_u32le()? as usize;
         let avi_tag  = self.src.read_u32be()?;
@@ -178,7 +194,7 @@ impl<'a> AVIDemuxer<'a> {
         self.size = size;
         let mut rest_size = size;
         loop {
-            let (csz, end) = self.parse_chunk(RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
+            let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
             if end { self.movi_size = csz - 4; break; }
             rest_size -= csz;
         }
@@ -218,17 +234,17 @@ fn is_list_tag(tag: u32) -> bool {
 }
 
 #[allow(unused_variables)]
-fn parse_hdrl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     Ok(0)
 }
 
 #[allow(unused_variables)]
-fn parse_strl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     Ok(0)
 }
 
 #[allow(unused_variables)]
-fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     if size < 0x38 { return Err(InvalidData); }
     let tag = dmx.src.read_u32be()?; //stream type
     let fcc = dmx.src.read_u32be()?; //handler(fourcc)
@@ -265,17 +281,17 @@ fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
     Ok(size)
 }
 
-fn parse_strf(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     if let None = dmx.sstate.strm_type { return Err(InvalidData); }
     match dmx.sstate.strm_type.unwrap() {
-        StreamType::Video    => parse_strf_vids(dmx, size),
-        StreamType::Audio    => parse_strf_auds(dmx, size),
-        _                    => parse_strf_xxxx(dmx, size),
+        StreamType::Video    => parse_strf_vids(dmx, strmgr, size),
+        StreamType::Audio    => parse_strf_auds(dmx, strmgr, size),
+        _                    => parse_strf_xxxx(dmx, strmgr, size),
     }
 }
 
 #[allow(unused_variables)]
-fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     if size < 40 { return Err(InvalidData); }
     let bi_size         = dmx.src.read_u32le()?;
     if (bi_size as usize) > size { return Err(InvalidData); }
@@ -301,21 +317,21 @@ fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
                     Some(name) => name,
                 };
     let vinfo = NACodecInfo::new(cname, vci, edata);
-    let res = dmx.dmx.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo, dmx.tb_num, dmx.tb_den));
+    let res = strmgr.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo, dmx.tb_num, dmx.tb_den));
     if let None = res { return Err(MemoryError); }
     dmx.sstate.reset();
     Ok(size)
 }
 
 #[allow(unused_variables)]
-fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     if size < 16 { return Err(InvalidData); }
     let w_format_tag        = dmx.src.read_u16le()?;
     let channels            = dmx.src.read_u16le()?;
     let samplespersec       = dmx.src.read_u32le()?;
     let avgbytespersec      = dmx.src.read_u32le()?;
     let block_align         = dmx.src.read_u16le()?;
-    let bits_per_sample     = dmx.src.read_u16le()?;
+    let bits_per_sample     = dmx.src.read_u16le()? * 8;
 
     let soniton = NASoniton::new(bits_per_sample as u8, SONITON_FLAG_SIGNED);
     let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
@@ -325,23 +341,23 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
                     Some(name) => name,
                 };
     let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
-    let res = dmx.dmx.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo, dmx.tb_num, dmx.tb_den));
+    let res = strmgr.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo, dmx.tb_num, dmx.tb_den));
     if let None = res { return Err(MemoryError); }
     dmx.sstate.reset();
     Ok(size)
 }
 
-fn parse_strf_xxxx(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     let edata = dmx.read_extradata(size)?;
     let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
-    let res = dmx.dmx.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info, dmx.tb_num, dmx.tb_den));
+    let res = strmgr.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info, dmx.tb_num, dmx.tb_den));
     if let None = res { return Err(MemoryError); }
     dmx.sstate.reset();
     Ok(size)
 }
 
 #[allow(unused_variables)]
-fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     if size < 0x38 { return Err(InvalidData); }
     let timebase = dmx.src.read_u32le()?; //microsec per frame
     dmx.src.read_skip(4)?; //max frame size
@@ -363,7 +379,8 @@ fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
     Ok(size)
 }
 
-fn parse_junk(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
+#[allow(unused_variables)]
+fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
     dmx.src.read_skip(size)?;
     Ok(size)
 }
@@ -371,7 +388,7 @@ fn parse_junk(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
 pub struct AVIDemuxerCreator { }
 
 impl DemuxerCreator for AVIDemuxerCreator {
-    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<Demux<'a> + 'a> {
+    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
         Box::new(AVIDemuxer::new(br))
     }
     fn get_name(&self) -> &'static str { "avi" }
@@ -388,10 +405,11 @@ mod test {
         let mut fr = FileReader::new_read(&mut file);
         let mut br = ByteReader::new(&mut fr);
         let mut dmx = AVIDemuxer::new(&mut br);
-        dmx.open().unwrap();
+        let mut sm = StreamManager::new();
+        dmx.open(&mut sm).unwrap();
 
         loop {
-            let pktres = dmx.get_frame();
+            let pktres = dmx.get_frame(&mut sm);
             if let Err(e) = pktres {
                 if e == DemuxerError::EOF { break; }
                 panic!("error");