nihav-game/src/demuxers/hl_fmv.rs

   1 use nihav_core::frame::*;
   2 use nihav_core::demuxers::*;
   3
   4 #[allow(dead_code)]
   5 struct HighlanderFMVDemuxer<'a> {
   6     src:        &'a mut ByteReader<'a>,
   7     vpts:       u64,
   8     apts:       u64,
   9 }
  10
  11 impl<'a> DemuxCore<'a> for HighlanderFMVDemuxer<'a> {
  12     #[allow(unused_variables)]
  13     fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
  14         let src = &mut self.src;
  15
  16         let tag                         = src.read_tag()?;
  17         validate!(&tag == b"FMV*");
  18         let size                        = src.read_u32le()?;
  19         validate!(size == 0);
  20
  21         let vhdr = NAVideoInfo::new(320, 240, false, PAL8_FORMAT);
  22         let vci = NACodecTypeInfo::Video(vhdr);
  23         let vinfo = NACodecInfo::new("hl-fmv-video", vci, None);
  24         if strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 2, 25, 0)).is_none() {
  25             return Err(DemuxerError::MemoryError);
  26         }
  27         let ahdr = NAAudioInfo::new(22050, 1, SND_U8_FORMAT, 1);
  28         let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
  29         if strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, 22050, 0)).is_none() {
  30             return Err(DemuxerError::MemoryError);
  31         }
  32
  33         self.apts = 0;
  34         self.vpts = 0;
  35         Ok(())
  36     }
  37
  38     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
  39         let tag                         = self.src.read_tag()?;
  40         let size                        = self.src.read_u32le()? as usize;
  41         match &tag {
  42             b"AUD1" => {
  43                 let stream = strmgr.get_stream_by_id(1).unwrap();
  44                 let ts = stream.make_ts(Some(self.apts), None, None);
  45                 self.apts += size as u64;
  46                 self.src.read_packet(stream, ts, true, size)
  47             },
  48             b"VID3" => {
  49                 let stream = strmgr.get_stream_by_id(0).unwrap();
  50                 let ts = stream.make_ts(Some(self.vpts), None, None);
  51                 self.vpts += 1;
  52                 self.src.read_packet(stream, ts, true, size)
  53             },
  54             b"END*" => Err(DemuxerError::EOF),
  55             _ => Err(DemuxerError::InvalidData),
  56         }
  57     }
  58
  59     fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
  60         Err(DemuxerError::NotPossible)
  61     }
  62     fn get_duration(&self) -> u64 { 0 }
  63 }
  64 impl<'a> NAOptionHandler for HighlanderFMVDemuxer<'a> {
  65     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
  66     fn set_options(&mut self, _options: &[NAOption]) { }
  67     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
  68 }
  69 impl<'a> HighlanderFMVDemuxer<'a> {
  70     fn new(io: &'a mut ByteReader<'a>) -> Self {
  71         HighlanderFMVDemuxer {
  72             src:        io,
  73             vpts:       0,
  74             apts:       0,
  75         }
  76     }
  77 }
  78
  79 pub struct HighlanderFMVDemuxerCreator { }
  80
  81 impl DemuxerCreator for HighlanderFMVDemuxerCreator {
  82     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
  83         Box::new(HighlanderFMVDemuxer::new(br))
  84     }
  85     fn get_name(&self) -> &'static str { "hl-fmv" }
  86 }
  87
  88 #[cfg(test)]
  89 mod test {
  90     use super::*;
  91     use std::fs::File;
  92
  93     // sample extracted from Highlander: The Last of the MacLeods unpublished game
  94     #[test]
  95     fn test_highlander_fmv_demux() {
  96         let mut file = File::open("assets/Game/0010.fmv").unwrap();
  97         let mut fr = FileReader::new_read(&mut file);
  98         let mut br = ByteReader::new(&mut fr);
  99         let mut dmx = HighlanderFMVDemuxer::new(&mut br);
 100         let mut sm = StreamManager::new();
 101         let mut si = SeekIndex::new();
 102         dmx.open(&mut sm, &mut si).unwrap();
 103         loop {
 104             let pktres = dmx.get_frame(&mut sm);
 105             if let Err(e) = pktres {
 106                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 107                 panic!("error");
 108             }
 109             let pkt = pktres.unwrap();
 110             println!("Got {}", pkt);
 111         }
 112     }
 113 }