X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-game%2Fsrc%2Fdemuxers%2Fvmd.rs;h=326dd0666308fc274366a1e2a40e1935a80a7eef;hb=d24468d9dbd54f5cbe414649ff061699337fa7fe;hp=74fe3a799b3243a9d9c707e69717875a78c79d8c;hpb=9895bd7b1732a96f0b3f61bf7c95ba342bd08b1e;p=nihav.git

diff --git a/nihav-game/src/demuxers/vmd.rs b/nihav-game/src/demuxers/vmd.rs
index 74fe3a7..326dd06 100644
--- a/nihav-game/src/demuxers/vmd.rs
+++ b/nihav-game/src/demuxers/vmd.rs
@@ -28,7 +28,7 @@ struct VMDDemuxer<'a> {
 
 impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
     #[allow(unused_variables)]
-    fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
+    fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
         let src = &mut self.src;
 
         let mut header: [u8; HEADER_SIZE] = [0; HEADER_SIZE];
@@ -45,7 +45,7 @@ impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
         let nframes = read_u16le(&header[6..])? as usize;
         let fpb     = read_u16le(&header[18..])? as usize;
         validate!(nframes > 0 && fpb > 0);
-        
+
         let mut edata: Vec<u8> = Vec::with_capacity(HEADER_SIZE);
         edata.extend_from_slice(&header);
         let vhdr = NAVideoInfo::new(width, height, false, PAL8_FORMAT);
@@ -53,12 +53,12 @@ impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
         let vinfo = NACodecInfo::new(if !self.is_indeo { "vmd-video" } else { "indeo3" }, vci, Some(edata));
         self.vid_id = strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, 12)).unwrap();
 
-        let srate = read_u16le(&header[804..])? as u32;
+        let srate = u32::from(read_u16le(&header[804..])?);
+        let block_size;
         if srate > 0 {
             let bsize = read_u16le(&header[806..])? as usize;
-            let channels = if (header[811] & 0x80) != 0 { 2 } else { 1 };
+            let channels = if (header[811] & 0x8F) != 0 { 2 } else { 1 };
             let is16bit;
-            let block_size;
             if (bsize & 0x8000) != 0 {
                 is16bit = true;
                 block_size = 0x10000 - bsize;
@@ -70,10 +70,12 @@ impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
             let ahdr = NAAudioInfo::new(srate, channels, if is16bit { SND_S16P_FORMAT } else { SND_U8_FORMAT }, block_size);
             let ainfo = NACodecInfo::new("vmd-audio", NACodecTypeInfo::Audio(ahdr), None);
             self.aud_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, srate)).unwrap();
+        } else {
+            block_size = 0;
         }
 
-        let adelay  = read_u16le(&header[808..])? as u32;
-        let idx_off = read_u32le(&header[812..])? as u64;
+        let adelay  = u32::from(read_u16le(&header[808..])?);
+        let idx_off = u64::from(read_u32le(&header[812..])?);
                                                 src.seek(SeekFrom::Start(idx_off))?;
         let mut offs: Vec<u32> = Vec::with_capacity(nframes);
         for i in 0..nframes {
@@ -88,9 +90,12 @@ impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
             for _ in 0..fpb {
                 let chtype                      = src.read_byte()?;
                                                   src.read_skip(1)?;
-                let size                        = src.read_u32le()?;
+                let mut size                    = src.read_u32le()?;
                 let mut hdr: [u8; FRAME_HDR_SIZE] = [0; FRAME_HDR_SIZE];
                                                   src.read_buf(&mut hdr)?;
+                if (i == 0) && (chtype == CHTYPE_AUDIO) && (size > 4) && ((size as usize) < block_size/2) {
+                    size += 0x10000;
+                }
                 if (chtype == CHTYPE_VIDEO || chtype == CHTYPE_AUDIO) && (size > 0) {
                     let ts = if (i == 0) || (chtype != CHTYPE_AUDIO) {
                             i as u32
@@ -117,7 +122,7 @@ impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
         if self.fno >= self.frames.len() { return Err(DemuxerError::EOF); }
         let cur_frame = &self.frames[self.fno];
 //println!("fno {} -> type {} size {} @ {:X} ts {}", self.fno, cur_frame.chtype, cur_frame.size, cur_frame.off, cur_frame.ts);
-        let next_pos = cur_frame.off as u64;
+        let next_pos = u64::from(cur_frame.off);
         if self.src.tell() != next_pos {
             self.src.seek(SeekFrom::Start(next_pos))?;
         }
@@ -138,15 +143,14 @@ impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
         let str_id = if is_video { self.vid_id } else { self.aud_id };
         let str = strmgr.get_stream(str_id).unwrap();
         let (tb_num, tb_den) = str.get_timebase();
-        let ts = NATimeInfo::new(Some(cur_frame.ts as u64), None, None, tb_num, tb_den);
+        let ts = NATimeInfo::new(Some(u64::from(cur_frame.ts)), None, None, tb_num, tb_den);
         let pkt = NAPacket::new(str, ts, false, buf);
 
         Ok(pkt)
     }
 
-    #[allow(unused_variables)]
-    fn seek(&mut self, time: u64) -> DemuxerResult<()> {
-        Err(DemuxerError::NotImplemented)
+    fn seek(&mut self, _time: u64, _seek_index: &SeekIndex) -> DemuxerResult<()> {
+        Err(DemuxerError::NotPossible)
     }
 }
 
@@ -166,7 +170,7 @@ impl<'a> VMDDemuxer<'a> {
 pub struct VMDDemuxerCreator { }
 
 impl DemuxerCreator for VMDDemuxerCreator {
-    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
         Box::new(VMDDemuxer::new(br))
     }
     fn get_name(&self) -> &'static str { "vmd" }
@@ -179,13 +183,14 @@ mod test {
 
     #[test]
     fn test_vmd_demux() {
-        let mut file = File::open("assets/128.vmd").unwrap();
-        //let mut file = File::open("assets/1491.VMD").unwrap();
+        let mut file = File::open("assets/Game/128.vmd").unwrap();
+        //let mut file = File::open("assets/Game/1491.VMD").unwrap();
         let mut fr = FileReader::new_read(&mut file);
         let mut br = ByteReader::new(&mut fr);
         let mut dmx = VMDDemuxer::new(&mut br);
         let mut sm = StreamManager::new();
-        dmx.open(&mut sm).unwrap();
+        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 {