introduce option handling for demuxers

[nihav.git] / nihav-realmedia / src / demuxers / realmedia.rs

diff --git a/nihav-realmedia/src/demuxers/realmedia.rs b/nihav-realmedia/src/demuxers/realmedia.rs
index fa3920a0a3d0d042d7493bcf24755cf370ded324..d591eab3367b2de9336ea5ac656a32a6833c2d72 100644 (file)
--- a/nihav-realmedia/src/demuxers/realmedia.rs
+++ b/nihav-realmedia/src/demuxers/realmedia.rs
@@ -53,13 +53,15 @@ impl RMVideoStream {
         self.frame.resize(frame_size + self.hdr_size, 0);
         self.frame[0] = (num_slices - 1) as u8;
         self.frame_pos = 0;
-        self.add_slice(1, data);
+        self.add_slice(1, data).unwrap();
     }
-    fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
+    fn add_slice(&mut self, slice_no: usize, data: &[u8]) -> DemuxerResult<()> {
+        validate!(self.hdr_size + self.frame_pos + data.len() <= self.frame.len());
         self.write_slice_info(slice_no);
         let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
         dslice.copy_from_slice(data);
         self.frame_pos += data.len();
+        Ok(())
     }
     fn write_slice_info(&mut self, slice_no: usize) {
         let off = 1 + (slice_no - 1) * 8;
@@ -224,7 +226,7 @@ impl RMAudioStream {
         self.sub_packet = 0;
 
         if self.deint == Deinterleaver::Sipro {
-            sipro_restore(&mut self.buf, factor, fsize);
+            sipro_restore(&mut self.buf, factor, iinfo.frame_size as usize);
         }
 
         let mut frames_iter = self.buf.chunks(fsize);
@@ -433,7 +435,7 @@ impl RMDemuxCommon {
             let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
             let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
             let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
-            let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, sample_rate));
+            let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000));
             if res.is_none() { return Err(MemoryError); }
             let astr = RMAudioStream::new(None);
             str_data.streams.push(RMStreamType::Audio(astr));
@@ -515,7 +517,7 @@ println!(" got ainfo {:?}", ainfo);
                 Some(eslice.to_vec())
             };
         let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
-        let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, srate));
+        let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000));
         if res.is_none() { return Err(MemoryError); }
 
         let astr = RMAudioStream::new(ainfo.ileave_info);
@@ -531,11 +533,11 @@ println!(" got ainfo {:?}", ainfo);
         let bpp         = src.read_u16be()?;
         let pad_w       = src.read_u16be()?;
         let pad_h       = src.read_u16be()?;
-        let fps;
+        let _fps;
         if tag2 == mktag!('V', 'I', 'D', 'O') {
-            fps         = src.read_u32be()?;
+            _fps        = src.read_u32be()?;
         } else {
-            fps = 0x10000;
+            _fps = 0x10000;
         }
         let extradata: Option<Vec<u8>>;
         if src.left() > 0 {
@@ -548,7 +550,7 @@ println!(" got ainfo {:?}", ainfo);
 
         let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
         let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
-        let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
+        let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 1, 1000));
         if res.is_none() { return Err(DemuxerError::MemoryError); }
 
         let vstr = RMVideoStream::new();
@@ -580,7 +582,7 @@ println!(" got ainfo {:?}", ainfo);
                                 if packet_num == 1 {
                                     vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
                                 } else {
-                                    vstr.add_slice(packet_num as usize, slice_buf.as_slice());
+                                    vstr.add_slice(packet_num as usize, slice_buf.as_slice())?;
                                 }
                                 if (packet_num as usize) < num_pkts {
                                     return Err(DemuxerError::TryAgain);
@@ -610,7 +612,7 @@ println!(" got ainfo {:?}", ainfo);
                                 if packet_num == 1 && frame_size == tail_size {
                                     vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
                                 } else {
-                                    vstr.add_slice(packet_num as usize, slice_buf.as_slice());
+                                    vstr.add_slice(packet_num as usize, slice_buf.as_slice())?;
                                 }
 
                                 while src.tell() < pos + (payload_size as u64) {
@@ -762,6 +764,12 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
     }
 }
 
+impl<'a> NAOptionHandler for RealMediaDemuxer<'a> {
+    fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+    fn set_options(&mut self, _options: &[NAOption]) { }
+    fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+}
+
 fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
     let id      = src.read_u32be()?;
 if id == 0 { return Ok((0, 0, 0)); }
@@ -1130,7 +1138,7 @@ impl<'a> RealMediaDemuxer<'a> {
         let _next_idx       = self.src.read_u32be()?;
         validate!(chunk_size == num_entries * 14 + 10);
         if num_entries == 0 { return Ok(()); }
-        
+
         seek_idx.add_stream(str_id);
         let idx = seek_idx.get_stream_index(str_id).unwrap();
         for _ in 0..num_entries {
@@ -1250,6 +1258,12 @@ println!(" got ainfo {:?}", ainfo);
     }
 }
 
+impl<'a> NAOptionHandler for RealAudioDemuxer<'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> RealAudioDemuxer<'a> {
     fn new(io: &'a mut ByteReader<'a>) -> Self {
         RealAudioDemuxer {
@@ -1589,6 +1603,12 @@ println!("R1M kind");
     }
 }
 
+impl<'a> NAOptionHandler for RealIVRDemuxer<'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> RealIVRDemuxer<'a> {
     fn new(io: &'a mut ByteReader<'a>) -> Self {
         RealIVRDemuxer {
@@ -1674,7 +1694,8 @@ mod test {
         let mut br = ByteReader::new(&mut fr);
         let mut dmx = RealMediaDemuxer::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);
@@ -1696,7 +1717,8 @@ mod test {
         let mut br = ByteReader::new(&mut fr);
         let mut dmx = RealAudioDemuxer::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);
@@ -1717,7 +1739,8 @@ mod test {
         let mut br = ByteReader::new(&mut fr);
         let mut dmx = RealIVRDemuxer::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);