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) -> 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 = read_u16le(&header[804..])? as u32;
  57         if srate > 0 {
  58             let bsize = read_u16le(&header[806..])? as usize;
  59             let channels = if (header[811] & 0x80) != 0 { 2 } else { 1 };
  60             let is16bit;
  61             let block_size;
  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 ahdr = NAAudioInfo::new(srate, channels, if is16bit { SND_S16P_FORMAT } else { SND_U8_FORMAT }, block_size);
  71             let ainfo = NACodecInfo::new("vmd-audio", NACodecTypeInfo::Audio(ahdr), None);
  72             self.aud_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, srate)).unwrap();
  73         }
  74
  75         let adelay  = read_u16le(&header[808..])? as u32;
  76         let idx_off = read_u32le(&header[812..])? as u64;
  77                                                 src.seek(SeekFrom::Start(idx_off))?;
  78         let mut offs: Vec<u32> = Vec::with_capacity(nframes);
  79         for i in 0..nframes {
  80             let _flags                          = src.read_u16le()?;
  81             let off                             = src.read_u32le()?;
  82             offs.push(off);
  83         }
  84         self.frames.reserve(nframes * fpb);
  85         let mut ats = adelay;
  86         for i in 0..nframes {
  87             let mut off = offs[i];
  88             for _ in 0..fpb {
  89                 let chtype                      = src.read_byte()?;
  90                                                   src.read_skip(1)?;
  91                 let size                        = src.read_u32le()?;
  92                 let mut hdr: [u8; FRAME_HDR_SIZE] = [0; FRAME_HDR_SIZE];
  93                                                   src.read_buf(&mut hdr)?;
  94                 if (chtype == CHTYPE_VIDEO || chtype == CHTYPE_AUDIO) && (size > 0) {
  95                     let ts = if (i == 0) || (chtype != CHTYPE_AUDIO) {
  96                             i as u32
  97                         } else {
  98                             ats
  99                         };
 100                     self.frames.push(FrameRec { chtype, size, hdr, off, ts });
 101                 }
 102                 if i > 0 && chtype == CHTYPE_AUDIO {
 103                     ats += 1;
 104                 }
 105                 if chtype != 0 {
 106                     validate!(off.checked_add(size).is_some());
 107                     off += size;
 108                 }
 109             }
 110         }
 111
 112         self.fno = 0;
 113         Ok(())
 114     }
 115
 116     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
 117         if self.fno >= self.frames.len() { return Err(DemuxerError::EOF); }
 118         let cur_frame = &self.frames[self.fno];
 119 //println!("fno {} -> type {} size {} @ {:X} ts {}", self.fno, cur_frame.chtype, cur_frame.size, cur_frame.off, cur_frame.ts);
 120         let next_pos = cur_frame.off as u64;
 121         if self.src.tell() != next_pos {
 122             self.src.seek(SeekFrom::Start(next_pos))?;
 123         }
 124
 125         let is_video = cur_frame.chtype == CHTYPE_VIDEO;
 126         let mut buf: Vec<u8> = Vec::with_capacity(FRAME_HDR_SIZE + (cur_frame.size as usize));
 127         if !self.is_indeo || !is_video {
 128             buf.extend_from_slice(&cur_frame.hdr);
 129             buf.resize(FRAME_HDR_SIZE + (cur_frame.size as usize), 0);
 130             self.src.read_buf(&mut buf[FRAME_HDR_SIZE..])?;
 131         } else {
 132             buf.resize(cur_frame.size as usize, 0);
 133             self.src.read_buf(&mut buf)?;
 134         }
 135
 136         self.fno += 1;
 137
 138         let str_id = if is_video { self.vid_id } else { self.aud_id };
 139         let str = strmgr.get_stream(str_id).unwrap();
 140         let (tb_num, tb_den) = str.get_timebase();
 141         let ts = NATimeInfo::new(Some(cur_frame.ts as u64), None, None, tb_num, tb_den);
 142         let pkt = NAPacket::new(str, ts, false, buf);
 143
 144         Ok(pkt)
 145     }
 146
 147     #[allow(unused_variables)]
 148     fn seek(&mut self, time: u64) -> DemuxerResult<()> {
 149         Err(DemuxerError::NotImplemented)
 150     }
 151 }
 152
 153 impl<'a> VMDDemuxer<'a> {
 154     fn new(io: &'a mut ByteReader<'a>) -> Self {
 155         Self {
 156             src:        io,
 157             vid_id:     0,
 158             aud_id:     0,
 159             fno:        0,
 160             is_indeo:   false,
 161             frames:     Vec::new(),
 162         }
 163     }
 164 }
 165
 166 pub struct VMDDemuxerCreator { }
 167
 168 impl DemuxerCreator for VMDDemuxerCreator {
 169     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
 170         Box::new(VMDDemuxer::new(br))
 171     }
 172     fn get_name(&self) -> &'static str { "vmd" }
 173 }
 174
 175 #[cfg(test)]
 176 mod test {
 177     use super::*;
 178     use std::fs::File;
 179
 180     #[test]
 181     fn test_vmd_demux() {
 182         let mut file = File::open("assets/128.vmd").unwrap();
 183         //let mut file = File::open("assets/1491.VMD").unwrap();
 184         let mut fr = FileReader::new_read(&mut file);
 185         let mut br = ByteReader::new(&mut fr);
 186         let mut dmx = VMDDemuxer::new(&mut br);
 187         let mut sm = StreamManager::new();
 188         dmx.open(&mut sm).unwrap();
 189         loop {
 190             let pktres = dmx.get_frame(&mut sm);
 191             if let Err(e) = pktres {
 192                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 193                 panic!("error");
 194             }
 195             let pkt = pktres.unwrap();
 196             println!("Got {}", pkt);
 197         }
 198     }
 199 }