nihav-game/src/demuxers/vmd.rs

   1 use nihav_core::frame::*;
   2 use nihav_core::demuxers::*;
   3 use std::io::SeekFrom;
   4
   5 const HEADER_SIZE: usize = 0x330;
   6 const FRAME_HDR_SIZE: usize = 10;
   7
   8 const CHTYPE_VIDEO: u8 = 0x02;
   9 const CHTYPE_AUDIO: u8 = 0x01;
  10
  11 #[derive(Clone,Copy)]
  12 struct FrameRec {
  13     chtype:     u8,
  14     size:       u32,
  15     off:        u32,
  16     hdr:        [u8; FRAME_HDR_SIZE],
  17     ts:         u32,
  18 }
  19
  20 struct VMDDemuxer<'a> {
  21     src:        &'a mut ByteReader<'a>,
  22     vid_id:     usize,
  23     aud_id:     usize,
  24     fno:        usize,
  25     is_indeo:   bool,
  26     frames:     Vec<FrameRec>,
  27 }
  28
  29 impl<'a> DemuxCore<'a> for VMDDemuxer<'a> {
  30     #[allow(unused_variables)]
  31     fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
  32         let src = &mut self.src;
  33
  34         let mut header: [u8; HEADER_SIZE] = [0; HEADER_SIZE];
  35                                                 src.read_buf(&mut header)?;
  36
  37         let mut width  = read_u16le(&header[12..])? as usize;
  38         let mut height = read_u16le(&header[14..])? as usize;
  39         self.is_indeo = &header[24..27] == b"iv3";
  40         if self.is_indeo && width > 320 {
  41             width  >>= 1;
  42             height >>= 1;
  43         }
  44
  45         let nframes = read_u16le(&header[6..])? as usize;
  46         let fpb     = read_u16le(&header[18..])? as usize;
  47         validate!(nframes > 0 && fpb > 0);
  48
  49         let mut edata: Vec<u8> = Vec::with_capacity(HEADER_SIZE);
  50         edata.extend_from_slice(&header);
  51         let vhdr = NAVideoInfo::new(width, height, false, PAL8_FORMAT);
  52         let vci = NACodecTypeInfo::Video(vhdr);
  53         let vinfo = NACodecInfo::new(if !self.is_indeo { "vmd-video" } else { "indeo3" }, vci, Some(edata));
  54         self.vid_id = strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, 12)).unwrap();
  55
  56         let srate = u32::from(read_u16le(&header[804..])?);
  57         let block_size;
  58         if srate > 0 {
  59             let bsize = read_u16le(&header[806..])? as usize;
  60             let channels = if (header[811] & 0x8F) != 0 { 2 } else { 1 };
  61             let is16bit;
  62             if (bsize & 0x8000) != 0 {
  63                 is16bit = true;
  64                 block_size = 0x10000 - bsize;
  65             } else {
  66                 is16bit = false;
  67                 block_size = bsize;
  68             }
  69
  70             let mut aedata: Vec<u8> = Vec::with_capacity(2);
  71             aedata.extend_from_slice(&header[810..][..2]);
  72             let ahdr = NAAudioInfo::new(srate, channels, if is16bit { SND_S16P_FORMAT } else { SND_U8_FORMAT }, block_size);
  73             let ainfo = NACodecInfo::new("vmd-audio", NACodecTypeInfo::Audio(ahdr), Some(aedata));
  74             self.aud_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, srate)).unwrap();
  75         } else {
  76             block_size = 0;
  77         }
  78
  79         let adelay  = u32::from(read_u16le(&header[808..])?);
  80         let idx_off = u64::from(read_u32le(&header[812..])?);
  81                                                 src.seek(SeekFrom::Start(idx_off))?;
  82         let mut offs: Vec<u32> = Vec::with_capacity(nframes);
  83         for i in 0..nframes {
  84             let _flags                          = src.read_u16le()?;
  85             let off                             = src.read_u32le()?;
  86             offs.push(off);
  87         }
  88         self.frames.reserve(nframes * fpb);
  89         let mut ats = adelay;
  90         for i in 0..nframes {
  91             let mut off = offs[i];
  92             for _ in 0..fpb {
  93                 let chtype                      = src.read_byte()?;
  94                                                   src.read_skip(1)?;
  95                 let mut size                    = src.read_u32le()?;
  96                 let mut hdr: [u8; FRAME_HDR_SIZE] = [0; FRAME_HDR_SIZE];
  97                                                   src.read_buf(&mut hdr)?;
  98                 if (i == 0) && (chtype == CHTYPE_AUDIO) && (size > 4) && ((size as usize) < block_size/2) {
  99                     size += 0x10000;
 100                 }
 101                 if (chtype == CHTYPE_VIDEO || chtype == CHTYPE_AUDIO) && (size > 0) {
 102                     let ts = if (i == 0) || (chtype != CHTYPE_AUDIO) {
 103                             i as u32
 104                         } else {
 105                             ats
 106                         };
 107                     self.frames.push(FrameRec { chtype, size, hdr, off, ts });
 108                 }
 109                 if i > 0 && chtype == CHTYPE_AUDIO {
 110                     ats += 1;
 111                 }
 112                 if chtype != 0 {
 113                     validate!(off.checked_add(size).is_some());
 114                     off += size;
 115                 }
 116             }
 117         }
 118
 119         self.fno = 0;
 120         Ok(())
 121     }
 122
 123     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
 124         if self.fno >= self.frames.len() { return Err(DemuxerError::EOF); }
 125         let cur_frame = &self.frames[self.fno];
 126 //println!("fno {} -> type {} size {} @ {:X} ts {}", self.fno, cur_frame.chtype, cur_frame.size, cur_frame.off, cur_frame.ts);
 127         let next_pos = u64::from(cur_frame.off);
 128         if self.src.tell() != next_pos {
 129             self.src.seek(SeekFrom::Start(next_pos))?;
 130         }
 131
 132         let is_video = cur_frame.chtype == CHTYPE_VIDEO;
 133         let mut buf: Vec<u8> = Vec::with_capacity(FRAME_HDR_SIZE + (cur_frame.size as usize));
 134         if !self.is_indeo || !is_video {
 135             buf.extend_from_slice(&cur_frame.hdr);
 136             buf.resize(FRAME_HDR_SIZE + (cur_frame.size as usize), 0);
 137             self.src.read_buf(&mut buf[FRAME_HDR_SIZE..])?;
 138         } else {
 139             buf.resize(cur_frame.size as usize, 0);
 140             self.src.read_buf(&mut buf)?;
 141         }
 142
 143         self.fno += 1;
 144
 145         let str_id = if is_video { self.vid_id } else { self.aud_id };
 146         let str = strmgr.get_stream(str_id).unwrap();
 147         let (tb_num, tb_den) = str.get_timebase();
 148         let ts = NATimeInfo::new(Some(u64::from(cur_frame.ts)), None, None, tb_num, tb_den);
 149         let pkt = NAPacket::new(str, ts, false, buf);
 150
 151         Ok(pkt)
 152     }
 153
 154     fn seek(&mut self, _time: u64, _seek_index: &SeekIndex) -> DemuxerResult<()> {
 155         Err(DemuxerError::NotPossible)
 156     }
 157 }
 158
 159 impl<'a> VMDDemuxer<'a> {
 160     fn new(io: &'a mut ByteReader<'a>) -> Self {
 161         Self {
 162             src:        io,
 163             vid_id:     0,
 164             aud_id:     0,
 165             fno:        0,
 166             is_indeo:   false,
 167             frames:     Vec::new(),
 168         }
 169     }
 170 }
 171
 172 pub struct VMDDemuxerCreator { }
 173
 174 impl DemuxerCreator for VMDDemuxerCreator {
 175     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
 176         Box::new(VMDDemuxer::new(br))
 177     }
 178     fn get_name(&self) -> &'static str { "vmd" }
 179 }
 180
 181 #[cfg(test)]
 182 mod test {
 183     use super::*;
 184     use std::fs::File;
 185
 186     #[test]
 187     fn test_vmd_demux() {
 188         let mut file = File::open("assets/Game/128.vmd").unwrap();
 189         //let mut file = File::open("assets/Game/1491.VMD").unwrap();
 190         let mut fr = FileReader::new_read(&mut file);
 191         let mut br = ByteReader::new(&mut fr);
 192         let mut dmx = VMDDemuxer::new(&mut br);
 193         let mut sm = StreamManager::new();
 194         let mut si = SeekIndex::new();
 195         dmx.open(&mut sm, &mut si).unwrap();
 196         loop {
 197             let pktres = dmx.get_frame(&mut sm);
 198             if let Err(e) = pktres {
 199                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 200                 panic!("error");
 201             }
 202             let pkt = pktres.unwrap();
 203             println!("Got {}", pkt);
 204         }
 205     }
 206 }