aac: clear M/S flags

[nihav.git] / nihav-game / src / demuxers / smush.rs

diff --git a/nihav-game/src/demuxers/smush.rs b/nihav-game/src/demuxers/smush.rs
index 812acf6940b106afdeb7f2af795332db12a4dddd..3cc5fbc5410a591172605ffee6c98832abe14512 100644 (file)
--- a/nihav-game/src/demuxers/smush.rs
+++ b/nihav-game/src/demuxers/smush.rs
@@ -288,8 +288,7 @@ impl<'a> SmushDemuxer<'a> {
                     let mut buf = Vec::new();
                     std::mem::swap(&mut self.chunks, &mut buf);
                     let stream = strmgr.get_stream(0).unwrap();
-                    let (tb_num, tb_den) = stream.get_timebase();
-                    let ts = NATimeInfo::new(Some(self.cur_frame as u64 - 1), None, None, tb_num, tb_den);
+                    let ts = stream.make_ts(Some(self.cur_frame as u64 - 1), None, None);
                     return Ok(NAPacket::new(stream, ts, false, buf));
                 }
                 if self.cur_frame == self.nframes {
@@ -320,8 +319,7 @@ impl<'a> SmushDemuxer<'a> {
                     let flags           = self.src.read_u16le()?;
                     if (opcode == 8) && (flags == 0x2E) {
                         if let Some(stream) = strmgr.get_stream(1) {
-                            let (tb_num, tb_den) = stream.get_timebase();
-                            let ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
+                            let ts = stream.make_ts(None, None, None);
 
                             let mut buf = vec![0; size as usize];
                             write_u16le(&mut buf[0..2], opcode).unwrap();
@@ -342,10 +340,8 @@ impl<'a> SmushDemuxer<'a> {
                     if size > 0x30 {
                                           self.src.read_skip(0x30)?;
                         if let Some(stream) = strmgr.get_stream(1) {
-                            let (tb_num, tb_den) = stream.get_timebase();
-
                             let audio_size = size - 0x30;
-                            let ts = NATimeInfo::new(Some(self.asize), None, None, tb_num, tb_den);
+                            let ts = stream.make_ts(Some(self.asize), None, None);
                             let pkt = self.src.read_packet(stream, ts, true, audio_size as usize)?;
                             self.asize += audio_size;
                             if (self.src.tell() & 1) == 1 {
@@ -379,8 +375,7 @@ impl<'a> SmushDemuxer<'a> {
                     let mut buf = Vec::new();
                     std::mem::swap(&mut self.chunks, &mut buf);
                     let stream = strmgr.get_stream(0).unwrap();
-                    let (tb_num, tb_den) = stream.get_timebase();
-                    let ts = NATimeInfo::new(Some(self.cur_frame as u64 - 1), None, None, tb_num, tb_den);
+                    let ts = stream.make_ts(Some(self.cur_frame as u64 - 1), None, None);
                     return Ok(NAPacket::new(stream, ts, self.keyframe, buf));
                 }
                 if self.cur_frame == self.nframes {
@@ -427,8 +422,7 @@ impl<'a> SmushDemuxer<'a> {
                             }
                         }
 
-                        let (tb_num, tb_den) = stream.get_timebase();
-                        let mut ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
+                        let mut ts = stream.make_ts(None, None, None);
                         if nsamples != 0 {
                             ts.pts = Some(self.asize);
                             self.asize += u64::from(nsamples);
@@ -537,7 +531,7 @@ impl<'a> DemuxCore<'a> for MCMPDemuxer<'a> {
         let hdr_size                    = self.src.read_u32be()?;
         validate!(cmp == 0 && size1 == hdr_size);
 
-        let size = (nframes - 1) as usize;
+        let size = nframes - 1;
         self.offsets = Vec::with_capacity(size);
         self.sizes   = Vec::with_capacity(size);
         self.samples = Vec::with_capacity(size);
@@ -568,7 +562,17 @@ impl<'a> DemuxCore<'a> for MCMPDemuxer<'a> {
         let mut arate = 0;
         let mut abits = 0;
         let mut chans = 0;
-        parse_iact(&mut self.src, data_start, &mut arate, &mut abits, &mut chans, true)?;
+        if let Ok([b'R', b'I', b'F', b'F']) = self.src.peek_tag() {
+            validate!(hdr_size >= 44);
+                                          self.src.read_skip(22)?;
+            let c                       = self.src.read_u16le()?;
+            validate!(c == 1 || c == 2);
+            chans = c as u8;
+            arate                       = self.src.read_u32le()?;
+            validate!(arate > 0);
+        } else {
+            parse_iact(self.src, data_start, &mut arate, &mut abits, &mut chans, true)?;
+        }
         if chans == 2 {
             for (samp, pts) in self.samples.iter_mut().zip(self.pts.iter_mut()) {
                 validate!((*samp & 1) == 0);
@@ -606,8 +610,7 @@ impl<'a> DemuxCore<'a> for MCMPDemuxer<'a> {
                                           self.src.read_buf(&mut buf[4..])?;
 
         let stream = strmgr.get_stream(0).unwrap();
-        let (tb_num, tb_den) = stream.get_timebase();
-        let ts = NATimeInfo::new(Some(self.pts[idx]), None, None, tb_num, tb_den);
+        let ts = stream.make_ts(Some(self.pts[idx]), None, None);
 
         self.cur_frame += 1;
 
@@ -707,7 +710,7 @@ mod test {
         }
     }
     #[test]
-    fn test_mcmp_demux() {
+    fn test_mcmp_demux_imus() {
         // sample from Grim Fandango
         let mut file = File::open("assets/Game/smush/1104 - Lupe.IMC").unwrap();
         let mut fr = FileReader::new_read(&mut file);
@@ -726,4 +729,24 @@ mod test {
             println!("Got {}", pkt);
         }
     }
+    #[test]
+    fn test_mcmp_demux_wav() {
+        // sample from Grim Fandango
+        let mut file = File::open("assets/Game/smush/breadpor.WAV").unwrap();
+        let mut fr = FileReader::new_read(&mut file);
+        let mut br = ByteReader::new(&mut fr);
+        let mut dmx = MCMPDemuxer::new(&mut br);
+        let mut sm = StreamManager::new();
+        let mut si = SeekIndex::new();
+        dmx.open(&mut sm, &mut si).unwrap();
+        loop {
+            let pktres = dmx.get_frame(&mut sm);
+            if let Err(e) = pktres {
+                if (e as i32) == (DemuxerError::EOF as i32) { break; }
+                panic!("error");
+            }
+            let pkt = pktres.unwrap();
+            println!("Got {}", pkt);
+        }
+    }
 }