rename register_all_codecs to register_all_decoders

[nihav.git] / nihav-realmedia / src / codecs / ralf.rs

diff --git a/nihav-realmedia/src/codecs/ralf.rs b/nihav-realmedia/src/codecs/ralf.rs
index 76bf3df8f50ae7c97f6a3fcbdcc8cafcc7ad8fd0..be256b33dc0e682f0170df7623014041f4da3d15 100644 (file)
--- a/nihav-realmedia/src/codecs/ralf.rs
+++ b/nihav-realmedia/src/codecs/ralf.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;
@@ -142,7 +140,7 @@ impl Filter {
     }
     fn predict(&self, src: &[i32], bits: u8) -> i32 {
         let mut acc: i32 = 0;
-        for (f, s) in src.iter().rev().take(self.length).zip(self.coeffs.into_iter()) {
+        for (f, s) in src.iter().rev().take(self.length).zip(self.coeffs.iter()) {
             acc += *f * *s;
         }
         let bias = 1 << (self.bits - 1);
@@ -246,7 +244,7 @@ struct Block {
 
 const RALF_MAX_PACKET_SIZE: usize = 8192;
 struct RALFDecoder {
-    info:           Rc<NACodecInfo>,
+    info:           NACodecInfoRef,
     chmap:          NAChannelMap,
     channels:       u8,
 
@@ -279,7 +277,7 @@ impl RALFDecoder {
         }
     }
     fn decode_block(&mut self, off: usize, size: usize, abuf: &mut NABufferType) -> DecoderResult<()> {
-        let mut br = BitReader::new(&self.pkt_buf[off..][..size], size, BitReaderMode::BE);
+        let mut br = BitReader::new(&self.pkt_buf[off..][..size], BitReaderMode::BE);
 
         let length = read_block_length(&mut br).unwrap();
         validate!(length + self.sample_offset <= self.max_frame_size);
@@ -357,7 +355,7 @@ fn read_block_length(br: &mut BitReader) -> DecoderResult<usize> {
 }
 
 impl NADecoder for RALFDecoder {
-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
 
@@ -391,7 +389,7 @@ impl NADecoder for RALFDecoder {
             Err(DecoderError::InvalidData)
         }
     }
-    fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
+    fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
         let info = pkt.get_stream().get_info();
         validate!(info.get_properties().is_audio());
         let pktbuf = pkt.get_buffer();
@@ -404,7 +402,7 @@ impl NADecoder for RALFDecoder {
             let table_bytes = table_bits >> 3;
             validate!((table_bytes + 3 <= pktbuf.len()) && (pktbuf.len() <= RALF_MAX_PACKET_SIZE));
             let cmp_len = table_bytes + 2;
-            validate!(&pktbuf[..cmp_len] == &self.pkt_buf[..cmp_len]);
+            validate!(pktbuf[..cmp_len] == self.pkt_buf[..cmp_len]);
             {
                 let copy_size = pktbuf.len() - cmp_len;
                 let dst = &mut self.pkt_buf[RALF_MAX_PACKET_SIZE..][..copy_size];
@@ -419,7 +417,7 @@ impl NADecoder for RALFDecoder {
 
                 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), NABufferType::None);
                 frm.set_frame_type(FrameType::Skip);
-                return Ok(Rc::new(RefCell::new(frm)));
+                return Ok(frm.into_ref());
             }
             src_len = pktbuf.len();
         }
@@ -430,8 +428,8 @@ impl NADecoder for RALFDecoder {
         validate!(src_len > table_bytes + 3);
         self.blocks.truncate(0);
         {
-            let mut br = BitReader::new(&self.pkt_buf[2..], table_bytes, BitReaderMode::BE);
-            while br.tell() < table_bits.into() {
+            let mut br = BitReader::new(&self.pkt_buf[2..][..table_bytes], BitReaderMode::BE);
+            while br.tell() < table_bits {
                 let size                                = br.read(13 + self.channels).unwrap() as usize;
                 let pts;
                 if br.read_bool().unwrap() {
@@ -467,11 +465,19 @@ impl NADecoder for RALFDecoder {
 
         let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
         frm.set_keyframe(true);
-        Ok(Rc::new(RefCell::new(frm)))
+        Ok(frm.into_ref())
     }
+    fn flush(&mut self) {
+    }
+}
+
+impl NAOptionHandler for RALFDecoder {
+    fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+    fn set_options(&mut self, _options: &[NAOption]) { }
+    fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 }
 
-pub fn get_decoder() -> Box<NADecoder> {
+pub fn get_decoder() -> Box<dyn NADecoder + Send> {
     Box::new(RALFDecoder::new())
 }
 
@@ -479,19 +485,18 @@ pub fn get_decoder() -> Box<NADecoder> {
 mod test {
     use nihav_core::codecs::RegisteredDecoders;
     use nihav_core::demuxers::RegisteredDemuxers;
-    use nihav_core::test::dec_video::*;
-    use crate::codecs::realmedia_register_all_codecs;
-    use crate::demuxers::realmedia_register_all_demuxers;
+    use nihav_codec_support::test::dec_video::*;
+    use crate::realmedia_register_all_decoders;
+    use crate::realmedia_register_all_demuxers;
     #[test]
     fn test_ralf() {
         let mut dmx_reg = RegisteredDemuxers::new();
         realmedia_register_all_demuxers(&mut dmx_reg);
         let mut dec_reg = RegisteredDecoders::new();
-        realmedia_register_all_codecs(&mut dec_reg);
+        realmedia_register_all_decoders(&mut dec_reg);
 
-        let file = "assets/RV/rv40_ralf.rmvb";
-        test_decode_audio("realmedia", file, Some(2000), "ralf", &dmx_reg, &dec_reg);
-//panic!("end");
+        test_decoding("realmedia", "ralf", "assets/RV/rv40_ralf.rmvb", None, &dmx_reg, &dec_reg,
+                      ExpectedTestResult::MD5([0x6cf18361, 0x9548b5ce, 0x5dfc0b5c, 0x2bd6f392]));
     }
 }