more work on supporting decoders in framework

[nihav.git] / src / demuxers / gdv.rs

diff --git a/src/demuxers/gdv.rs b/src/demuxers/gdv.rs
index c556197828dec46036905efe4e499d1bcb860b40..09c26202cca75333db51aa5618043b3d1b9a622e 100644 (file)
--- a/src/demuxers/gdv.rs
+++ b/src/demuxers/gdv.rs
@@ -1,7 +1,7 @@
 use super::*;
 use io::byteio::*;
 use frame::*;
-use std::io::SeekFrom;
+use formats::*;
 //use std::collections::HashMap;
 
 enum GDVState {
@@ -11,18 +11,20 @@ enum GDVState {
 
 #[allow(dead_code)]
 pub struct GremlinVideoDemuxer<'a> {
-    opened: bool,
-    src:    &'a mut ByteReader<'a>,
-    streams: Vec<Rc<NAStream<'a>>>,
-    frames: u16,
-    cur_frame: u16,
-    asize: usize,
-    apacked: bool,
-    state: GDVState,
-    pktdta: Vec<u8>,
+    opened:     bool,
+    src:        &'a mut ByteReader<'a>,
+    frames:     u16,
+    cur_frame:  u16,
+    asize:      usize,
+    apacked:    bool,
+    state:      GDVState,
+    pktdta:     Vec<u8>,
+    dmx:        Demuxer,
+    a_id:       Option<usize>,
+    v_id:       Option<usize>,
 }
 
-impl<'a> NADemuxer<'a> for GremlinVideoDemuxer<'a> {
+impl<'a> Demux<'a> for GremlinVideoDemuxer<'a> {
     #[allow(unused_variables)]
     fn open(&mut self) -> DemuxerResult<()> {
         let src = &mut self.src;
@@ -38,25 +40,21 @@ impl<'a> NADemuxer<'a> for GremlinVideoDemuxer<'a> {
         src.read_skip(2)?;
         let width = src.read_u16le()?;
         let height = src.read_u16le()?;
-println!("id {} frames {} fps {} sound {} Hz {:X} img {} - {}x{}",id,frames,fps,rate,aflags,depth,width,height);
         if max_fs > 0 {
-            let vhdr = NAVideoInfo::new(width as u32, height as u32, false, PAL8_FORMAT);
+            let vhdr = NAVideoInfo::new(width as usize, height as usize, false, PAL8_FORMAT);
             let vci = NACodecTypeInfo::Video(vhdr);
-            let vinfo = NACodecInfo::new(vci, None);
-            let vstr = NAStream::new(StreamType::Video, 0, vinfo);
-            self.streams.push(Rc::new(vstr));
+            let vinfo = NACodecInfo::new("video-gdv", vci, None);
+            self.v_id = self.dmx.add_stream(NAStream::new(StreamType::Video, 0, vinfo));
         }
         if (aflags & 1) != 0 {
             let channels = if (aflags & 2) != 0 { 2 } else { 1 };
             let ahdr = NAAudioInfo::new(rate as u32, channels as u8, if (aflags & 4) != 0 { SND_S16_FORMAT } else { SND_U8_FORMAT }, 2);
-            let ainfo = NACodecInfo::new(NACodecTypeInfo::Audio(ahdr), None);
-            let astr = NAStream::new(StreamType::Audio, 1, ainfo);
-            self.streams.push(Rc::new(astr));
+            let ainfo = NACodecInfo::new("audio-gdv", NACodecTypeInfo::Audio(ahdr), None);
+            self.a_id = self.dmx.add_stream(NAStream::new(StreamType::Audio, 1, ainfo));
 
             let packed = if (aflags & 8) != 0 { 1 } else { 0 };
             self.asize = (((rate / fps) * channels * (if (aflags & 4) != 0 { 2 } else { 1 })) >> packed) as usize;
             self.apacked = (aflags & 8) != 0;
-println!("audio chunk size {}({:X})",self.asize,self.asize);
         }
         if max_fs > 0 && depth == 1 {
             src.read_skip(768)?;
@@ -77,6 +75,9 @@ println!("audio chunk size {}({:X})",self.asize,self.asize);
         }
     }
 
+    fn get_num_streams(&self) -> usize { self.dmx.get_num_streams() }
+    fn get_stream(&self, idx: usize) -> Option<Rc<NAStream>> { self.dmx.get_stream(idx) }
+
     #[allow(unused_variables)]
     fn seek(&mut self, time: u64) -> DemuxerResult<()> {
         if !self.opened { return Err(DemuxerError::NoSuchInput); }
@@ -99,33 +100,26 @@ impl<'a> GremlinVideoDemuxer<'a> {
             state: GDVState::NewFrame,
 pktdta: Vec::new(),
             src: io,
-            streams: Vec::new()
+            a_id: None,
+            v_id: None,
+            dmx: Demuxer::new()
         }
     }
 
-    fn find_stream(&mut self, id: u32) -> Rc<NAStream<'a>> {
-        for i in 0..self.streams.len() {
-            if self.streams[i].get_id() == id {
-                return self.streams[i].clone();
-            }
-        }
-        panic!("stream not found");
-    }
     fn read_achunk(&mut self) -> DemuxerResult<NAPacket> {
         self.state = GDVState::AudioRead;
-        let str = self.find_stream(1);
+        let str = self.dmx.get_stream(self.a_id.unwrap()).unwrap();
         self.src.read_packet(str, Some(self.cur_frame as u64), None, None, true, self.asize)
     }
 
     fn read_vchunk(&mut self) -> DemuxerResult<NAPacket> {
-        let str = self.find_stream(0);
+        let str = self.dmx.get_stream(self.v_id.unwrap()).unwrap();
         let mut src = &mut self.src;
         let magic = src.read_u16be()?;
         if magic != 0x0513 { return Err(DemuxerError::InvalidData); }
         let size = (src.read_u16le()? as usize) + 4;
-        let tmp = src.read_u32le()?;
+        let tmp = src.peek_u32le()?;
         let flags = (tmp & 0xFF) as usize;
-        src.seek(SeekFrom::Current(-4))?;
         self.state = GDVState::NewFrame;
         self.cur_frame = self.cur_frame + 1;
         src.read_packet(str, Some((self.cur_frame - 1) as u64), None, None, if (flags & 64) != 0 { true } else { false }, size)