switch NACodecInfo to Arc

diff --git a/nihav-commonfmt/src/codecs/aac.rs b/nihav-commonfmt/src/codecs/aac.rs
index 8232e07f1f7caa689b8da38f40de3e714b4bdbb5..412bc9c8b4c0883403ba31ba897dfd053334b317 100644 (file)
--- a/nihav-commonfmt/src/codecs/aac.rs
+++ b/nihav-commonfmt/src/codecs/aac.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -1107,7 +1105,7 @@ impl DSP {
 }
 
 struct AACDecoder {
 }
 
 struct AACDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     chmap:      NAChannelMap,
     m4ainfo:    M4AInfo,
     pairs:      Vec<ChannelPair>,
     chmap:      NAChannelMap,
     m4ainfo:    M4AInfo,
     pairs:      Vec<ChannelPair>,


@@ -1205,7 +1203,7 @@ impl AACDecoder {
 }
 
 impl NADecoder for AACDecoder {
 }
 
 impl NADecoder for AACDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
             validate!(edata.len() >= 2);
         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
             validate!(edata.len() >= 2);

diff --git a/nihav-commonfmt/src/codecs/atrac3.rs b/nihav-commonfmt/src/codecs/atrac3.rs
index 7b543bf2774a34b4ff1709e2cdc7853e4c4f6244..42fbe8a708fe053d15d0bf20bcc27589c2bcb4be 100644 (file)
--- a/nihav-commonfmt/src/codecs/atrac3.rs
+++ b/nihav-commonfmt/src/codecs/atrac3.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -387,7 +385,7 @@ impl DSP {
 }
 
 struct Atrac3Decoder {
 }
 
 struct Atrac3Decoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     channels:   usize,
     chmap:      NAChannelMap,
     samples:    usize,
     channels:   usize,
     chmap:      NAChannelMap,
     samples:    usize,


@@ -555,7 +553,7 @@ fn interp(a: f32, b: f32, pos: usize) -> f32 {
 }
 
 impl NADecoder for Atrac3Decoder {
 }
 
 impl NADecoder for Atrac3Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.info = info.clone();
             let edata = info.get_extradata().unwrap();
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.info = info.clone();
             let edata = info.get_extradata().unwrap();

diff --git a/nihav-commonfmt/src/codecs/clearvideo.rs b/nihav-commonfmt/src/codecs/clearvideo.rs
index 3c3ae9ad489ce46046e07dc5f2baf043d7937cb0..d485bdb6b00cb572f7bb91cdce916c7284ff9ebc 100644 (file)
--- a/nihav-commonfmt/src/codecs/clearvideo.rs
+++ b/nihav-commonfmt/src/codecs/clearvideo.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::io::byteio::{ByteReader,MemoryReader};
 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::io::byteio::{ByteReader,MemoryReader};
 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;


@@ -430,7 +428,7 @@ fn extend_edges(buf: &mut NAVideoBuffer<u8>, tile_size: usize) {
 
 #[allow(dead_code)]
 struct ClearVideoDecoder {
 
 #[allow(dead_code)]
 struct ClearVideoDecoder {

-    info:    Rc<NACodecInfo>,
+    info:    NACodecInfoRef,

     dc_cb:   Codebook<i8>,
     ac_cb:   Codebook<u16>,
     frmmgr:  HAMShuffler,
     dc_cb:   Codebook<i8>,
     ac_cb:   Codebook<u16>,
     frmmgr:  HAMShuffler,


@@ -530,7 +528,7 @@ fn decode_tile_info(br: &mut BitReader, lc: &[LevelCodes], level: usize) -> Deco
 
 impl ClearVideoDecoder {
     fn new(is_rm: bool) -> Self {
 
 impl ClearVideoDecoder {
     fn new(is_rm: bool) -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);
+        let dummy_info = NACodecInfo::new_dummy();

         let mut coderead = CLVDCCodeReader{};
         let dc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
         let mut coderead = CLVACCodeReader{};
         let mut coderead = CLVDCCodeReader{};
         let dc_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
         let mut coderead = CLVACCodeReader{};


@@ -683,7 +681,7 @@ impl ClearVideoDecoder {
 }
 
 impl NADecoder for ClearVideoDecoder {
 }
 
 impl NADecoder for ClearVideoDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if info.get_extradata().is_none() { return Err(DecoderError::InvalidData); }
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
         if info.get_extradata().is_none() { return Err(DecoderError::InvalidData); }
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();


@@ -691,7 +689,7 @@ impl NADecoder for ClearVideoDecoder {
             let f = vinfo.is_flipped();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));
             let f = vinfo.is_flipped();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             self.frmmgr.clear();
             let edata = info.get_extradata().unwrap();
 //todo detect simply by extradata contents?
             self.frmmgr.clear();
             let edata = info.get_extradata().unwrap();
 //todo detect simply by extradata contents?

diff --git a/nihav-commonfmt/src/codecs/pcm.rs b/nihav-commonfmt/src/codecs/pcm.rs
index edc8124e473c811b388ae74ecc9344da598523c4..132d4c3a60755e91548643f05d9d8287e10d0b12 100644 (file)
--- a/nihav-commonfmt/src/codecs/pcm.rs
+++ b/nihav-commonfmt/src/codecs/pcm.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::formats::*;
 use nihav_core::codecs::*;
 
 use nihav_core::formats::*;
 use nihav_core::codecs::*;
 


@@ -35,7 +33,7 @@ fn get_duration(ainfo: &NAAudioInfo, duration: Option<u64>, data_size: usize) ->
 }
 
 impl NADecoder for PCMDecoder {
 }
 
 impl NADecoder for PCMDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap = get_default_chmap(ainfo.get_channels());
             if self.chmap.num_channels() == 0 { return Err(DecoderError::InvalidData); }
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap = get_default_chmap(ainfo.get_channels());
             if self.chmap.num_channels() == 0 { return Err(DecoderError::InvalidData); }

diff --git a/nihav-commonfmt/src/codecs/sipro.rs b/nihav-commonfmt/src/codecs/sipro.rs
index 1b8d701e42125840034e1a0ac64277ad93b90c60..05e6816588df5047d708a0a20ad06e0c2067caf0 100644 (file)
--- a/nihav-commonfmt/src/codecs/sipro.rs
+++ b/nihav-commonfmt/src/codecs/sipro.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -28,7 +26,7 @@ const EXCITATION_OFFSET: usize = 281 + 10 + 1;
 struct SiproDecoder {
     chmap:              NAChannelMap,
     ainfo:              NAAudioInfo,
 struct SiproDecoder {
     chmap:              NAChannelMap,
     ainfo:              NAAudioInfo,

-    info:               Rc<NACodecInfo>,
+    info:               NACodecInfoRef,

     mode:               &'static SiproModeInfo,
     mode_type:          SiproMode,
 
     mode:               &'static SiproModeInfo,
     mode_type:          SiproMode,
 


@@ -640,7 +638,7 @@ fn synth_filter(dst: &mut [f32], doff: usize, filt: &[f32], src: &[f32], len: us
 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
 
 impl NADecoder for SiproDecoder {
 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
 
 impl NADecoder for SiproDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let mut found = false;
             for i in 0..SIPRO_MODES.len() {
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let mut found = false;
             for i in 0..SIPRO_MODES.len() {

diff --git a/nihav-commonfmt/src/codecs/ts102366.rs b/nihav-commonfmt/src/codecs/ts102366.rs
index 5d1d66c2e6cccbf702150fe13d6e21077465d7ed..f17b43106229dc75d552ac405b6248c0fc688c8d 100644 (file)
--- a/nihav-commonfmt/src/codecs/ts102366.rs
+++ b/nihav-commonfmt/src/codecs/ts102366.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -116,7 +114,7 @@ fn do_imdct_core(fft: &mut FFT, xsc: &[FFTComplex; BLOCK_LEN/2], size: usize, il
 }
 
 struct AudioDecoder {
 }
 
 struct AudioDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     ablk:       AudioBlock,
     imdct512:   IMDCTContext,
     imdct256:   IMDCTContext,
     ablk:       AudioBlock,
     imdct512:   IMDCTContext,
     imdct256:   IMDCTContext,


@@ -1159,7 +1157,7 @@ impl AudioBlock {
 }
 
 impl NADecoder for AudioDecoder {
 }
 
 impl NADecoder for AudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
             self.info = info.clone();
             Ok(())
         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
             self.info = info.clone();
             Ok(())

diff --git a/nihav-core/src/codecs/mod.rs b/nihav-core/src/codecs/mod.rs
index bf4fbd411edf9032afdd7f511dba364704f5b94f..692269ea7572dd1c03a535ff3a441982a486ab60 100644 (file)
--- a/nihav-core/src/codecs/mod.rs
+++ b/nihav-core/src/codecs/mod.rs
@@ -2,7 +2,6 @@ use std::fmt;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 
 pub use crate::frame::*;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 
 pub use crate::frame::*;

-pub use std::rc::Rc;

 use std::mem;
 use crate::io::byteio::ByteIOError;
 use crate::io::bitreader::BitReaderError;
 use std::mem;
 use crate::io::byteio::ByteIOError;
 use crate::io::bitreader::BitReaderError;


@@ -232,7 +231,7 @@ impl fmt::Display for MV {
 
 
 pub trait NADecoder {
 
 
 pub trait NADecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()>;
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()>;

     fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
 }
 
     fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef>;
 }
 

diff --git a/nihav-core/src/frame.rs b/nihav-core/src/frame.rs
index 45e05ca76f455f06fc223c725390f50a151b4234..bc3216bd2b3a37a9247f4414caf951be723bf64e 100644 (file)
--- a/nihav-core/src/frame.rs
+++ b/nihav-core/src/frame.rs
@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use std::fmt;
 pub use std::rc::Rc;
 pub use std::cell::*;
 use std::fmt;
 pub use std::rc::Rc;
 pub use std::cell::*;

+use std::sync::Arc;

 pub use crate::formats::*;
 pub use crate::refs::*;
 
 pub use crate::formats::*;
 pub use crate::refs::*;
 


@@ -531,22 +532,25 @@ impl NABufferPool {
 pub struct NACodecInfo {
     name:       &'static str,
     properties: NACodecTypeInfo,
 pub struct NACodecInfo {
     name:       &'static str,
     properties: NACodecTypeInfo,

-    extradata:  Option<Rc<Vec<u8>>>,
+    extradata:  Option<Arc<Vec<u8>>>,

 }
 
 }
 

+pub type NACodecInfoRef = Arc<NACodecInfo>;
+

 impl NACodecInfo {
     pub fn new(name: &'static str, p: NACodecTypeInfo, edata: Option<Vec<u8>>) -> Self {
         let extradata = match edata {
             None => None,
 impl NACodecInfo {
     pub fn new(name: &'static str, p: NACodecTypeInfo, edata: Option<Vec<u8>>) -> Self {
         let extradata = match edata {
             None => None,

-            Some(vec) => Some(Rc::new(vec)),
+            Some(vec) => Some(Arc::new(vec)),

         };
         NACodecInfo { name: name, properties: p, extradata: extradata }
     }
         };
         NACodecInfo { name: name, properties: p, extradata: extradata }
     }

-    pub fn new_ref(name: &'static str, p: NACodecTypeInfo, edata: Option<Rc<Vec<u8>>>) -> Self {
+    pub fn new_ref(name: &'static str, p: NACodecTypeInfo, edata: Option<Arc<Vec<u8>>>) -> Self {

         NACodecInfo { name: name, properties: p, extradata: edata }
     }
         NACodecInfo { name: name, properties: p, extradata: edata }
     }

+    pub fn into_ref(self) -> NACodecInfoRef { Arc::new(self) }

     pub fn get_properties(&self) -> NACodecTypeInfo { self.properties }
     pub fn get_properties(&self) -> NACodecTypeInfo { self.properties }

-    pub fn get_extradata(&self) -> Option<Rc<Vec<u8>>> {
+    pub fn get_extradata(&self) -> Option<Arc<Vec<u8>>> {

         if let Some(ref vec) = self.extradata { return Some(vec.clone()); }
         None
     }
         if let Some(ref vec) = self.extradata { return Some(vec.clone()); }
         None
     }


@@ -559,11 +563,11 @@ impl NACodecInfo {
         if let NACodecTypeInfo::Audio(_) = self.properties { return true; }
         false
     }
         if let NACodecTypeInfo::Audio(_) = self.properties { return true; }
         false
     }

-    pub fn new_dummy() -> Rc<Self> {
-        Rc::new(DUMMY_CODEC_INFO)
+    pub fn new_dummy() -> Arc<Self> {
+        Arc::new(DUMMY_CODEC_INFO)

     }
     }

-    pub fn replace_info(&self, p: NACodecTypeInfo) -> Rc<Self> {
-        Rc::new(NACodecInfo { name: self.name, properties: p, extradata: self.extradata.clone() })
+    pub fn replace_info(&self, p: NACodecTypeInfo) -> Arc<Self> {
+        Arc::new(NACodecInfo { name: self.name, properties: p, extradata: self.extradata.clone() })

     }
 }
 
     }
 }
 


@@ -592,7 +596,7 @@ pub enum NAValue {
     Int(i32),
     Long(i64),
     String(String),
     Int(i32),
     Long(i64),
     String(String),

-    Data(Rc<Vec<u8>>),
+    Data(Arc<Vec<u8>>),

 }
 
 #[derive(Debug,Clone,Copy,PartialEq)]
 }
 
 #[derive(Debug,Clone,Copy,PartialEq)]


@@ -643,7 +647,7 @@ impl NATimeInfo {
 pub struct NAFrame {
     ts:             NATimeInfo,
     buffer:         NABufferType,
 pub struct NAFrame {
     ts:             NATimeInfo,
     buffer:         NABufferType,

-    info:           Rc<NACodecInfo>,
+    info:           NACodecInfoRef,

     ftype:          FrameType,
     key:            bool,
     options:        HashMap<String, NAValue>,
     ftype:          FrameType,
     key:            bool,
     options:        HashMap<String, NAValue>,


@@ -664,12 +668,12 @@ impl NAFrame {
     pub fn new(ts:             NATimeInfo,
                ftype:          FrameType,
                keyframe:       bool,
     pub fn new(ts:             NATimeInfo,
                ftype:          FrameType,
                keyframe:       bool,

-               info:           Rc<NACodecInfo>,
+               info:           NACodecInfoRef,

                options:        HashMap<String, NAValue>,
                buffer:         NABufferType) -> Self {
         NAFrame { ts: ts, buffer: buffer, info: info, ftype: ftype, key: keyframe, options: options }
     }
                options:        HashMap<String, NAValue>,
                buffer:         NABufferType) -> Self {
         NAFrame { ts: ts, buffer: buffer, info: info, ftype: ftype, key: keyframe, options: options }
     }

-    pub fn get_info(&self) -> Rc<NACodecInfo> { self.info.clone() }
+    pub fn get_info(&self) -> NACodecInfoRef { self.info.clone() }

     pub fn get_frame_type(&self) -> FrameType { self.ftype }
     pub fn is_keyframe(&self) -> bool { self.key }
     pub fn set_frame_type(&mut self, ftype: FrameType) { self.ftype = ftype; }
     pub fn get_frame_type(&self) -> FrameType { self.ftype }
     pub fn is_keyframe(&self) -> bool { self.key }
     pub fn set_frame_type(&mut self, ftype: FrameType) { self.ftype = ftype; }


@@ -730,7 +734,7 @@ pub struct NAStream {
     media_type:     StreamType,
     id:             u32,
     num:            usize,
     media_type:     StreamType,
     id:             u32,
     num:            usize,

-    info:           Rc<NACodecInfo>,
+    info:           NACodecInfoRef,

     tb_num:         u32,
     tb_den:         u32,
 }
     tb_num:         u32,
     tb_den:         u32,
 }


@@ -753,12 +757,12 @@ pub fn reduce_timebase(tb_num: u32, tb_den: u32) -> (u32, u32) {
 impl NAStream {
     pub fn new(mt: StreamType, id: u32, info: NACodecInfo, tb_num: u32, tb_den: u32) -> Self {
         let (n, d) = reduce_timebase(tb_num, tb_den);
 impl NAStream {
     pub fn new(mt: StreamType, id: u32, info: NACodecInfo, tb_num: u32, tb_den: u32) -> Self {
         let (n, d) = reduce_timebase(tb_num, tb_den);

-        NAStream { media_type: mt, id: id, num: 0, info: Rc::new(info), tb_num: n, tb_den: d }
+        NAStream { media_type: mt, id: id, num: 0, info: info.into_ref(), tb_num: n, tb_den: d }

     }
     pub fn get_id(&self) -> u32 { self.id }
     pub fn get_num(&self) -> usize { self.num }
     pub fn set_num(&mut self, num: usize) { self.num = num; }
     }
     pub fn get_id(&self) -> u32 { self.id }
     pub fn get_num(&self) -> usize { self.num }
     pub fn set_num(&mut self, num: usize) { self.num = num; }

-    pub fn get_info(&self) -> Rc<NACodecInfo> { self.info.clone() }
+    pub fn get_info(&self) -> NACodecInfoRef { self.info.clone() }

     pub fn get_timebase(&self) -> (u32, u32) { (self.tb_num, self.tb_den) }
     pub fn set_timebase(&mut self, tb_num: u32, tb_den: u32) {
         let (n, d) = reduce_timebase(tb_num, tb_den);
     pub fn get_timebase(&self) -> (u32, u32) { (self.tb_num, self.tb_den) }
     pub fn set_timebase(&mut self, tb_num: u32, tb_den: u32) {
         let (n, d) = reduce_timebase(tb_num, tb_den);


@@ -814,12 +818,12 @@ impl fmt::Display for NAPacket {
 }
 
 pub trait FrameFromPacket {
 }
 
 pub trait FrameFromPacket {

-    fn new_from_pkt(pkt: &NAPacket, info: Rc<NACodecInfo>, buf: NABufferType) -> NAFrame;
+    fn new_from_pkt(pkt: &NAPacket, info: NACodecInfoRef, buf: NABufferType) -> NAFrame;

     fn fill_timestamps(&mut self, pkt: &NAPacket);
 }
 
 impl FrameFromPacket for NAFrame {
     fn fill_timestamps(&mut self, pkt: &NAPacket);
 }
 
 impl FrameFromPacket for NAFrame {

-    fn new_from_pkt(pkt: &NAPacket, info: Rc<NACodecInfo>, buf: NABufferType) -> NAFrame {
+    fn new_from_pkt(pkt: &NAPacket, info: NACodecInfoRef, buf: NABufferType) -> NAFrame {

         NAFrame::new(pkt.ts, FrameType::Other, pkt.keyframe, info, HashMap::new(), buf)
     }
     fn fill_timestamps(&mut self, pkt: &NAPacket) {
         NAFrame::new(pkt.ts, FrameType::Other, pkt.keyframe, info, HashMap::new(), buf)
     }
     fn fill_timestamps(&mut self, pkt: &NAPacket) {

diff --git a/nihav-duck/src/codecs/dkadpcm.rs b/nihav-duck/src/codecs/dkadpcm.rs
index 041095733181831492ed6f663deb5e04f6c1cb3a..0104b306d9e8f622743537f4e3f104f5f5469fbc 100644 (file)
--- a/nihav-duck/src/codecs/dkadpcm.rs
+++ b/nihav-duck/src/codecs/dkadpcm.rs
@@ -51,7 +51,7 @@ impl DuckADPCMDecoder {
 }
 
 impl NADecoder for DuckADPCMDecoder {
 }
 
 impl NADecoder for DuckADPCMDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             validate!(ainfo.get_block_len() > 16);
             self.block_len = ainfo.get_block_len();
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             validate!(ainfo.get_block_len() > 16);
             self.block_len = ainfo.get_block_len();

diff --git a/nihav-duck/src/codecs/truemotion1.rs b/nihav-duck/src/codecs/truemotion1.rs
index a156705a24bceae75121cb61da9b25506470c904..2c8e5d273933c901763836beb5d8dcd894f2afda 100644 (file)
--- a/nihav-duck/src/codecs/truemotion1.rs
+++ b/nihav-duck/src/codecs/truemotion1.rs
@@ -168,7 +168,7 @@ impl Default for FrameBuf {
 
 #[derive(Default)]
 struct TM1Decoder {
 
 #[derive(Default)]
 struct TM1Decoder {

-    info:           Rc<NACodecInfo>,
+    info:           NACodecInfoRef,

     last_delta_set: usize,
     last_table_idx: usize,
     delta_tables:   DeltaTables,
     last_delta_set: usize,
     last_table_idx: usize,
     delta_tables:   DeltaTables,


@@ -515,10 +515,10 @@ impl TM1Decoder {
 }
 
 impl NADecoder for TM1Decoder {
 }
 
 impl NADecoder for TM1Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-duck/src/codecs/truemotion2.rs b/nihav-duck/src/codecs/truemotion2.rs
index 54f0d30848245dd1d7d24d2344e2c8f7f55e2c6a..e8225450a52b2e17398c7652f89905d380ccbd23 100644 (file)
--- a/nihav-duck/src/codecs/truemotion2.rs
+++ b/nihav-duck/src/codecs/truemotion2.rs
@@ -331,7 +331,7 @@ impl TM2Frame {
 
 #[derive(Default)]
 struct TM2Decoder {
 
 #[derive(Default)]
 struct TM2Decoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     streams:    [TM2Stream; TM2StreamType::Num as usize],
     width:      usize,
     height:     usize,
     streams:    [TM2Stream; TM2StreamType::Num as usize],
     width:      usize,
     height:     usize,


@@ -546,14 +546,14 @@ impl TM2Decoder {
 }
 
 impl NADecoder for TM2Decoder {
 }
 
 impl NADecoder for TM2Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));
             self.width  = vinfo.get_width();
             self.height = vinfo.get_height();
             self.cur_frame  = TM2Frame::alloc(self.width, self.height);
             self.prev_frame = TM2Frame::alloc(self.width, self.height);
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));
             self.width  = vinfo.get_width();
             self.height = vinfo.get_height();
             self.cur_frame  = TM2Frame::alloc(self.width, self.height);
             self.prev_frame = TM2Frame::alloc(self.width, self.height);

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-duck/src/codecs/truemotion2x.rs b/nihav-duck/src/codecs/truemotion2x.rs
index 6eb35594cd184cd2e5f81f0ab060a6d43c4e995d..fce5fb359b3a9bd68f0979ed4375cdb990958b87 100644 (file)
--- a/nihav-duck/src/codecs/truemotion2x.rs
+++ b/nihav-duck/src/codecs/truemotion2x.rs
@@ -161,7 +161,7 @@ impl Frame {
 
 #[derive(Default)]
 struct TM2XDecoder {
 
 #[derive(Default)]
 struct TM2XDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     width:      usize,
     height:     usize,
     dec_buf:    Vec<u8>,
     width:      usize,
     height:     usize,
     dec_buf:    Vec<u8>,


@@ -556,7 +556,7 @@ impl TM2XDecoder {
 }
 
 impl NADecoder for TM2XDecoder {
 }
 
 impl NADecoder for TM2XDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
                                            Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
                                            Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),


@@ -568,7 +568,7 @@ impl NADecoder for TM2XDecoder {
             self.height = vinfo.get_height();
             self.cur_frame.resize(self.width, self.height);
             self.ref_frame.resize(self.width, self.height);
             self.height = vinfo.get_height();
             self.cur_frame.resize(self.width, self.height);
             self.ref_frame.resize(self.width, self.height);

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-duck/src/codecs/truemotionrt.rs b/nihav-duck/src/codecs/truemotionrt.rs
index df17047288aa63ed483376820d0252009756ad51..12548ef302719698dff09b1ab6d3cf80f6d19746 100644 (file)
--- a/nihav-duck/src/codecs/truemotionrt.rs
+++ b/nihav-duck/src/codecs/truemotionrt.rs
@@ -3,7 +3,7 @@ use nihav_core::io::bitreader::*;
 
 #[derive(Default)]
 struct TMRTDecoder {
 
 #[derive(Default)]
 struct TMRTDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

 }
 
 const TMRT_DELTA_TAB: [&[i16]; 3] = [
 }
 
 const TMRT_DELTA_TAB: [&[i16]; 3] = [


@@ -35,10 +35,10 @@ impl TMRTDecoder {
 }
 
 impl NADecoder for TMRTDecoder {
 }
 
 impl NADecoder for TMRTDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, YUV410_FORMAT));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-game/src/codecs/bmv.rs b/nihav-game/src/codecs/bmv.rs
index 46e5f65226754aaf656ebbae459a474ea87ecadc..79b8745b17cdd529017e9e2e74b240eb5bc39355 100644 (file)
--- a/nihav-game/src/codecs/bmv.rs
+++ b/nihav-game/src/codecs/bmv.rs
@@ -101,16 +101,15 @@ impl<'a> BMVWriter<'a> {
 }
 
 struct BMVVideoDecoder {
 }
 
 struct BMVVideoDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     pal:        [u8; 768],
     frame:      [u8; FRAME_W * FRAME_H],
 }
 
 impl BMVVideoDecoder {
     fn new() -> Self {
     pal:        [u8; 768],
     frame:      [u8; FRAME_W * FRAME_H],
 }
 
 impl BMVVideoDecoder {
     fn new() -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);

         Self {
         Self {

-            info: dummy_info, pal: [0; 768], frame: [0; FRAME_W * FRAME_H],
+            info: NACodecInfoRef::default(), pal: [0; 768], frame: [0; FRAME_W * FRAME_H],

         }
     }
     fn decode_frame(&mut self, src: &[u8], bufinfo: &mut NABufferType, line: i16) -> DecoderResult<()> {
         }
     }
     fn decode_frame(&mut self, src: &[u8], bufinfo: &mut NABufferType, line: i16) -> DecoderResult<()> {


@@ -170,7 +169,7 @@ impl BMVVideoDecoder {
 }
 
 impl NADecoder for BMVVideoDecoder {
 }
 
 impl NADecoder for BMVVideoDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
             let fmt = NAPixelFormaton::new(ColorModel::RGB(RGBSubmodel::RGB),
                                            Some(NAPixelChromaton::new(0, 0, true, 8, 0, 0, 3)),
         if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
             let fmt = NAPixelFormaton::new(ColorModel::RGB(RGBSubmodel::RGB),
                                            Some(NAPixelChromaton::new(0, 0, true, 8, 0, 0, 3)),


@@ -179,7 +178,7 @@ impl NADecoder for BMVVideoDecoder {
                                            None, None,
                                            FORMATON_FLAG_PALETTE, 3);
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(FRAME_W, FRAME_H, false, fmt));
                                            None, None,
                                            FORMATON_FLAG_PALETTE, 3);
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(FRAME_W, FRAME_H, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             Ok(())
         } else {
 
             Ok(())
         } else {


@@ -258,7 +257,7 @@ fn scale_sample(samp: u8, scale: i32) -> i16 {
 }
 
 impl NADecoder for BMVAudioDecoder {
 }
 
 impl NADecoder for BMVAudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
             self.chmap = NAChannelMap::from_str("L,R").unwrap();
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
             self.chmap = NAChannelMap::from_str("L,R").unwrap();

diff --git a/nihav-game/src/codecs/bmv3.rs b/nihav-game/src/codecs/bmv3.rs
index 099f070bc5be930c2ac598874ab9d9cc1cdd79ec..687ca237c09a8420a8258dffdf9e17e442ed7b1e 100644 (file)
--- a/nihav-game/src/codecs/bmv3.rs
+++ b/nihav-game/src/codecs/bmv3.rs
@@ -69,7 +69,7 @@ impl NibbleReader {
 }
 
 struct BMV3VideoDecoder {
 }
 
 struct BMV3VideoDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     stride:     usize,
     height:     usize,
     frame:      Vec<u16>,
     stride:     usize,
     height:     usize,
     frame:      Vec<u16>,


@@ -85,7 +85,6 @@ struct BMV3VideoDecoder {
 
 impl BMV3VideoDecoder {
     fn new() -> Self {
 
 impl BMV3VideoDecoder {
     fn new() -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);

         let mut frame1 = Vec::with_capacity(BMV_MAX_SIZE);
         frame1.resize(BMV_MAX_SIZE, 0);
         let mut frame2 = Vec::with_capacity(BMV_MAX_SIZE);
         let mut frame1 = Vec::with_capacity(BMV_MAX_SIZE);
         frame1.resize(BMV_MAX_SIZE, 0);
         let mut frame2 = Vec::with_capacity(BMV_MAX_SIZE);


@@ -103,7 +102,7 @@ impl BMV3VideoDecoder {
         }
 
         Self {
         }
 
         Self {

-            info:       dummy_info,
+            info:       NACodecInfoRef::default(),

             stride:     0,
             height:     0,
             frame:      frame1,
             stride:     0,
             height:     0,
             frame:      frame1,


@@ -442,10 +441,10 @@ impl BMV3VideoDecoder {
 }
 
 impl NADecoder for BMV3VideoDecoder {
 }
 
 impl NADecoder for BMV3VideoDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB565_FORMAT));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, RGB565_FORMAT));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             self.stride = vinfo.get_width();
             self.height = vinfo.get_height();
 
             self.stride = vinfo.get_width();
             self.height = vinfo.get_height();


@@ -553,7 +552,7 @@ fn decode_block(mode: u8, src: &[u8], dst: &mut [i16], mut pred: i16) -> i16 {
 }
 
 impl NADecoder for BMV3AudioDecoder {
 }
 
 impl NADecoder for BMV3AudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
             self.chmap = NAChannelMap::from_str("L,R").unwrap();
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, 32);
             self.chmap = NAChannelMap::from_str("L,R").unwrap();

diff --git a/nihav-game/src/codecs/gremlinvideo.rs b/nihav-game/src/codecs/gremlinvideo.rs
index 9dd67cae85de21694bb497dbf784de52765cbdd0..cf7f7b13c1ff23425d8fb47063e5e7c5c519d7af 100644 (file)
--- a/nihav-game/src/codecs/gremlinvideo.rs
+++ b/nihav-game/src/codecs/gremlinvideo.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::frame::*;
 use nihav_core::formats;
 use nihav_core::formats::{NAChannelType, NAChannelMap};
 use nihav_core::frame::*;
 use nihav_core::formats;
 use nihav_core::formats::{NAChannelType, NAChannelMap};


@@ -7,7 +5,7 @@ use nihav_core::codecs::*;
 use nihav_core::io::byteio::*;
 
 struct GremlinVideoDecoder {
 use nihav_core::io::byteio::*;
 
 struct GremlinVideoDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     pal:        [u8; 768],
     frame:      Vec<u8>,
     scale_v:    bool,
     pal:        [u8; 768],
     frame:      Vec<u8>,
     scale_v:    bool,


@@ -61,9 +59,8 @@ impl Bits32 {
 
 impl GremlinVideoDecoder {
     fn new() -> Self {
 
 impl GremlinVideoDecoder {
     fn new() -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);

         GremlinVideoDecoder {
         GremlinVideoDecoder {

-            info: dummy_info, pal: [0; 768], frame: Vec::new(),
+            info: NACodecInfoRef::default(), pal: [0; 768], frame: Vec::new(),

             scale_v: false, scale_h: false
         }
     }
             scale_v: false, scale_h: false
         }
     }


@@ -374,14 +371,14 @@ impl GremlinVideoDecoder {
 }
 
 impl NADecoder for GremlinVideoDecoder {
 }
 
 impl NADecoder for GremlinVideoDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             if !vinfo.get_format().is_paletted() { return Err(DecoderError::NotImplemented); }
             let fmt = formats::PAL8_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             if !vinfo.get_format().is_paletted() { return Err(DecoderError::NotImplemented); }
             let fmt = formats::PAL8_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             self.frame.resize(PREAMBLE_SIZE + w * h, 0);
             for i in 0..2 {
 
             self.frame.resize(PREAMBLE_SIZE + w * h, 0);
             for i in 0..2 {


@@ -513,7 +510,7 @@ fn get_default_chmap(nch: u8) -> NAChannelMap {
 }
 
 impl NADecoder for GremlinAudioDecoder {
 }
 
 impl NADecoder for GremlinAudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, ainfo.get_block_len());
             self.chmap = get_default_chmap(ainfo.get_channels());
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), ainfo.get_channels(), formats::SND_S16P_FORMAT, ainfo.get_block_len());
             self.chmap = get_default_chmap(ainfo.get_channels());

diff --git a/nihav-game/src/codecs/vmd.rs b/nihav-game/src/codecs/vmd.rs
index bbe521842d30b54aa5e27f37fcd5ac5d19cebe08..dc831c4fb8200834e1eb8e2af4fded93f25c6ebe 100644 (file)
--- a/nihav-game/src/codecs/vmd.rs
+++ b/nihav-game/src/codecs/vmd.rs
@@ -147,7 +147,7 @@ fn decode_frame_data(br: &mut ByteReader, dst: &mut [u8], mut dpos: usize, strid
 }
 
 struct VMDVideoDecoder {
 }
 
 struct VMDVideoDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     pal:        [u8; 768],
     buf:        Vec<u8>,
     width:      usize,
     pal:        [u8; 768],
     buf:        Vec<u8>,
     width:      usize,


@@ -158,7 +158,7 @@ struct VMDVideoDecoder {
 impl VMDVideoDecoder {
     fn new() -> Self {
         Self {
 impl VMDVideoDecoder {
     fn new() -> Self {
         Self {

-            info:       Rc::new(NACodecInfo::default()),
+            info:       NACodecInfoRef::default(),

             pal:        [0; 768],
             buf:        Vec::new(),
             width:      0,
             pal:        [0; 768],
             buf:        Vec::new(),
             width:      0,


@@ -215,12 +215,12 @@ impl VMDVideoDecoder {
 }
 
 impl NADecoder for VMDVideoDecoder {
 }
 
 impl NADecoder for VMDVideoDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             self.width  = vinfo.get_width();
             self.height = vinfo.get_height();
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, PAL8_FORMAT));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             self.width  = vinfo.get_width();
             self.height = vinfo.get_height();
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(self.width, self.height, false, PAL8_FORMAT));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             validate!(info.get_extradata().is_some());
 
             if let Some(ref edata) = info.get_extradata() {
             validate!(info.get_extradata().is_some());
 
             if let Some(ref edata) = info.get_extradata() {


@@ -351,7 +351,7 @@ impl VMDAudioDecoder {
 }
 
 impl NADecoder for VMDAudioDecoder {
 }
 
 impl NADecoder for VMDAudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let fmt;
             if ainfo.get_format().get_bits() == 8 {
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let fmt;
             if ainfo.get_format().get_bits() == 8 {

diff --git a/nihav-indeo/src/codecs/imc.rs b/nihav-indeo/src/codecs/imc.rs
index 2d65a7c954c15752804834c5558dd2a2769d2703..ceac0d1062e33de26dbeb77b7bab7fc33b73d9e2 100644 (file)
--- a/nihav-indeo/src/codecs/imc.rs
+++ b/nihav-indeo/src/codecs/imc.rs
@@ -1,8 +1,6 @@
 use std::mem;
 use std::ptr;
 use std::f32::consts;
 use std::mem;
 use std::ptr;
 use std::f32::consts;

-use std::rc::Rc;
-use std::cell::RefCell;

 
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 
 use nihav_core::formats::*;
 use nihav_core::frame::*;


@@ -323,7 +321,7 @@ struct IMCDecoder {
 
     chmap:  NAChannelMap,
     ainfo:  NAAudioInfo,
 
     chmap:  NAChannelMap,
     ainfo:  NAAudioInfo,

-    info:   Rc<NACodecInfo>,
+    info:   NACodecInfoRef,

 
     codes:  [[Codebook<u8>; 4]; 4],
     ch_data: [IMCChannel; 2],
 
     codes:  [[Codebook<u8>; 4]; 4],
     ch_data: [IMCChannel; 2],


@@ -867,7 +865,7 @@ const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
 
 impl NADecoder for IMCDecoder {
 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
 
 impl NADecoder for IMCDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap = NAChannelMap::new();
             match ainfo.get_channels() {
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap = NAChannelMap::new();
             match ainfo.get_channels() {

diff --git a/nihav-indeo/src/codecs/indeo2.rs b/nihav-indeo/src/codecs/indeo2.rs
index c3a8a4772ebd9b182339f557ec7673f3c8ee740b..5ea8b3f5ad5666e53333c9f104890e835f34d0dc 100644 (file)
--- a/nihav-indeo/src/codecs/indeo2.rs
+++ b/nihav-indeo/src/codecs/indeo2.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;
 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;


@@ -186,14 +184,14 @@ impl CodebookDescReader<u8> for IR2CodeReader {
 }
 
 struct Indeo2Decoder {
 }
 
 struct Indeo2Decoder {

-    info:    Rc<NACodecInfo>,
+    info:    NACodecInfoRef,

     cb:      Codebook<u8>,
     frmmgr:  HAMShuffler,
 }
 
 impl Indeo2Decoder {
     fn new() -> Self {
     cb:      Codebook<u8>,
     frmmgr:  HAMShuffler,
 }
 
 impl Indeo2Decoder {
     fn new() -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);
+        let dummy_info = NACodecInfo::new_dummy();

         let mut coderead = IR2CodeReader{};
         let cb = Codebook::new(&mut coderead, CodebookMode::LSB).unwrap();
         Indeo2Decoder { info: dummy_info, cb: cb, frmmgr: HAMShuffler::new() }
         let mut coderead = IR2CodeReader{};
         let cb = Codebook::new(&mut coderead, CodebookMode::LSB).unwrap();
         Indeo2Decoder { info: dummy_info, cb: cb, frmmgr: HAMShuffler::new() }


@@ -309,14 +307,14 @@ impl Indeo2Decoder {
 const IR2_START: usize = 48;
 
 impl NADecoder for Indeo2Decoder {
 const IR2_START: usize = 48;
 
 impl NADecoder for Indeo2Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let f = vinfo.is_flipped();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let f = vinfo.is_flipped();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             self.frmmgr.clear();
             Ok(())
         } else {
             self.frmmgr.clear();
             Ok(())
         } else {

diff --git a/nihav-indeo/src/codecs/indeo3.rs b/nihav-indeo/src/codecs/indeo3.rs
index a99db74667b8ac2085569746cf9864b3747b97ab..ebf941c6be9c249ea26dac252b9fa1692ef7597a 100644 (file)
--- a/nihav-indeo/src/codecs/indeo3.rs
+++ b/nihav-indeo/src/codecs/indeo3.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::formats;
 use nihav_core::codecs::*;
 use nihav_core::io::byteio::*;
 use nihav_core::formats;
 use nihav_core::codecs::*;
 use nihav_core::io::byteio::*;


@@ -254,7 +252,7 @@ fn fill_block8x8(bufs: &mut Buffers, doff: usize, stride: usize, h: usize, topli
 }
 
 struct Indeo3Decoder {
 }
 
 struct Indeo3Decoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     bpos:       u8,
     bbuf:       u8,
     width:      u16,
     bpos:       u8,
     bbuf:       u8,
     width:      u16,


@@ -330,7 +328,7 @@ const SKIP_OR_TREE: u8 = 2;
 
 impl Indeo3Decoder {
     fn new() -> Self {
 
 impl Indeo3Decoder {
     fn new() -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);
+        let dummy_info = NACodecInfo::new_dummy();

         Indeo3Decoder { info: dummy_info, bpos: 0, bbuf: 0, width: 0, height: 0,
                         mvs: Vec::new(), altquant: [0; 16],
                         vq_offset: 0, bufs: Buffers::new() }
         Indeo3Decoder { info: dummy_info, bpos: 0, bbuf: 0, width: 0, height: 0,
                         mvs: Vec::new(), altquant: [0; 16],
                         vq_offset: 0, bufs: Buffers::new() }


@@ -690,13 +688,13 @@ const FLAG_KEYFRAME: u16 = 1 << 2;
 const FLAG_NONREF:   u16 = 1 << 8;
 
 impl NADecoder for Indeo3Decoder {
 const FLAG_NONREF:   u16 = 1 << 8;
 
 impl NADecoder for Indeo3Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             self.bufs.reset();
             Ok(())
         } else {
             self.bufs.reset();
             Ok(())
         } else {

diff --git a/nihav-indeo/src/codecs/indeo4.rs b/nihav-indeo/src/codecs/indeo4.rs
index 6311dc9975a2584454d949c2225866f11bf6a01b..07f6d67fa9e5faa1d6c8822a55eee3c311770fa8 100644 (file)
--- a/nihav-indeo/src/codecs/indeo4.rs
+++ b/nihav-indeo/src/codecs/indeo4.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::{Ref, RefCell};

 use nihav_core::io::bitreader::*;
 use nihav_core::formats;
 use nihav_core::frame::*;
 use nihav_core::io::bitreader::*;
 use nihav_core::formats;
 use nihav_core::frame::*;


@@ -419,7 +417,7 @@ impl IndeoXParser for Indeo4Parser {
 }
 
 struct Indeo4Decoder {
 }
 
 struct Indeo4Decoder {

-    info:   Rc<NACodecInfo>,
+    info:   NACodecInfoRef,

     dec:    IVIDecoder,
 }
 
     dec:    IVIDecoder,
 }
 


@@ -433,14 +431,14 @@ impl Indeo4Decoder {
 }
 
 impl NADecoder for Indeo4Decoder {
 }
 
 impl NADecoder for Indeo4Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let f = vinfo.is_flipped();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let f = vinfo.is_flipped();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-indeo/src/codecs/indeo5.rs b/nihav-indeo/src/codecs/indeo5.rs
index 98bd34031aad20d432acae4d93297529629af43d..1f770814c4b5fbb18597cfc4207fabfeb71deaa6 100644 (file)
--- a/nihav-indeo/src/codecs/indeo5.rs
+++ b/nihav-indeo/src/codecs/indeo5.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::{Ref, RefCell};

 use nihav_core::io::bitreader::*;
 use nihav_core::formats;
 use nihav_core::frame::*;
 use nihav_core::io::bitreader::*;
 use nihav_core::formats;
 use nihav_core::frame::*;


@@ -493,7 +491,7 @@ impl IndeoXParser for Indeo5Parser {
 }
 
 struct Indeo5Decoder {
 }
 
 struct Indeo5Decoder {

-    info:   Rc<NACodecInfo>,
+    info:   NACodecInfoRef,

     dec:    IVIDecoder,
     ip:     Indeo5Parser,
 }
     dec:    IVIDecoder,
     ip:     Indeo5Parser,
 }


@@ -509,14 +507,14 @@ impl Indeo5Decoder {
 }
 
 impl NADecoder for Indeo5Decoder {
 }
 
 impl NADecoder for Indeo5Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let f = vinfo.is_flipped();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let f = vinfo.is_flipped();
             let fmt = formats::YUV410_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, f, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-indeo/src/codecs/intel263.rs b/nihav-indeo/src/codecs/intel263.rs
index d84aff51c9f99a2d8a9c7623e6d897e1ee9a2246..3b95c5fa8e4f52466e84323a1a1a27051e77f09d 100644 (file)
--- a/nihav-indeo/src/codecs/intel263.rs
+++ b/nihav-indeo/src/codecs/intel263.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;
 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;


@@ -21,7 +19,7 @@ struct Tables {
 }
 
 struct Intel263Decoder {
 }
 
 struct Intel263Decoder {

-    info:    Rc<NACodecInfo>,
+    info:    NACodecInfoRef,

     dec:     H263BaseDecoder,
     tables:  Tables,
     bdsp:    H263BlockDSP,
     dec:     H263BaseDecoder,
     tables:  Tables,
     bdsp:    H263BlockDSP,


@@ -357,7 +355,7 @@ impl Intel263Decoder {
         };
 
         Intel263Decoder{
         };
 
         Intel263Decoder{

-            info:           Rc::new(DUMMY_CODEC_INFO),
+            info:           NACodecInfo::new_dummy(),

             dec:            H263BaseDecoder::new(true),
             tables:         tables,
             bdsp:           H263BlockDSP::new(),
             dec:            H263BaseDecoder::new(true),
             tables:         tables,
             bdsp:           H263BlockDSP::new(),


@@ -366,13 +364,13 @@ impl Intel263Decoder {
 }
 
 impl NADecoder for Intel263Decoder {
 }
 
 impl NADecoder for Intel263Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             Ok(())
         } else {
             Err(DecoderError::InvalidData)
             Ok(())
         } else {
             Err(DecoderError::InvalidData)

diff --git a/nihav-rad/src/codecs/bink2.rs b/nihav-rad/src/codecs/bink2.rs
index 719608d4b5b5c2ab236811c1f9a722f3e7762390..60d42a4fb8a9d5a0d1c05809d2771fd77711f2d4 100644 (file)
--- a/nihav-rad/src/codecs/bink2.rs
+++ b/nihav-rad/src/codecs/bink2.rs
@@ -996,7 +996,7 @@ impl Default for Bink2Codes {
 
 #[derive(Default)]
 struct Bink2Decoder {
 
 #[derive(Default)]
 struct Bink2Decoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     ips:        IPShuffler,
 
     version:    u32,
     ips:        IPShuffler,
 
     version:    u32,


@@ -1858,7 +1858,7 @@ fn decode_acs_4blocks_old(br: &mut BitReader, codes: &Bink2Codes, dst: &mut [[f3
 const KB2H_NUM_SLICES: [usize; 4] = [ 2, 3, 4, 8 ];
 
 impl NADecoder for Bink2Decoder {
 const KB2H_NUM_SLICES: [usize; 4] = [ 2, 3, 4, 8 ];
 
 impl NADecoder for Bink2Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();


@@ -1907,7 +1907,7 @@ impl NADecoder for Bink2Decoder {
                                            if self.has_alpha { FORMATON_FLAG_ALPHA } else { 0 },
                                            if self.has_alpha { 4 } else { 3 });
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
                                            if self.has_alpha { FORMATON_FLAG_ALPHA } else { 0 },
                                            if self.has_alpha { 4 } else { 3 });
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             Ok(())
         } else {
 
             Ok(())
         } else {

diff --git a/nihav-rad/src/codecs/binkaud.rs b/nihav-rad/src/codecs/binkaud.rs
index c38f6d4beff88ca7094eefe4bf675e2ad8391591..182c6c91f2a5d7e370f429e6d3dda1d895f58be6 100644 (file)
--- a/nihav-rad/src/codecs/binkaud.rs
+++ b/nihav-rad/src/codecs/binkaud.rs
@@ -178,7 +178,7 @@ const CRITICAL_FREQS: [usize; MAX_BANDS] = [
 const RUN_TAB: [usize; 16] = [ 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64 ];
 
 impl NADecoder for BinkAudioDecoder {
 const RUN_TAB: [usize; 16] = [ 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 64 ];
 
 impl NADecoder for BinkAudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let srate    = ainfo.get_sample_rate();
             let channels = ainfo.get_channels();
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let srate    = ainfo.get_sample_rate();
             let channels = ainfo.get_channels();

diff --git a/nihav-rad/src/codecs/binkvid.rs b/nihav-rad/src/codecs/binkvid.rs
index dc9a469cfb06552cb3571b351e26068c27494b33..2f95ed6b58c1add29a8d1f437e1043663c06e56e 100644 (file)
--- a/nihav-rad/src/codecs/binkvid.rs
+++ b/nihav-rad/src/codecs/binkvid.rs
@@ -474,7 +474,7 @@ impl Default for QuantMats {
 
 #[derive(Default)]
 struct BinkDecoder {
 
 #[derive(Default)]
 struct BinkDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     ips:        IPShuffler,
     hams:       HAMShuffler,
 
     ips:        IPShuffler,
     hams:       HAMShuffler,
 


@@ -1157,7 +1157,7 @@ const BINK_FLAG_ALPHA:  u32 = 0x00100000;
 const BINK_FLAG_GRAY:   u32 = 0x00020000;
 
 impl NADecoder for BinkDecoder {
 const BINK_FLAG_GRAY:   u32 = 0x00020000;
 
 impl NADecoder for BinkDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();


@@ -1192,7 +1192,7 @@ impl NADecoder for BinkDecoder {
                                            None, None, None, None, 0, 1);
             }
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
                                            None, None, None, None, 0, 1);
             }
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             //self.init_bundle_lengths(w.max(8), (w + 7) >> 3);
             self.init_bundle_bufs((w + 7) >> 3, (h + 7) >> 3);
 
             //self.init_bundle_lengths(w.max(8), (w + 7) >> 3);
             self.init_bundle_bufs((w + 7) >> 3, (h + 7) >> 3);

diff --git a/nihav-rad/src/codecs/smacker.rs b/nihav-rad/src/codecs/smacker.rs
index bbf48460061c519d85906af5f0ca57a2e9f7a60d..bc27ab0b31a6616d5761c6cf97d1d319f5d911ca 100644 (file)
--- a/nihav-rad/src/codecs/smacker.rs
+++ b/nihav-rad/src/codecs/smacker.rs
@@ -210,7 +210,7 @@ const SMK_BLOCK_RUNS: [usize; 64] = [
 ];
 
 struct SmackerVideoDecoder {
 ];
 
 struct SmackerVideoDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     mmap_tree:  SmackerTree16,
     mclr_tree:  SmackerTree16,
     full_tree:  SmackerTree16,
     mmap_tree:  SmackerTree16,
     mclr_tree:  SmackerTree16,
     full_tree:  SmackerTree16,


@@ -227,9 +227,8 @@ struct SmackerVideoDecoder {
 
 impl SmackerVideoDecoder {
     fn new() -> Self {
 
 impl SmackerVideoDecoder {
     fn new() -> Self {

-        let dummy_info = Rc::new(DUMMY_CODEC_INFO);

         Self {
         Self {

-            info:       dummy_info,
+            info:       NACodecInfoRef::default(),

             mmap_tree:  SmackerTree16::new(),
             mclr_tree:  SmackerTree16::new(),
             full_tree:  SmackerTree16::new(),
             mmap_tree:  SmackerTree16::new(),
             mclr_tree:  SmackerTree16::new(),
             full_tree:  SmackerTree16::new(),


@@ -388,7 +387,7 @@ impl SmackerVideoDecoder {
 }
 
 impl NADecoder for SmackerVideoDecoder {
 }
 
 impl NADecoder for SmackerVideoDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();


@@ -428,8 +427,7 @@ impl NADecoder for SmackerVideoDecoder {
                 out_h <<= 1;
             }
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, out_h, false, fmt));
                 out_h <<= 1;
             }
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, out_h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
-
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             Ok(())
         } else {
 
             Ok(())
         } else {


@@ -494,7 +492,7 @@ impl SmackerAudioDecoder {
 }
 
 impl NADecoder for SmackerAudioDecoder {
 }
 
 impl NADecoder for SmackerAudioDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.bits = ainfo.get_format().get_bits();
             let fmt = if self.bits == 8 { SND_U8_FORMAT } else { SND_S16P_FORMAT };
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.bits = ainfo.get_format().get_bits();
             let fmt = if self.bits == 8 { SND_U8_FORMAT } else { SND_S16P_FORMAT };

diff --git a/nihav-realmedia/src/codecs/cook.rs b/nihav-realmedia/src/codecs/cook.rs
index 6d7877b4a2f8cd1d6dc948e5d44dab0b581f4eee..6303724c2ff1edcfdeecf29faca6c5a12f233e54 100644 (file)
--- a/nihav-realmedia/src/codecs/cook.rs
+++ b/nihav-realmedia/src/codecs/cook.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -523,7 +521,7 @@ impl RND {
 }
 
 struct CookDecoder {
 }
 
 struct CookDecoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     chmap:      NAChannelMap,
     src:        [u8; 65536],
     num_pairs:  usize,
     chmap:      NAChannelMap,
     src:        [u8; 65536],
     num_pairs:  usize,


@@ -553,7 +551,7 @@ impl CookDecoder {
 }
 
 impl NADecoder for CookDecoder {
 }
 
 impl NADecoder for CookDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
             validate!(edata.len() >= 4);
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
             validate!(edata.len() >= 4);

diff --git a/nihav-realmedia/src/codecs/ra144.rs b/nihav-realmedia/src/codecs/ra144.rs
index 19cf38b841c713b8b84ea54bfec055c36ac69e11..38d76c3764f8e1dd2107d2ba7ccb3ef2b6cc69d1 100644 (file)
--- a/nihav-realmedia/src/codecs/ra144.rs
+++ b/nihav-realmedia/src/codecs/ra144.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -14,7 +12,7 @@ const FRAME_SIZE: usize = 20;
 struct RA144Decoder {
     chmap:  NAChannelMap,
     ainfo:  NAAudioInfo,
 struct RA144Decoder {
     chmap:  NAChannelMap,
     ainfo:  NAAudioInfo,

-    info:   Rc<NACodecInfo>,
+    info:   NACodecInfoRef,

 
     old_energy:     u16,
     lpc_data:       [[i32; LPC_ORDER]; 2],
 
     old_energy:     u16,
     lpc_data:       [[i32; LPC_ORDER]; 2],


@@ -244,7 +242,7 @@ fn clip_out(sample: i16) -> i16 {
 }
 
 impl NADecoder for RA144Decoder {
 }
 
 impl NADecoder for RA144Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap.add_channels(&CHMAP_MONO);
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap.add_channels(&CHMAP_MONO);
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),

diff --git a/nihav-realmedia/src/codecs/ra288.rs b/nihav-realmedia/src/codecs/ra288.rs
index 8538f8560b6fec2da1810ccf897a8f6071148f4e..142cf2ae1cec294242c637382b9d514dcef5d268 100644 (file)
--- a/nihav-realmedia/src/codecs/ra288.rs
+++ b/nihav-realmedia/src/codecs/ra288.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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -17,7 +15,7 @@ const GAIN_START: usize = 28;
 struct RA288Decoder {
     chmap:  NAChannelMap,
     ainfo:  NAAudioInfo,
 struct RA288Decoder {
     chmap:  NAChannelMap,
     ainfo:  NAAudioInfo,

-    info:   Rc<NACodecInfo>,
+    info:   NACodecInfoRef,

 
     speech_lpc:     [f32; SP_LPC_ORDER],
     speech_hist:    [f32; 111],
 
     speech_lpc:     [f32; SP_LPC_ORDER],
     speech_hist:    [f32; 111],


@@ -153,7 +151,7 @@ impl RA288Decoder {
 }
 
 impl NADecoder for RA288Decoder {
 }
 
 impl NADecoder for RA288Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap.add_channels(&CHMAP_MONO);
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             self.chmap.add_channels(&CHMAP_MONO);
             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),

diff --git a/nihav-realmedia/src/codecs/ralf.rs b/nihav-realmedia/src/codecs/ralf.rs
index 76bf3df8f50ae7c97f6a3fcbdcc8cafcc7ad8fd0..307436c9ed03743a7158a5f88761c28383e7cba7 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::*;
 use nihav_core::formats::*;
 use nihav_core::frame::*;
 use nihav_core::codecs::*;


@@ -246,7 +244,7 @@ struct Block {
 
 const RALF_MAX_PACKET_SIZE: usize = 8192;
 struct RALFDecoder {
 
 const RALF_MAX_PACKET_SIZE: usize = 8192;
 struct RALFDecoder {

-    info:           Rc<NACodecInfo>,
+    info:           NACodecInfoRef,

     chmap:          NAChannelMap,
     channels:       u8,
 
     chmap:          NAChannelMap,
     channels:       u8,
 


@@ -357,7 +355,7 @@ fn read_block_length(br: &mut BitReader) -> DecoderResult<usize> {
 }
 
 impl NADecoder for RALFDecoder {
 }
 
 impl NADecoder for RALFDecoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
 
         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
             let edata = info.get_extradata().unwrap();
 

diff --git a/nihav-realmedia/src/codecs/rv10.rs b/nihav-realmedia/src/codecs/rv10.rs
index 348a7ff8b713c80255593e9dc9571bb830344135..1d93a012433a54cb12f2a446e9bb1de005926231 100644 (file)
--- a/nihav-realmedia/src/codecs/rv10.rs
+++ b/nihav-realmedia/src/codecs/rv10.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;
 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;


@@ -23,7 +21,7 @@ struct Tables {
 }
 
 struct RealVideo10Decoder {
 }
 
 struct RealVideo10Decoder {

-    info:    Rc<NACodecInfo>,
+    info:    NACodecInfoRef,

     dec:     H263BaseDecoder,
     tables:  Tables,
     w:       usize,
     dec:     H263BaseDecoder,
     tables:  Tables,
     w:       usize,


@@ -392,7 +390,7 @@ impl RealVideo10Decoder {
         };
 
         RealVideo10Decoder{
         };
 
         RealVideo10Decoder{

-            info:           Rc::new(DUMMY_CODEC_INFO),
+            info:           NACodecInfoRef::default(),

             dec:            H263BaseDecoder::new_with_opts(false, false, false),
             tables:         tables,
             w:              0,
             dec:            H263BaseDecoder::new_with_opts(false, false, false),
             tables:         tables,
             w:              0,


@@ -405,13 +403,13 @@ impl RealVideo10Decoder {
 }
 
 impl NADecoder for RealVideo10Decoder {
 }
 
 impl NADecoder for RealVideo10Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             self.w = w;
             self.h = h;
 
             self.w = w;
             self.h = h;
 

diff --git a/nihav-realmedia/src/codecs/rv20.rs b/nihav-realmedia/src/codecs/rv20.rs
index eeb56cfb9b2f59625e52968ddd6f86e2837e3070..36ccc67846ce9dd1d806f9a9542d311ce84c91da 100644 (file)
--- a/nihav-realmedia/src/codecs/rv20.rs
+++ b/nihav-realmedia/src/codecs/rv20.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;
 use nihav_core::io::bitreader::*;
 use nihav_core::io::codebook::*;
 use nihav_core::formats;


@@ -32,7 +30,7 @@ struct RPRInfo {
 }
 
 struct RealVideo20Decoder {
 }
 
 struct RealVideo20Decoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     dec:        H263BaseDecoder,
     tables:     Tables,
     w:          usize,
     dec:        H263BaseDecoder,
     tables:     Tables,
     w:          usize,


@@ -445,7 +443,7 @@ impl RealVideo20Decoder {
         };
 
         RealVideo20Decoder{
         };
 
         RealVideo20Decoder{

-            info:           Rc::new(DUMMY_CODEC_INFO),
+            info:           NACodecInfoRef::default(),

             dec:            H263BaseDecoder::new_b_frames(false),
             tables:         tables,
             w:              0,
             dec:            H263BaseDecoder::new_b_frames(false),
             tables:         tables,
             w:              0,


@@ -459,13 +457,13 @@ impl RealVideo20Decoder {
 
 impl NADecoder for RealVideo20Decoder {
 #[allow(unused_variables)]
 
 impl NADecoder for RealVideo20Decoder {
 #[allow(unused_variables)]

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let w = vinfo.get_width();
             let h = vinfo.get_height();
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

             self.w = w;
             self.h = h;
 
             self.w = w;
             self.h = h;
 

diff --git a/nihav-realmedia/src/codecs/rv30.rs b/nihav-realmedia/src/codecs/rv30.rs
index acdefb61928aaf3086c518a05c2321770f74a2c2..a2d7090cc19098ddefdc98b92b4c0b5d6510035a 100644 (file)
--- a/nihav-realmedia/src/codecs/rv30.rs
+++ b/nihav-realmedia/src/codecs/rv30.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::formats;
 use nihav_core::io::bitreader::*;
 use nihav_core::io::intcode::*;
 use nihav_core::formats;
 use nihav_core::io::bitreader::*;
 use nihav_core::io::intcode::*;


@@ -104,7 +102,7 @@ impl RV34BitstreamDecoder for RealVideo30BR {
 
 struct RealVideo30Decoder {
     bd:         RealVideo30BR,
 
 struct RealVideo30Decoder {
     bd:         RealVideo30BR,

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     dec:        RV34Decoder,
 }
 
     dec:        RV34Decoder,
 }
 


@@ -112,18 +110,18 @@ impl RealVideo30Decoder {
     fn new() -> Self {
         RealVideo30Decoder{
             bd:         RealVideo30BR::new(),
     fn new() -> Self {
         RealVideo30Decoder{
             bd:         RealVideo30BR::new(),

-            info:       Rc::new(DUMMY_CODEC_INFO),
+            info:       NACodecInfoRef::default(),

             dec:        RV34Decoder::new(true, Box::new(RV30DSP::new())),
         }
     }
 }
 
 impl NADecoder for RealVideo30Decoder {
             dec:        RV34Decoder::new(true, Box::new(RV30DSP::new())),
         }
     }
 }
 
 impl NADecoder for RealVideo30Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             let edata = info.get_extradata().unwrap();
             let src: &[u8] = &edata;
 
             let edata = info.get_extradata().unwrap();
             let src: &[u8] = &edata;

diff --git a/nihav-realmedia/src/codecs/rv40.rs b/nihav-realmedia/src/codecs/rv40.rs
index d664dce8d343f9867e40b0bb6925ef646e3fc017..eb45164401e6ed50127968d7f9549f995ba0e793 100644 (file)
--- a/nihav-realmedia/src/codecs/rv40.rs
+++ b/nihav-realmedia/src/codecs/rv40.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::formats;
 use nihav_core::frame::*;
 use nihav_core::io::bitreader::*;
 use nihav_core::formats;
 use nihav_core::frame::*;
 use nihav_core::io::bitreader::*;


@@ -301,7 +299,7 @@ impl RV34BitstreamDecoder for RealVideo40BR {
 
 struct RealVideo40Decoder {
     bd:         RealVideo40BR,
 
 struct RealVideo40Decoder {
     bd:         RealVideo40BR,

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     dec:        RV34Decoder,
 }
 
     dec:        RV34Decoder,
 }
 


@@ -309,18 +307,18 @@ impl RealVideo40Decoder {
     fn new() -> Self {
         RealVideo40Decoder{
             bd:         RealVideo40BR::new(),
     fn new() -> Self {
         RealVideo40Decoder{
             bd:         RealVideo40BR::new(),

-            info:       Rc::new(DUMMY_CODEC_INFO),
+            info:       NACodecInfoRef::default(),

             dec:        RV34Decoder::new(false, Box::new(RV40DSP::new())),
         }
     }
 }
 
 impl NADecoder for RealVideo40Decoder {
             dec:        RV34Decoder::new(false, Box::new(RV40DSP::new())),
         }
     }
 }
 
 impl NADecoder for RealVideo40Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt));
         if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
             let fmt = formats::YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             let edata = info.get_extradata().unwrap();
             let src: &[u8] = &edata;
 
             let edata = info.get_extradata().unwrap();
             let src: &[u8] = &edata;

diff --git a/nihav-realmedia/src/codecs/rv60.rs b/nihav-realmedia/src/codecs/rv60.rs
index b430b5bcbd749c8c6e3b4c111f6d6ac672d828f6..4adbe394406c2b25be546fbcfb153a453998d9b4 100644 (file)
--- a/nihav-realmedia/src/codecs/rv60.rs
+++ b/nihav-realmedia/src/codecs/rv60.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-use std::cell::RefCell;

 use nihav_core::formats::YUV420_FORMAT;
 use nihav_core::frame::*;
 use nihav_core::codecs::{NADecoder, MV, ZERO_MV, DecoderError, DecoderResult, IPBShuffler};
 use nihav_core::formats::YUV420_FORMAT;
 use nihav_core::frame::*;
 use nihav_core::codecs::{NADecoder, MV, ZERO_MV, DecoderError, DecoderResult, IPBShuffler};


@@ -610,7 +608,7 @@ impl DeblockInfo {
 }
 
 struct RealVideo60Decoder {
 }
 
 struct RealVideo60Decoder {

-    info:       Rc<NACodecInfo>,
+    info:       NACodecInfoRef,

     cbs:        RV60Codebooks,
     ipbs:       IPBShuffler,
     dsp:        RV60DSP,
     cbs:        RV60Codebooks,
     ipbs:       IPBShuffler,
     dsp:        RV60DSP,


@@ -647,7 +645,7 @@ impl RealVideo60Decoder {
         let vb = vt.get_vbuf();
         let avg_buf = vb.unwrap();
         RealVideo60Decoder{
         let vb = vt.get_vbuf();
         let avg_buf = vb.unwrap();
         RealVideo60Decoder{

-            info:       Rc::new(DUMMY_CODEC_INFO),
+            info:       NACodecInfoRef::default(),

             cbs:        RV60Codebooks::init(),
             ipbs:       IPBShuffler::new(),
             ipred:      IntraPredContext::new(),
             cbs:        RV60Codebooks::init(),
             ipbs:       IPBShuffler::new(),
             ipred:      IntraPredContext::new(),


@@ -1393,11 +1391,11 @@ println!(" left {} bits", br.left());
 }
 
 impl NADecoder for RealVideo60Decoder {
 }
 
 impl NADecoder for RealVideo60Decoder {

-    fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+    fn init(&mut self, info: NACodecInfoRef) -> DecoderResult<()> {

         if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
             let fmt = YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt));
         if let NACodecTypeInfo::Video(_vinfo) = info.get_properties() {
             let fmt = YUV420_FORMAT;
             let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, false, fmt));

-            self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
+            self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();

 
             let edata = info.get_extradata().unwrap();
             let src: &[u8] = &edata;
 
             let edata = info.get_extradata().unwrap();
             let src: &[u8] = &edata;