]> git.nihav.org Git - nihav.git/commitdiff
use static codebook arrays instead of vectors where applicable
authorKostya Shishkov <kostya.shishkov@gmail.com>
Mon, 16 Nov 2026 20:31:56 +0000 (21:31 +0100)
committerKostya Shishkov <kostya.shishkov@gmail.com>
Mon, 16 Nov 2026 20:31:56 +0000 (21:31 +0100)
nihav-qt/src/codecs/svq1.rs
nihav-realmedia/src/codecs/cook.rs
nihav-realmedia/src/codecs/ralf.rs
nihav-realmedia/src/codecs/rv34codes.rs
nihav-realmedia/src/codecs/rv40.rs
nihav-vivo/src/codecs/siren.rs

index 431a04992b9ca70f7fbc114d98f6b78df92808d1..63d5fe76c920e8ed5eb57c3f9b70b46bebf75307 100644 (file)
@@ -120,8 +120,8 @@ struct SVQ1Decoder {
     height:     usize,
     ref_frm:    Option<NAVideoBufferRef<u8>>,
     mvs:        Vec<MV>,
-    intra_stages_cb:    Vec<Codebook<i16>>,
-    inter_stages_cb:    Vec<Codebook<i16>>,
+    intra_stages_cb:    [Codebook<i16>; 6],
+    inter_stages_cb:    [Codebook<i16>; 6],
     intra_mean_cb:      Codebook<i16>,
     inter_mean_cb:      Codebook<i16>,
     mv_cb:              Codebook<i16>,
@@ -131,18 +131,12 @@ struct SVQ1Decoder {
 
 impl SVQ1Decoder {
     fn new() -> Self {
-        let mut intra_stages_cb = Vec::with_capacity(6);
-        for table in SVQ_INTRA_STAGE_CODES.iter() {
-            let mut cbd = SVQ1DescReader { table, bias: -1 };
-            let cb = Codebook::new(&mut cbd, CodebookMode::MSB).unwrap();
-            intra_stages_cb.push(cb);
-        }
-        let mut inter_stages_cb = Vec::with_capacity(6);
-        for table in SVQ_INTER_STAGE_CODES.iter() {
-            let mut cbd = SVQ1DescReader { table, bias: -1 };
-            let cb = Codebook::new(&mut cbd, CodebookMode::MSB).unwrap();
-            inter_stages_cb.push(cb);
-        }
+        let intra_stages_cb = std::array::from_fn(|i| {
+            let mut cbd = SVQ1DescReader { table: &SVQ_INTRA_STAGE_CODES[i], bias: -1 };
+            Codebook::new(&mut cbd, CodebookMode::MSB).unwrap() });
+        let inter_stages_cb = std::array::from_fn(|i| {
+            let mut cbd = SVQ1DescReader { table: &SVQ_INTER_STAGE_CODES[i], bias: -1 };
+            Codebook::new(&mut cbd, CodebookMode::MSB).unwrap() });
         let mut cbd = SVQ1DescReader { table: &SVQ_INTRA_MEAN_CODES, bias: 0 };
         let intra_mean_cb = Codebook::new(&mut cbd, CodebookMode::MSB).unwrap();
         let mut cbd = SVQ1InterMeanDescReader {};
index c360145f2aa41d2496d55c36c7e2b33c3c560650..bc1610ab89bc09538fd33303ad5c7ccd0b01fae9 100644 (file)
@@ -39,7 +39,7 @@ impl CodebookDescReader<u16> for CookBookReader {
 
 struct Codebooks {
     cpl_cb:     [Codebook<u16>; 5],
-    quant_cb:   Vec<Codebook<u16>>,
+    quant_cb:   [Codebook<u16>; COOK_QUANT_CODES.len()],
     vq_cb:      [Codebook<u16>; 7],
 }
 
@@ -55,11 +55,9 @@ impl Codebooks {
                       Codebook::new(&mut cpl2, CodebookMode::MSB).unwrap(),
                       Codebook::new(&mut cpl3, CodebookMode::MSB).unwrap(),
                       Codebook::new(&mut cpl4, CodebookMode::MSB).unwrap()];
-        let mut quant_cb: Vec<Codebook<u16>> = Vec::with_capacity(COOK_QUANT_CODES.len());
-        for i in 0..COOK_QUANT_CODES.len() {
+        let quant_cb = std::array::from_fn(|i| {
             let mut quant = CookBookReader { codes: COOK_QUANT_CODES[i], bits: COOK_QUANT_BITS[i] };
-            quant_cb.push(Codebook::new(&mut quant, CodebookMode::MSB).unwrap());
-        }
+            Codebook::new(&mut quant, CodebookMode::MSB).unwrap() });
         let mut vq0 = CookBookReader { codes: COOK_VQ0_CODES, bits: COOK_VQ0_BITS };
         let mut vq1 = CookBookReader { codes: COOK_VQ1_CODES, bits: COOK_VQ1_BITS };
         let mut vq2 = CookBookReader { codes: COOK_VQ2_CODES, bits: COOK_VQ2_BITS };
index 1ebad04442aa89a1157e9fefd9739e28044afd90..28f3b5b3d046ee9deb2f0d0ef8d244448e0d6d10 100644 (file)
@@ -10,9 +10,9 @@ struct CodebookSet {
     filter_params_cb:   Codebook<u16>,
     bias_cb:            Codebook<u16>,
     coding_mode_cb:     Codebook<u16>,
-    filter_coeffs_cb:   Vec<Vec<Codebook<u16>>>,
-    short_codes_cb:     Vec<Codebook<u16>>,
-    long_codes_cb:      Vec<Codebook<u16>>,
+    filter_coeffs_cb:   [[Codebook<u16>; 11]; 10],
+    short_codes_cb:     [Codebook<u16>; 15],
+    long_codes_cb:      [Codebook<u16>; 125],
 }
 
 const MAX_ELEMS: usize = 644;
@@ -64,26 +64,17 @@ impl CodebookSet {
         let mut cbr = RALFCodebookDescReader::new(&RALF_CODING_MODE_TAB[idx], RALF_CODING_MODE_LEN);
         let coding_mode_cb = Codebook::new(&mut cbr, CodebookMode::MSB).unwrap();
 
-        let mut filter_coeffs_cb: Vec<Vec<Codebook<u16>>> = Vec::with_capacity(10);
-        for cb_set in RALF_FILTER_COEFFS_TAB[idx].iter() {
-            let mut fcb: Vec<Codebook<u16>> = Vec::with_capacity(11);
-            for cb in cb_set.iter() {
-                let mut cbr = RALFCodebookDescReader::new(cb, RALF_FILTER_COEFFS_LEN);
-                fcb.push(Codebook::new(&mut cbr, CodebookMode::MSB).unwrap());
-            }
-            filter_coeffs_cb.push(fcb);
-        }
+        let filter_coeffs_cb = std::array::from_fn(|i|
+            std::array::from_fn(|j| {
+                let mut cbr = RALFCodebookDescReader::new(&RALF_FILTER_COEFFS_TAB[idx][i][j], RALF_FILTER_COEFFS_LEN);
+                Codebook::new(&mut cbr, CodebookMode::MSB).unwrap() }));
 
-        let mut short_codes_cb: Vec<Codebook<u16>> = Vec::with_capacity(15);
-        for cb in RALF_SHORT_CODES_TAB[idx].iter() {
-            let mut cbr = RALFCodebookDescReader::new(cb, RALF_SHORT_CODES_LEN);
-            short_codes_cb.push(Codebook::new(&mut cbr, CodebookMode::MSB).unwrap());
-        }
-        let mut long_codes_cb: Vec<Codebook<u16>> = Vec::with_capacity(125);
-        for cb in RALF_LONG_CODES_TAB[idx].iter() {
-            let mut cbr = RALFCodebookDescReader::new(cb, RALF_LONG_CODES_LEN);
-            long_codes_cb.push(Codebook::new(&mut cbr, CodebookMode::MSB).unwrap());
-        }
+        let short_codes_cb = std::array::from_fn(|i| {
+            let mut cbr = RALFCodebookDescReader::new(&RALF_SHORT_CODES_TAB[idx][i], RALF_SHORT_CODES_LEN);
+            Codebook::new(&mut cbr, CodebookMode::MSB).unwrap() });
+        let long_codes_cb = std::array::from_fn(|i| {
+            let mut cbr = RALFCodebookDescReader::new(&RALF_LONG_CODES_TAB[idx][i], RALF_LONG_CODES_LEN);
+            Codebook::new(&mut cbr, CodebookMode::MSB).unwrap() });
 
         Self { filter_params_cb, bias_cb, coding_mode_cb, filter_coeffs_cb, short_codes_cb, long_codes_cb }
     }
index 4c684b504d16fde88d3799d7991571ba185ac35a..0dddfd292e95a8dd5481944d47003c95af9db418 100644 (file)
@@ -9,8 +9,8 @@ struct CBPSet {
 
 struct CoefSet {
     blk_pattern0:   Vec<Codebook<u16>>,
-    blk_pattern1:   Vec<Codebook<u16>>,
-    blk_pattern2:   Vec<Codebook<u16>>,
+    blk_pattern1:   [Codebook<u16>; 2],
+    blk_pattern2:   [Codebook<u16>; 2],
 }
 
 struct FullSet {
@@ -156,13 +156,13 @@ impl CoefSet {
             let second0 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
             let mut coderead = RV34CodeReader::new(&RV34_INTRA_SECONDPAT[set][1]);
             let second1 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            let seconds: Vec<Codebook<u16>> = vec![second0, second1];
+            let seconds = [second0, second1];
 
             let mut coderead = RV34CodeReader::new(&RV34_INTRA_THIRDPAT[set][0]);
             let third0 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
             let mut coderead = RV34CodeReader::new(&RV34_INTRA_THIRDPAT[set][1]);
             let third1 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            let thirds: Vec<Codebook<u16>> = vec![third0, third1];
+            let thirds = [third0, third1];
 
             CoefSet { blk_pattern0: firsts, blk_pattern1: seconds, blk_pattern2: thirds }
         } else {
@@ -176,13 +176,13 @@ impl CoefSet {
             let second0 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
             let mut coderead = RV34CodeReader::new(&RV34_INTER_SECONDPAT[set][1]);
             let second1 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            let seconds: Vec<Codebook<u16>> = vec![second0, second1];
+            let seconds = [second0, second1];
 
             let mut coderead = RV34CodeReader::new(&RV34_INTER_THIRDPAT[set][0]);
             let third0 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
             let mut coderead = RV34CodeReader::new(&RV34_INTER_THIRDPAT[set][1]);
             let third1 = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            let thirds: Vec<Codebook<u16>> = vec![third0, third1];
+            let thirds = [third0, third1];
 
             CoefSet { blk_pattern0: firsts, blk_pattern1: seconds, blk_pattern2: thirds }
         }
index bca36eee2f6233b47f864595503d5084f75a92c9..759593016e4a41a6db581bd5bab436dd0260749a 100644 (file)
@@ -50,10 +50,10 @@ struct RealVideo40BR {
     width:          usize,
     height:         usize,
     aic_top_cb:     Codebook<i8>,
-    aic_mode1_cb:   Vec<Codebook<i8>>,
-    aic_mode2_cb:   Vec<Codebook<i8>>,
-    ptype_cb:       Vec<Codebook<MBType>>,
-    btype_cb:       Vec<Codebook<MBType>>,
+    aic_mode1_cb:   [Codebook<i8>; 90],
+    aic_mode2_cb:   [Codebook<i8>; 20],
+    ptype_cb:       [Codebook<MBType>; 7],
+    btype_cb:       [Codebook<MBType>; 6],
     had_skip_run:   bool,
 }
 
@@ -62,39 +62,26 @@ impl RealVideo40BR {
         let mut coderead = AICCodeReader8{ lengths: &RV40_AIC_TOP_BITS, codes: &RV40_AIC_TOP_CODES };
         let aic_top_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 
-        let mut aic_mode1_cb: Vec<Codebook<i8>> = Vec::with_capacity(RV40_AIC_MODE1_BITS.len());
-        for i in 0..RV40_AIC_MODE1_BITS.len() {
+        let aic_mode1_cb = std::array::from_fn(|i|
             if (i % 10) != 9 {
                 let mut coderead = AICCodeReader8{ lengths: &RV40_AIC_MODE1_BITS[i], codes: &RV40_AIC_MODE1_CODES[i] };
-                let cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-                aic_mode1_cb.push(cb);
+                Codebook::new(&mut coderead, CodebookMode::MSB).unwrap()
             } else {
                 let mut coderead = AICCodeReader8{ lengths: &RV40_AIC_MODE1_BITS_DUMMY, codes: &RV40_AIC_MODE1_CODES_DUMMY };
-                let cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-                aic_mode1_cb.push(cb);
-            }
-        }
+                Codebook::new(&mut coderead, CodebookMode::MSB).unwrap()
+            });
 
-        let mut aic_mode2_cb: Vec<Codebook<i8>> = Vec::with_capacity(RV40_AIC_MODE2_BITS.len());
-        for i in 0..RV40_AIC_MODE2_BITS.len() {
+        let aic_mode2_cb = std::array::from_fn(|i| {
             let mut coderead = AICCodeReader16{ lengths: &RV40_AIC_MODE2_BITS[i], codes: &RV40_AIC_MODE2_CODES[i] };
-            let cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            aic_mode2_cb.push(cb);
-        }
+            Codebook::new(&mut coderead, CodebookMode::MSB).unwrap() });
 
-        let mut ptype_cb: Vec<Codebook<MBType>> = Vec::with_capacity(RV40_PTYPE_BITS.len());
-        for i in 0..RV40_PTYPE_BITS.len() {
+        let ptype_cb = std::array::from_fn(|i| {
             let mut coderead = TypeCodeReader{ lengths: &RV40_PTYPE_BITS[i], codes: &RV40_PTYPE_CODES[i], syms: RV40_PTYPE_SYMS };
-            let cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            ptype_cb.push(cb);
-        }
+            Codebook::new(&mut coderead, CodebookMode::MSB).unwrap() });
 
-        let mut btype_cb: Vec<Codebook<MBType>> = Vec::with_capacity(RV40_BTYPE_BITS.len());
-        for i in 0..RV40_BTYPE_BITS.len() {
+        let btype_cb = std::array::from_fn(|i| {
             let mut coderead = TypeCodeReader{ lengths: &RV40_BTYPE_BITS[i], codes: &RV40_BTYPE_CODES[i], syms: RV40_BTYPE_SYMS };
-            let cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
-            btype_cb.push(cb);
-        }
+            Codebook::new(&mut coderead, CodebookMode::MSB).unwrap() });
 
         RealVideo40BR {
             width:          0,
index 868b4d46bda670645ae6d44ce8f43c530b6391aa..09a22bdb8c8b7e9172ca93aa2a645a95cb7ee774 100644 (file)
@@ -37,7 +37,7 @@ struct SirenDecoder {
     chmap:              NAChannelMap,
     ainfo:              NAAudioInfo,
     info:               NACodecInfoRef,
-    diff_cb:            Vec<Codebook<i8>>,
+    diff_cb:            [Codebook<i8>; NUM_DIFF_CB],
     vec_cb:             [Codebook<u16>; 7],
     imdct:              IMDCT,
 
@@ -59,12 +59,9 @@ struct SirenDecoder {
 fn map_idx_diff(idx: usize) -> i8 { (idx as i8) - 12 }
 impl SirenDecoder {
     fn new() -> Self {
-        let mut diff_cb = Vec::with_capacity(NUM_DIFF_CB);
-        for i in 0..NUM_DIFF_CB {
+        let diff_cb = std::array::from_fn(|i| {
             let mut cr = TableCodebookDescReader::new(&DIFF_CODE_BITS[i], &DIFF_CODE_LENS[i], map_idx_diff);
-            let cb = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
-            diff_cb.push(cb);
-        }
+            Codebook::new(&mut cr, CodebookMode::MSB).unwrap() });
         let mut cr = TableCodebookDescReader::new(&VEC_CB0_BITS, &VEC_CB0_LENS, |idx| VEC_CB0_SYMS[idx]);
         let vec_cb0 = Codebook::new(&mut cr, CodebookMode::MSB).unwrap();
         let mut cr = TableCodebookDescReader::new(&VEC_CB1_BITS, &VEC_CB1_LENS, |idx| VEC_CB1_SYMS[idx]);