introduce option handling for demuxers

[nihav.git] / nihav-rad / src / demuxers / bink.rs

diff --git a/nihav-rad/src/demuxers/bink.rs b/nihav-rad/src/demuxers/bink.rs
index ef0e14893234070038609fcb8b0ac4893dee7efc..35bdcbf6126234a4030f432412403901e7c9f4e6 100644 (file)
--- a/nihav-rad/src/demuxers/bink.rs
+++ b/nihav-rad/src/demuxers/bink.rs
@@ -49,7 +49,7 @@ macro_rules! mktag {
 }
 
 impl<'a> DemuxCore<'a> for BinkDemuxer<'a> {
-    fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
+    fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
         let src = &mut self.src;
         let mut magic: [u8; 4] = [0; 4];
                                               src.read_buf(&mut magic)?;
@@ -66,10 +66,11 @@ impl<'a> DemuxCore<'a> for BinkDemuxer<'a> {
         let tb_num                          = src.read_u32le()?;
         validate!((width > 0) && (height > 0) && (width <= 7680) && (height <= 4800));
         validate!((self.frames > 0) && (tb_num > 0) && (tb_den > 0) && (max_size < fsize));
+        self.tb_num = tb_num;
+        self.tb_den = tb_den;
         let mut flags: [u8; 4] = [0; 4];
                                               src.read_buf(&mut flags)?;
-        let mut edata: Vec<u8> = Vec::with_capacity(8);
-        edata.resize(8, 0);
+        let mut edata: Vec<u8> = vec![0; 8];
         let p0 = &mut edata[0..4];
         p0.copy_from_slice(&magic);
         let p1 = &mut edata[4..][..4];
@@ -98,15 +99,22 @@ impl<'a> DemuxCore<'a> for BinkDemuxer<'a> {
             let _trk_id                     = src.read_u32le()?;
         }
 
+        seek_idx.mode = SeekIndexMode::Present;
+        seek_idx.add_stream(0);
         self.frame_pos = Vec::with_capacity(self.frames + 1);
-        for _ in 0..self.frames+1 {
+        for fno in 0..=self.frames {
             let pos                         = src.read_u32le()?;
             self.frame_pos.push(pos);
+            if (pos & 1) != 0 {
+                let time = (fno as u64) * 1000 * (tb_num as u64) / (tb_den as u64);
+                seek_idx.seek_info[0].add_entry(SeekEntry { time, pts: fno as u64, pos: (pos & !1) as u64 });
+            }
         }
         validate!((src.tell() as u32) == (self.frame_pos[0] & !1));
+        seek_idx.seek_info[0].filled = true;
 
         self.cur_frame = 0;
-        
+
         Ok(())
     }
     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
@@ -144,12 +152,25 @@ impl<'a> DemuxCore<'a> for BinkDemuxer<'a> {
 
         Ok(pkt)
     }
-    #[allow(unused_variables)]
-    fn seek(&mut self, time: u64) -> DemuxerResult<()> {
-        Err(DemuxerError::NotImplemented)
+    fn seek(&mut self, time: u64, seek_idx: &SeekIndex) -> DemuxerResult<()> {
+        let ret = seek_idx.find_pos(time);
+        if ret.is_none() {
+            return Err(DemuxerError::SeekError);
+        }
+        let seek_info = ret.unwrap();
+        self.src.seek(SeekFrom::Start(seek_info.pos))?;
+        self.queued_packets.clear();
+        self.cur_frame = seek_info.pts as usize;
+        Ok(())
     }
 }
 
+impl<'a> NAOptionHandler for BinkDemuxer<'a> {
+    fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+    fn set_options(&mut self, _options: &[NAOption]) { }
+    fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+}
+
 impl<'a> BinkDemuxer<'a> {
     fn new(io: &'a mut ByteReader<'a>) -> Self {
         Self {
@@ -170,7 +191,7 @@ impl<'a> BinkDemuxer<'a> {
 pub struct BinkDemuxerCreator { }
 
 impl DemuxerCreator for BinkDemuxerCreator {
-    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
         Box::new(BinkDemuxer::new(br))
     }
     fn get_name(&self) -> &'static str { "bink" }
@@ -192,7 +213,8 @@ mod test {
         let mut br = ByteReader::new(&mut fr);
         let mut dmx = BinkDemuxer::new(&mut br);
         let mut sm = StreamManager::new();
-        dmx.open(&mut sm).unwrap();
+        let mut si = SeekIndex::new();
+        dmx.open(&mut sm, &mut si).unwrap();
         loop {
             let pktres = dmx.get_frame(&mut sm);
             if let Err(e) = pktres {