Merge pull request #215 from paolobarbolini/array

Use arrays in more places

Author: HeroicKatora

src/decoder.rs

@@ -668,8 +668,8 @@ impl<R: Read> Decoder<R> {
                                 let block_offset = (block_y * component.block_size.width as usize + block_x) * 64;
                                 &mut mcu_row_coefficients[i][block_offset..block_offset + 64]
                             } else {
-                                &mut dummy_block[..]
-                            };
+                                &mut dummy_block[..64]
+                            }.try_into().unwrap();
 
                             if scan.successive_approximation_high == 0 {
                                 decode_block(&mut self.reader,
@@ -755,16 +755,14 @@ impl<R: Read> Decoder<R> {
 }
 
 fn decode_block<R: Read>(reader: &mut R,
-                         coefficients: &mut [i16],
+                         coefficients: &mut [i16; 64],
                          huffman: &mut HuffmanDecoder,
                          dc_table: Option<&HuffmanTable>,
                          ac_table: Option<&HuffmanTable>,
                          spectral_selection: Range<u8>,
                          successive_approximation_low: u8,
                          eob_run: &mut u16,
                          dc_predictor: &mut i16) -> Result<()> {
-    debug_assert_eq!(coefficients.len(), 64);
-
     if spectral_selection.start == 0 {
         // Section F.2.2.1
         // Figure F.12
@@ -840,14 +838,12 @@ fn decode_block<R: Read>(reader: &mut R,
 }
 
 fn decode_block_successive_approximation<R: Read>(reader: &mut R,
-                                                  coefficients: &mut [i16],
+                                                  coefficients: &mut [i16; 64],
                                                   huffman: &mut HuffmanDecoder,
                                                   ac_table: Option<&HuffmanTable>,
                                                   spectral_selection: Range<u8>,
                                                   successive_approximation_low: u8,
                                                   eob_run: &mut u16) -> Result<()> {
-    debug_assert_eq!(coefficients.len(), 64);
-
     let bit = 1 << successive_approximation_low;
 
     if spectral_selection.start == 0 {
@@ -926,13 +922,11 @@ fn decode_block_successive_approximation<R: Read>(reader: &mut R,
 }
 
 fn refine_non_zeroes<R: Read>(reader: &mut R,
-                              coefficients: &mut [i16],
+                              coefficients: &mut [i16; 64],
                               huffman: &mut HuffmanDecoder,
                               range: Range<u8>,
                               zrl: u8,
                               bit: i16) -> Result<u8> {
-    debug_assert_eq!(coefficients.len(), 64);
-
     let last = range.end - 1;
     let mut zero_run_length = zrl;
 

src/idct.rs

@@ -42,7 +42,7 @@ fn test_choose_idct_size() {
     assert_eq!(choose_idct_size(Dimensions{width: 5472, height: 3648}, Dimensions{width: 16384, height: 16384}), 8);
 }
 
-pub(crate) fn dequantize_and_idct_block(scale: usize, coefficients: &[i16], quantization_table: &[u16; 64], output_linestride: usize, output: &mut [u8]) {
+pub(crate) fn dequantize_and_idct_block(scale: usize, coefficients: &[i16; 64], quantization_table: &[u16; 64], output_linestride: usize, output: &mut [u8]) {
     match scale {
         8 => dequantize_and_idct_block_8x8(coefficients, quantization_table, output_linestride, output),
         4 => dequantize_and_idct_block_4x4(coefficients, quantization_table, output_linestride, output),
@@ -53,7 +53,7 @@ pub(crate) fn dequantize_and_idct_block(scale: usize, coefficients: &[i16], quan
 }
 
 pub fn dequantize_and_idct_block_8x8(
-    coefficients: &[i16],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     output_linestride: usize,
     output: &mut [u8]
@@ -65,7 +65,7 @@ pub fn dequantize_and_idct_block_8x8(
 
 // This is based on stb_image's 'stbi__idct_block'.
 fn dequantize_and_idct_block_8x8_inner<'a, I>(
-    coefficients: &[i16],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     output: I,
 ) where
@@ -79,9 +79,6 @@ fn dequantize_and_idct_block_8x8_inner<'a, I>(
         output.len()
     );
 
-    // optimizer hint to eliminate bounds checks within loops
-    assert!(coefficients.len() == 64);
-
     let mut temp = [Wrapping(0); 64];
 
     // columns
@@ -260,8 +257,7 @@ fn dequantize(c: i16, q: u16) -> Wrapping<i32> {
 
 // 4x4 and 2x2 IDCT based on Rakesh Dugad and Narendra Ahuja: "A Fast Scheme for Image Size Change in the Compressed Domain" (2001).
 // http://sylvana.net/jpegcrop/jidctred/
-fn dequantize_and_idct_block_4x4(coefficients: &[i16], quantization_table: &[u16; 64], output_linestride: usize, output: &mut [u8]) {
-    debug_assert_eq!(coefficients.len(), 64);
+fn dequantize_and_idct_block_4x4(coefficients: &[i16; 64], quantization_table: &[u16; 64], output_linestride: usize, output: &mut [u8]) {
     let mut temp = [Wrapping(0i32); 4 * 4];
 
     const CONST_BITS: usize = 12;
@@ -317,9 +313,7 @@ fn dequantize_and_idct_block_4x4(coefficients: &[i16], quantization_table: &[u16
     }
 }
 
-fn dequantize_and_idct_block_2x2(coefficients: &[i16], quantization_table: &[u16; 64], output_linestride: usize, output: &mut [u8]) {
-    debug_assert_eq!(coefficients.len(), 64);
-
+fn dequantize_and_idct_block_2x2(coefficients: &[i16; 64], quantization_table: &[u16; 64], output_linestride: usize, output: &mut [u8]) {
     const SCALE_BITS: usize = 3;
 
     // Column 0
@@ -348,9 +342,7 @@ fn dequantize_and_idct_block_2x2(coefficients: &[i16], quantization_table: &[u16
     output[output_linestride + 1] = stbi_clamp((x2 - x3) >> SCALE_BITS);
 }
 
-fn dequantize_and_idct_block_1x1(coefficients: &[i16], quantization_table: &[u16; 64], _output_linestride: usize, output: &mut [u8]) {
-    debug_assert_eq!(coefficients.len(), 64);
-
+fn dequantize_and_idct_block_1x1(coefficients: &[i16; 64], quantization_table: &[u16; 64], _output_linestride: usize, output: &mut [u8]) {
     let s0 = (Wrapping(coefficients[0] as i32 * quantization_table[0] as i32) + Wrapping(128 * 8)) / Wrapping(8);
     output[0] = stbi_clamp(s0);
 }

src/worker/immediate.rs

@@ -1,6 +1,7 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use core::mem;
+use core::convert::TryInto;
 use decoder::MAX_COMPONENTS;
 use error::Result;
 use idct::dequantize_and_idct_block;
@@ -46,7 +47,7 @@ impl ImmediateWorker {
             let x = (i % component.block_size.width as usize) * component.dct_scale;
             let y = (i / component.block_size.width as usize) * component.dct_scale;
 
-            let coefficients = &data[i * 64..(i + 1) * 64];
+            let coefficients = data[i * 64..(i + 1) * 64].try_into().unwrap();
             let output = &mut self.results[index][self.offsets[index] + y * line_stride + x..];
 
             dequantize_and_idct_block(component.dct_scale, coefficients, quantization_table, line_stride, output);