nihav-game/src/demuxers/cnm.rs

   1 use nihav_core::frame::*;
   2 use nihav_core::demuxers::*;
   3
   4 struct ArxelCinemaDemuxer<'a> {
   5     src:        &'a mut ByteReader<'a>,
   6     cur_frame:  usize,
   7     astreams:   usize,
   8     offsets:    Vec<u32>,
   9     vpts:       u64,
  10     tb_num:     u32,
  11     tb_den:     u32,
  12     is_ci2:     bool,
  13     tdata:      Vec<u8>,
  14 }
  15
  16 impl<'a> DemuxCore<'a> for ArxelCinemaDemuxer<'a> {
  17     #[allow(unused_variables)]
  18     fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
  19         let src = &mut self.src;
  20
  21         let magic                       = src.read_tag()?;
  22         validate!(&magic == b"CNM ");
  23         let magic                       = src.read_tag()?;
  24         validate!(&magic == b"UNR\x00");
  25         let _duration                   = src.read_u32le()?;
  26         let tb_den                      = src.read_u32le()?;
  27                                           src.read_byte()?;
  28         let width                       = src.read_u32le()? as usize;
  29         let height                      = src.read_u32le()? as usize;
  30         validate!(width != 0 && height != 0);
  31                                           src.read_u16le()?;
  32         self.astreams                   = src.read_byte()? as usize;
  33         validate!(self.astreams < 4);
  34         if self.astreams > 1 {
  35             return Err(DemuxerError::NotImplemented);
  36         }
  37         let nframes                     = src.read_u32le()? as usize;
  38                                           src.read_u32le()?; //nframes again?
  39         let tab_size                    = src.read_u32le()? as usize;
  40                                           src.read_skip(0x98)?;
  41
  42         let vhdr = NAVideoInfo::new(width, height, true, RGB24_FORMAT);
  43         let vci = NACodecTypeInfo::Video(vhdr);
  44         // use tab_size mismatch as the version marker
  45         let vinfo = NACodecInfo::new("arxel-video", vci, Some(vec![(tab_size != nframes * 8) as u8]));
  46         if strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 100, tb_den, nframes as u64)).is_none() {
  47             return Err(DemuxerError::MemoryError);
  48         }
  49         if let Some(stream) = strmgr.get_stream_by_id(0) {
  50             let (tb_num, tb_den) = stream.get_timebase();
  51             self.tb_num = tb_num;
  52             self.tb_den = tb_den;
  53         }
  54
  55         for trk in 0..(self.astreams as u32) {
  56             let channels                = src.read_byte()? + 1;
  57             let abits                   = src.read_byte()?;
  58             let arate                   = src.read_u32le()?;
  59                                           src.read_skip(10)?;
  60             validate!(channels > 0);
  61             validate!(abits >= 8);
  62             validate!(arate > 0);
  63
  64             let ahdr = NAAudioInfo::new(arate, channels, if abits > 8 { SND_S16_FORMAT } else { SND_U8_FORMAT }, 2);
  65             let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
  66             if strmgr.add_stream(NAStream::new(StreamType::Audio, 1 + trk, ainfo, 1, arate, 0)).is_none() {
  67                 return Err(DemuxerError::MemoryError);
  68             }
  69         }
  70
  71         if tab_size == nframes * 8 {
  72             let tab_size = tab_size / 4;
  73             self.offsets = Vec::with_capacity(tab_size);
  74             for _ in 0..tab_size {
  75                 let offset                  = src.read_u32le()?;
  76                 self.offsets.push(offset);
  77             }
  78         } else {
  79             validate!(nframes > 0);
  80             let off0                    = src.read_u32le()?;
  81             let off1                    = src.read_u32le()?;
  82             if off0 == 0 && off1 == 0 {
  83                 self.is_ci2 = true;
  84                                           src.read_skip((nframes - 1) * 8)?;
  85             } else {
  86                 return Err(DemuxerError::InvalidData);
  87             }
  88         }
  89         self.cur_frame = 0;
  90         self.vpts = 0;
  91         Ok(())
  92     }
  93
  94     #[allow(unused_variables)]
  95     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
  96         loop {
  97             let stream_id;
  98             if !self.is_ci2 {
  99                 if self.cur_frame >= self.offsets.len() { return Err(DemuxerError::EOF); }
 100                 let pos = u64::from(self.offsets[self.cur_frame]);
 101                 stream_id = (self.cur_frame % (self.astreams.max(1) + 1)) as u32;
 102                 self.cur_frame += 1;
 103                 if pos == 0 {
 104                     continue;
 105                 }
 106                                           self.src.seek(SeekFrom::Start(pos))?;
 107             } else {
 108                 stream_id = 1;
 109             }
 110             let ftype = match self.src.read_byte() {
 111                     Ok(b) => b,
 112                     Err(ByteIOError::EOF) if self.is_ci2 => return Err(DemuxerError::EOF),
 113                     _ => return Err(DemuxerError::IOError),
 114                 };
 115             match ftype {
 116                 0x41 | 0x42 | 0x5A => {
 117                     let size            = self.src.read_u32le()? as usize;
 118                     if size == 0 {
 119                         continue;
 120                     }
 121                     if let Some(stream) = strmgr.get_stream_by_id(stream_id) {
 122                         let ts = stream.make_ts(None, None, None);
 123                         return self.src.read_packet(stream, ts, true, size);
 124                     } else {
 125                                           self.src.read_skip(size)?;
 126                     }
 127                 },
 128                 0x53 if !self.is_ci2 => {
 129                     let size            = self.src.peek_u32le()? as usize;
 130                     if let Some(stream) = strmgr.get_stream_by_id(0) {
 131                         let ts = stream.make_ts(Some(self.vpts), None, None);
 132                         self.vpts += 1;
 133                         return self.src.read_packet(stream, ts, true, size + 0x2F);
 134                     } else {
 135                         return Err(DemuxerError::MemoryError);
 136                     }
 137                 },
 138                 0x53 | 0x55 => {
 139                     let size            = self.src.peek_u32le()? as usize;
 140                     let mut data = Vec::new();
 141                     std::mem::swap(&mut self.tdata, &mut data);
 142                     data.push(ftype);
 143                     let head_size = data.len();
 144                     data.resize(head_size + size + 0x2F, 0);
 145                                           self.src.read_buf(&mut data[head_size..])?;
 146                     if let Some(stream) = strmgr.get_stream_by_id(0) {
 147                         let ts = stream.make_ts(Some(self.vpts), None, None);
 148                         self.vpts += 1;
 149                         return Ok(NAPacket::new(stream, ts, ftype == 0x55, data));
 150                     } else {
 151                         return Err(DemuxerError::MemoryError);
 152                     }
 153                 },
 154                 0x54 => {
 155                     validate!(self.is_ci2);
 156                     let size            = self.src.peek_u32le()? as usize;
 157                     validate!(self.tdata.is_empty());
 158                     self.tdata.resize(size + 9, 0);
 159                     self.tdata[0] = 0x54;
 160                                           self.src.read_buf(&mut self.tdata[1..])?;
 161                 },
 162                 _ => continue,
 163             };
 164         }
 165     }
 166
 167     fn seek(&mut self, time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
 168         if self.is_ci2 {
 169             return Err(DemuxerError::NotPossible);
 170         }
 171         match time {
 172             NATimePoint::PTS(pts) => self.seek_to_frame(pts),
 173             NATimePoint::Milliseconds(ms) => {
 174                 if self.tb_num == 0 || self.tb_den == 0 {
 175                     return Err(DemuxerError::NotPossible);
 176                 }
 177                 let pts = NATimeInfo::time_to_ts(ms, 1000, self.tb_num, self.tb_den);
 178                 self.seek_to_frame(pts)
 179             },
 180             _ => Err(DemuxerError::NotPossible)
 181         }
 182     }
 183     fn get_duration(&self) -> u64 { 0 }
 184 }
 185 impl<'a> NAOptionHandler for ArxelCinemaDemuxer<'a> {
 186     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 187     fn set_options(&mut self, _options: &[NAOption]) { }
 188     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 189 }
 190 impl<'a> ArxelCinemaDemuxer<'a> {
 191     fn new(io: &'a mut ByteReader<'a>) -> Self {
 192         ArxelCinemaDemuxer {
 193             src:        io,
 194             cur_frame:  0,
 195             astreams:   0,
 196             offsets:    Vec::new(),
 197             vpts:       0,
 198             tb_num:     0,
 199             tb_den:     0,
 200             is_ci2:     false,
 201             tdata:      Vec::new(),
 202         }
 203     }
 204     fn seek_to_frame(&mut self, pts: u64) -> DemuxerResult<()> {
 205         let nframe = (pts as usize) * (1 + self.astreams.max(1));
 206         if nframe < self.offsets.len() {
 207             self.cur_frame = nframe;
 208             Ok(())
 209         } else {
 210             Err(DemuxerError::SeekError)
 211         }
 212     }
 213 }
 214
 215 pub struct CNMDemuxerCreator { }
 216
 217 impl DemuxerCreator for CNMDemuxerCreator {
 218     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
 219         Box::new(ArxelCinemaDemuxer::new(br))
 220     }
 221     fn get_name(&self) -> &'static str { "arxel-cnm" }
 222 }
 223
 224 #[cfg(test)]
 225 mod test {
 226     use super::*;
 227     use std::fs::File;
 228
 229     // samples from the Ring game
 230     #[test]
 231     fn test_cnm_demux() {
 232         let mut file = File::open("assets/Game/logo.cnm").unwrap();
 233         let mut fr = FileReader::new_read(&mut file);
 234         let mut br = ByteReader::new(&mut fr);
 235         let mut dmx = ArxelCinemaDemuxer::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     #[test]
 250     fn test_cnm_noaud_demux() {
 251         let mut file = File::open("assets/Game/tr_as_ro_d.cnm").unwrap();
 252         let mut fr = FileReader::new_read(&mut file);
 253         let mut br = ByteReader::new(&mut fr);
 254         let mut dmx = ArxelCinemaDemuxer::new(&mut br);
 255         let mut sm = StreamManager::new();
 256         let mut si = SeekIndex::new();
 257         dmx.open(&mut sm, &mut si).unwrap();
 258         loop {
 259             let pktres = dmx.get_frame(&mut sm);
 260             if let Err(e) = pktres {
 261                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 262                 panic!("error");
 263             }
 264             let pkt = pktres.unwrap();
 265             println!("Got {}", pkt);
 266         }
 267     }
 268     // sample from Faust: The Seven Games of the Soul game
 269     #[test]
 270     fn test_ci2_demux() {
 271         let mut file = File::open("assets/Game/logo.CI2").unwrap();
 272         let mut fr = FileReader::new_read(&mut file);
 273         let mut br = ByteReader::new(&mut fr);
 274         let mut dmx = ArxelCinemaDemuxer::new(&mut br);
 275         let mut sm = StreamManager::new();
 276         let mut si = SeekIndex::new();
 277         dmx.open(&mut sm, &mut si).unwrap();
 278         loop {
 279             let pktres = dmx.get_frame(&mut sm);
 280             if let Err(e) = pktres {
 281                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 282                 panic!("error");
 283             }
 284             let pkt = pktres.unwrap();
 285             println!("Got {}", pkt);
 286         }
 287     }
 288 }