src/demuxers/gdv.rs

   1 use super::*;
   2 use io::byteio::*;
   3 use frame::*;
   4 use formats::*;
   5 //use std::collections::HashMap;
   6
   7 enum GDVState {
   8     NewFrame,
   9     AudioRead,
  10 }
  11
  12 #[allow(dead_code)]
  13 struct GremlinVideoDemuxer<'a> {
  14     opened:     bool,
  15     src:        &'a mut ByteReader<'a>,
  16     frames:     u16,
  17     cur_frame:  u16,
  18     asize:      usize,
  19     apacked:    bool,
  20     state:      GDVState,
  21     pktdta:     Vec<u8>,
  22     dmx:        Demuxer,
  23     a_id:       Option<usize>,
  24     v_id:       Option<usize>,
  25 }
  26
  27 impl<'a> Demux<'a> for GremlinVideoDemuxer<'a> {
  28     #[allow(unused_variables)]
  29     fn open(&mut self) -> DemuxerResult<()> {
  30         let src = &mut self.src;
  31         let magic = src.read_u32le()?;
  32         if magic != 0x29111994 { return Err(DemuxerError::InvalidData); }
  33         let id = src.read_u16le()?;
  34         let frames = src.read_u16le()?;
  35         let fps = src.read_u16le()?;
  36         let aflags = src.read_u16le()?;
  37         let rate = src.read_u16le()?;
  38         let depth = src.read_u16le()?;
  39         let max_fs = src.read_u16le()?;
  40         src.read_skip(2)?;
  41         let width = src.read_u16le()?;
  42         let height = src.read_u16le()?;
  43         if max_fs > 0 {
  44             let vhdr = NAVideoInfo::new(width as usize, height as usize, false, PAL8_FORMAT);
  45             let vci = NACodecTypeInfo::Video(vhdr);
  46             let vinfo = NACodecInfo::new("gdv-video", vci, None);
  47             self.v_id = self.dmx.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, fps as u32));
  48         }
  49         if (aflags & 1) != 0 {
  50             let channels = if (aflags & 2) != 0 { 2 } else { 1 };
  51             let ahdr = NAAudioInfo::new(rate as u32, channels as u8, if (aflags & 4) != 0 { SND_S16_FORMAT } else { SND_U8_FORMAT }, 2);
  52             let ainfo = NACodecInfo::new("gdv-audio", NACodecTypeInfo::Audio(ahdr), None);
  53             self.a_id = self.dmx.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, rate as u32));
  54
  55             let packed = if (aflags & 8) != 0 { 1 } else { 0 };
  56             self.asize = (((rate / fps) * channels * (if (aflags & 4) != 0 { 2 } else { 1 })) >> packed) as usize;
  57             self.apacked = (aflags & 8) != 0;
  58         }
  59         if max_fs > 0 && depth == 1 {
  60             src.read_skip(768)?;
  61         }
  62         self.frames = frames;
  63         self.opened = true;
  64         self.state = GDVState::NewFrame;
  65         Ok(())
  66     }
  67
  68     #[allow(unused_variables)]
  69     fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
  70         if !self.opened { return Err(DemuxerError::NoSuchInput); }
  71         if self.cur_frame >= self.frames { return Err(DemuxerError::EOF); }
  72         match self.state {
  73             GDVState::NewFrame if self.asize > 0 => { self.read_achunk() }
  74             _ => { self.read_vchunk() }
  75         }
  76     }
  77
  78     fn get_num_streams(&self) -> usize { self.dmx.get_num_streams() }
  79     fn get_stream(&self, idx: usize) -> Option<Rc<NAStream>> { self.dmx.get_stream(idx) }
  80
  81     #[allow(unused_variables)]
  82     fn seek(&mut self, time: u64) -> DemuxerResult<()> {
  83         if !self.opened { return Err(DemuxerError::NoSuchInput); }
  84         Err(DemuxerError::NotImplemented)
  85     }
  86 }
  87 /*impl<'a> Drop for GremlinVideoDemuxer<'a> {
  88     #[allow(unused_variables)]
  89     fn drop(&mut self) {
  90     }
  91 }*/
  92 impl<'a> GremlinVideoDemuxer<'a> {
  93     fn new(io: &'a mut ByteReader<'a>) -> Self {
  94         GremlinVideoDemuxer {
  95             cur_frame: 0,
  96             frames: 0,
  97             opened: false,
  98             asize: 0,
  99             apacked: false,
 100             state: GDVState::NewFrame,
 101 pktdta: Vec::new(),
 102             src: io,
 103             a_id: None,
 104             v_id: None,
 105             dmx: Demuxer::new()
 106         }
 107     }
 108
 109     fn read_achunk(&mut self) -> DemuxerResult<NAPacket> {
 110         self.state = GDVState::AudioRead;
 111         let str = self.dmx.get_stream(self.a_id.unwrap()).unwrap();
 112         let (tb_num, tb_den) = str.get_timebase();
 113         let ts = NATimeInfo::new(Some(self.cur_frame as u64), None, None, tb_num, tb_den);
 114         self.src.read_packet(str, ts, true, self.asize)
 115     }
 116
 117     fn read_vchunk(&mut self) -> DemuxerResult<NAPacket> {
 118         let str = self.dmx.get_stream(self.v_id.unwrap()).unwrap();
 119         let mut src = &mut self.src;
 120         let magic = src.read_u16be()?;
 121         if magic != 0x0513 { return Err(DemuxerError::InvalidData); }
 122         let size = (src.read_u16le()? as usize) + 4;
 123         let tmp = src.peek_u32le()?;
 124         let flags = (tmp & 0xFF) as usize;
 125         self.state = GDVState::NewFrame;
 126         self.cur_frame = self.cur_frame + 1;
 127         let (tb_num, tb_den) = str.get_timebase();
 128         let ts = NATimeInfo::new(Some((self.cur_frame - 1) as u64), None, None, tb_num, tb_den);
 129         src.read_packet(str, ts, if (flags & 64) != 0 { true } else { false }, size)
 130     }
 131 }
 132
 133 pub struct GDVDemuxerCreator { }
 134
 135 impl DemuxerCreator for GDVDemuxerCreator {
 136     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<Demux<'a> + 'a> {
 137         Box::new(GremlinVideoDemuxer::new(br))
 138     }
 139     fn get_name(&self) -> &'static str { "gdv" }
 140 }
 141
 142 #[cfg(test)]
 143 mod test {
 144     use super::*;
 145     use std::fs::File;
 146
 147     #[test]
 148     fn test_gdv_demux() {
 149         let mut file = File::open("assets/intro1.gdv").unwrap();
 150         let mut fr = FileReader::new_read(&mut file);
 151         let mut br = ByteReader::new(&mut fr);
 152         let mut dmx = GremlinVideoDemuxer::new(&mut br);
 153         dmx.open().unwrap();
 154         loop {
 155             let pktres = dmx.get_frame();
 156             if let Err(e) = pktres {
 157                 if (e as i32) == (DemuxerError::EOF as i32) { break; }
 158                 panic!("error");
 159             }
 160             let pkt = pktres.unwrap();
 161             println!("Got {}", pkt);
 162         }
 163     }
 164 }