nihav-game/src/demuxers/q.rs

   1 use nihav_core::frame::*;
   2 use nihav_core::demuxers::*;
   3
   4 #[allow(dead_code)]
   5 struct QDemuxer<'a> {
   6     src:        &'a mut ByteReader<'a>,
   7     vpts:       u64,
   8     apts:       u64,
   9     bps:        usize,
  10     a_id:       Option<usize>,
  11     v_id:       Option<usize>,
  12     nframes:    usize,
  13     duration:   u64,
  14     side_data:  Vec<u8>,
  15 }
  16
  17 impl<'a> DemuxCore<'a> for QDemuxer<'a> {
  18     #[allow(unused_variables)]
  19     fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
  20         let src = &mut self.src;
  21
  22         let mut hdr = [0; 22];
  23                                           src.read_buf(&mut hdr)?;
  24         validate!(hdr[0] == 0x39);
  25         validate!(hdr[1] == 0x68);
  26         let version = hdr[2];
  27         validate!(version >= 3 && version <= 5);
  28         let mut width  = read_u16le(&hdr[4..])? as usize;
  29         let mut height = read_u16le(&hdr[6..])? as usize;
  30         if version > 3 {
  31             width  *= hdr[8] as usize;
  32             height *= hdr[9] as usize;
  33         }
  34         validate!(width > 0 && width <= 800);
  35         validate!(height > 0 && height <= 600);
  36
  37         self.nframes = read_u16le(&hdr[10..])? as usize;
  38         validate!(self.nframes > 0);
  39         let fps = if hdr[16] == 0 { 5 } else { hdr[16] as u32 };
  40         self.duration = (self.nframes as u64) * 1000 / u64::from(fps);
  41         let asize = if version > 3 {
  42                                           src.read_u32le()?
  43             } else { 0 };
  44
  45         let vhdr = NAVideoInfo::new(width, height, false, PAL8_FORMAT);
  46         let vci = NACodecTypeInfo::Video(vhdr);
  47         let vinfo = NACodecInfo::new("legend-q-video", vci, Some(hdr.to_vec()));
  48         self.v_id = strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, fps, self.nframes as u64));
  49         if asize != 0 {
  50             let ntype                   = self.src.peek_byte()?;
  51             if ntype == 8 {
  52                 let _                   = self.src.read_u16le()?;
  53                 let size                = self.src.read_u32le()? as usize;
  54                 validate!(size >= 44);
  55                 let mut buf = vec![0; size];
  56                                           self.src.read_buf(&mut buf)?;
  57                 let arate = read_u32le(&buf[24..])?;
  58                 let channels = buf[22];
  59                 let abits    = buf[34] as usize;
  60                 validate!(abits == 8 || abits == 16);
  61                 self.bps = (channels as usize) * abits / 8;
  62                 let bsize    = read_u16le(&buf[32..])? as usize;
  63                 let ahdr = NAAudioInfo::new(arate, channels as u8, if abits == 16 { SND_S16_FORMAT } else { SND_U8_FORMAT }, bsize);
  64                 let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
  65                 self.a_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, arate, 2));
  66             }
  67         }
  68         self.apts = 0;
  69         self.vpts = 0;
  70         self.side_data.clear();
  71         Ok(())
  72     }
  73
  74     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
  75         loop {
  76             let ctype                   = self.src.read_u16le()?;
  77             let size                    = self.src.read_u32le()? as usize;
  78             match ctype {
  79                 0xFFFF => return Err(DemuxerError::EOF),
  80                 0 => {
  81                     if let Some(a_id) = self.a_id {
  82                         let str = strmgr.get_stream(a_id).unwrap();
  83                         let (tb_num, tb_den) = str.get_timebase();
  84                         let ts = NATimeInfo::new(Some(self.apts), None, None, tb_num, tb_den);
  85                         self.apts += (size / self.bps) as u64;
  86                         return self.src.read_packet(str, ts, true, size);
  87                     } else {
  88                         return Err(DemuxerError::InvalidData);
  89                     }
  90                 },
  91                 1 => {
  92                     validate!(size <= 768);
  93                     let cur_len = self.side_data.len();
  94                     self.side_data.resize(cur_len + size + 6, 0);
  95                     self.side_data[cur_len] = ctype as u8;
  96                     write_u32le(&mut self.side_data[cur_len + 2..], size as u32)?;
  97                                           self.src.read_buf(&mut self.side_data[cur_len + 6..])?;
  98                 },
  99                 2 | 3 | 4 | 11 => {
 100                     validate!(self.v_id.is_some());
 101                     let str = strmgr.get_stream(self.v_id.unwrap_or(0)).unwrap();
 102                     let (tb_num, tb_den) = str.get_timebase();
 103                     let ts = NATimeInfo::new(Some(self.vpts), None, None, tb_num, tb_den);
 104                     self.vpts += 1;
 105
 106                     let cur_len = self.side_data.len();
 107                     self.side_data.resize(cur_len + size + 6, 0);
 108                     self.side_data[cur_len] = ctype as u8;
 109                     self.side_data[cur_len] = ctype as u8;
 110                     write_u32le(&mut self.side_data[cur_len + 2..], size as u32)?;
 111                     if let Err(err)       = self.src.read_buf(&mut self.side_data[cur_len + 6..]) {
 112                         self.side_data.truncate(cur_len);
 113                         return Err(err.into());
 114                     }
 115                     let mut buf = Vec::new();
 116                     std::mem::swap(&mut buf, &mut self.side_data);
 117                     return Ok(NAPacket::new(str, ts, self.vpts == 1, buf));
 118                 },
 119                 5 => {
 120                     validate!(size <= 256);
 121                     let cur_len = self.side_data.len();
 122                     self.side_data.resize(cur_len + size + 6, 0);
 123                     self.side_data[cur_len] = ctype as u8;
 124                     write_u32le(&mut self.side_data[cur_len + 2..], size as u32)?;
 125                                           self.src.read_buf(&mut self.side_data[cur_len + 6..])?;
 126                 },
 127                 6 | 7 => {
 128                     self.side_data.push(ctype as u8);
 129                     self.side_data.push(0);
 130                     self.side_data.push(0);
 131                     self.side_data.push(0);
 132                     self.side_data.push(0);
 133                     self.side_data.push(0);
 134                 },
 135                 8 => return Err(DemuxerError::InvalidData), //should be handled before main loop
 136                 9 => { // first part of interlaced frame
 137                     let cur_len = self.side_data.len();
 138                     self.side_data.resize(cur_len + size + 6, 0);
 139                     self.side_data[cur_len] = ctype as u8;
 140                     write_u32le(&mut self.side_data[cur_len + 2..], size as u32)?;
 141                                           self.src.read_buf(&mut self.side_data[cur_len + 6..])?;
 142                 },
 143                 _ => {
 144                                           self.src.read_skip(size)?;
 145                 },
 146             };
 147         }
 148     }
 149
 150     fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
 151         Err(DemuxerError::NotPossible)
 152     }
 153     fn get_duration(&self) -> u64 { self.duration }
 154 }
 155 impl<'a> NAOptionHandler for QDemuxer<'a> {
 156     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 157     fn set_options(&mut self, _options: &[NAOption]) { }
 158     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 159 }
 160 impl<'a> QDemuxer<'a> {
 161     fn new(io: &'a mut ByteReader<'a>) -> Self {
 162         QDemuxer {
 163             src:        io,
 164             vpts:       0,
 165             apts:       0,
 166             bps:        0,
 167             a_id:       None,
 168             v_id:       None,
 169             nframes:    0,
 170             duration:   0,
 171             side_data:  Vec::with_capacity(256 + 6),
 172         }
 173     }
 174 }
 175
 176 pub struct QDemuxerCreator { }
 177
 178 impl DemuxerCreator for QDemuxerCreator {
 179     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
 180         Box::new(QDemuxer::new(br))
 181     }
 182     fn get_name(&self) -> &'static str { "legend-q" }
 183 }
 184
 185 #[cfg(test)]
 186 mod test {
 187     use super::*;
 188     use std::fs::File;
 189
 190     #[test]
 191     fn test_q_demux_v3() {
 192         let mut file = File::open("assets/Game/dgate101.q").unwrap();
 193         let mut fr = FileReader::new_read(&mut file);
 194         let mut br = ByteReader::new(&mut fr);
 195         let mut dmx = QDemuxer::new(&mut br);
 196         let mut sm = StreamManager::new();
 197         let mut si = SeekIndex::new();
 198         dmx.open(&mut sm, &mut si).unwrap();
 199         loop {
 200             let pktres = dmx.get_frame(&mut sm);
 201             if let Err(e) = pktres {
 202                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 203                 panic!("error");
 204             }
 205             let pkt = pktres.unwrap();
 206             println!("Got {}", pkt);
 207         }
 208     }
 209
 210     #[test]
 211     fn test_q_demux_v4() {
 212         let mut file = File::open("assets/Game/1425A5.Q").unwrap();
 213         let mut fr = FileReader::new_read(&mut file);
 214         let mut br = ByteReader::new(&mut fr);
 215         let mut dmx = QDemuxer::new(&mut br);
 216         let mut sm = StreamManager::new();
 217         let mut si = SeekIndex::new();
 218         dmx.open(&mut sm, &mut si).unwrap();
 219         loop {
 220             let pktres = dmx.get_frame(&mut sm);
 221             if let Err(e) = pktres {
 222                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 223                 panic!("error");
 224             }
 225             let pkt = pktres.unwrap();
 226             println!("Got {}", pkt);
 227         }
 228     }
 229
 230     #[test]
 231     fn test_q_demux_v5() {
 232         let mut file = File::open("assets/Game/mc703.q").unwrap();
 233         let mut fr = FileReader::new_read(&mut file);
 234         let mut br = ByteReader::new(&mut fr);
 235         let mut dmx = QDemuxer::new(&mut br);
 236         let mut sm = StreamManager::new();
 237         let mut si = SeekIndex::new();
 238         dmx.open(&mut sm, &mut si).unwrap();
 239         loop {
 240             let pktres = dmx.get_frame(&mut sm);
 241             if let Err(e) = pktres {
 242                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 243                 panic!("error");
 244             }
 245             let pkt = pktres.unwrap();
 246             println!("Got {}", pkt);
 247         }
 248     }
 249 }