imc: cosmetics

[nihav.git] / src / demuxers / avi.rs

diff --git a/src/demuxers/avi.rs b/src/demuxers/avi.rs
index 8737fbf7354049537e9e2c3d45d0b9a673fa65cb..3810bc82d99e49989d373660c07cf6ff6b64e535 100644 (file)
--- a/src/demuxers/avi.rs
+++ b/src/demuxers/avi.rs
@@ -47,6 +47,8 @@ struct AVIDemuxer<'a> {
     size:           usize,
     movi_size:      usize,
     sstate:         StreamState,
+    tb_num:         u32,
+    tb_den:         u32,
 }
 
 #[derive(Debug,Clone,Copy,PartialEq)]
@@ -76,6 +78,11 @@ impl<'a> Demux<'a> for AVIDemuxer<'a> {
         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") {
@@ -90,7 +97,9 @@ impl<'a> Demux<'a> for AVIDemuxer<'a> {
             let str = self.dmx.get_stream(stream_no as usize);
             if let None = str { return Err(InvalidData); }
             let stream = str.unwrap();
-            let pkt = self.src.read_packet(stream, Some(self.cur_frame[stream_no as usize]), None, None, false, size)?;
+            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)?;
             self.cur_frame[stream_no as usize] += 1;            
             self.movi_size -= size + 8;
 
@@ -115,6 +124,8 @@ impl<'a> AVIDemuxer<'a> {
             size: 0,
             movi_size: 0,
             sstate: StreamState::new(),
+            tb_num: 0,
+            tb_den: 0,
             dmx: Demuxer::new()
         }
     }
@@ -129,7 +140,8 @@ 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));
         }
@@ -138,6 +150,7 @@ impl<'a> AVIDemuxer<'a> {
             if RIFFTag::Chunk(tag) == CHUNKS[i].tag {
                 let psize = (CHUNKS[i].parse)(self, 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 {
@@ -149,12 +162,23 @@ impl<'a> AVIDemuxer<'a> {
                     let (psize, _) = self.parse_chunk(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));
     }
 
@@ -226,8 +250,8 @@ fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
     dmx.src.read_skip(2)?; //priority
     dmx.src.read_skip(2)?; //language
     dmx.src.read_skip(4)?; //initial frames
-    let scale = dmx.src.read_u32le()?; //scale
-    let rate = dmx.src.read_u32le()?; //rate
+    dmx.tb_num = dmx.src.read_u32le()?; //scale
+    dmx.tb_den = dmx.src.read_u32le()?; //rate
     dmx.src.read_skip(4)?; //start
     dmx.src.read_skip(4)?; //length
     dmx.src.read_skip(4)?; //buf size
@@ -291,7 +315,7 @@ 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));
+    let res = dmx.dmx.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)
@@ -305,7 +329,7 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
     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);
@@ -315,7 +339,7 @@ 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));
+    let res = dmx.dmx.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)
@@ -324,7 +348,7 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
 fn parse_strf_xxxx(dmx: &mut AVIDemuxer, 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));
+    let res = dmx.dmx.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)
@@ -383,7 +407,7 @@ mod test {
         loop {
             let pktres = dmx.get_frame();
             if let Err(e) = pktres {
-                if (e as i32) == (DemuxerError::EOF as i32) { break; }
+                if e == DemuxerError::EOF { break; }
                 panic!("error");
             }
             let pkt = pktres.unwrap();