Merge remote-tracking branch 'origin/master' into HEAD

Author: 197g

src/decoder.rs

@@ -803,8 +803,8 @@ impl<R: Read> Decoder<R> {
                                     (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(
@@ -900,7 +900,7 @@ 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>,
@@ -988,7 +988,7 @@ fn decode_block<R: Read>(
 
 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>,
@@ -1074,7 +1074,7 @@ fn decode_block_successive_approximation<R: Read>(
 
 fn refine_non_zeroes<R: Read>(
     reader: &mut R,
-    coefficients: &mut [i16],
+    coefficients: &mut [i16; 64],
     huffman: &mut HuffmanDecoder,
     range: Range<u8>,
     zrl: u8,

src/idct.rs

@@ -204,7 +204,7 @@ fn test_choose_idct_size() {
 
 pub(crate) fn dequantize_and_idct_block(
     scale: usize,
-    coefficients: &[i16],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     output_linestride: usize,
     output: &mut [u8],
@@ -239,7 +239,7 @@ pub(crate) fn dequantize_and_idct_block(
 }
 
 pub fn dequantize_and_idct_block_8x8(
-    coefficients: &[i16],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     output_linestride: usize,
     output: &mut [u8],
@@ -258,7 +258,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
@@ -272,9 +272,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
@@ -338,6 +335,9 @@ fn dequantize_and_idct_block_8x8_inner<'a, I>(
         // to encode as 0..255 by adding 128, so we'll add that before the shift
         const X_SCALE: i32 = 65536 + (128 << 17);
 
+        // eliminate downstream bounds checks
+        let output_chunk = &mut output_chunk[..8];
+
         // TODO When the minimum rust version supports it
         // let [s0, rest @ ..] = chunk;
         let (s0, rest) = chunk.split_first().unwrap();
@@ -454,7 +454,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],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     output_linestride: usize,
     output: &mut [u8],
@@ -516,7 +516,7 @@ fn dequantize_and_idct_block_4x4(
 }
 
 fn dequantize_and_idct_block_2x2(
-    coefficients: &[i16],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     output_linestride: usize,
     output: &mut [u8],
@@ -552,15 +552,14 @@ fn dequantize_and_idct_block_2x2(
 }
 
 fn dequantize_and_idct_block_1x1(
-    coefficients: &[i16],
+    coefficients: &[i16; 64],
     quantization_table: &[u16; 64],
     _output_linestride: usize,
     output: &mut [u8],
 ) {
     debug_assert_eq!(coefficients.len(), 64);
 
-    let s0 = (Wrapping(coefficients[0] as i32 * quantization_table[0] as i32) + Wrapping(128 * 8))
-        / Wrapping(8);
+    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);

src/worker/mod.rs

@@ -1,10 +1,9 @@
 mod immediate;
-#[cfg(feature = "std")]
 mod multithreaded;
 
-#[cfg(all(feature = "std", not(any(target_arch = "asmjs", target_arch = "wasm32"))))]
+#[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))]
 pub use self::multithreaded::MultiThreadedWorker as PlatformWorker;
-#[cfg(any(not(feature = "std"), target_arch = "asmjs", target_arch = "wasm32"))]
+#[cfg(any(target_arch = "asmjs", target_arch = "wasm32"))]
 pub use self::immediate::ImmediateWorker as PlatformWorker;
 
 use alloc::sync::Arc;

src/worker/multithreaded.rs

@@ -6,8 +6,7 @@
 
 use decoder::MAX_COMPONENTS;
 use error::Result;
-use std::{mem, sync::mpsc::{self, Sender}};
-use std::thread;
+use std::{mem, io, sync::mpsc::{self, Sender}};
 use super::{RowData, Worker};
 use super::immediate::ImmediateWorker;
 
@@ -57,10 +56,9 @@ impl Worker for MultiThreadedWorker {
 }
 
 fn spawn_worker_thread(component: usize) -> Result<Sender<WorkerMsg>> {
-    let thread_builder = thread::Builder::new().name(format!("worker thread for component {}", component));
     let (tx, rx) = mpsc::channel();
 
-    thread_builder.spawn(move || {
+    spawn(component, move || {
         let mut worker = ImmediateWorker::new_immediate();
 
         while let Ok(message) = rx.recv() {
@@ -84,4 +82,24 @@ fn spawn_worker_thread(component: usize) -> Result<Sender<WorkerMsg>> {
     })?;
 
     Ok(tx)
-}
+}
+
+#[cfg(feature = "rayon")]
+fn spawn<F>(_component: usize, func: F) -> io::Result<()>
+where
+    F: FnOnce() + Send + 'static,
+{
+    rayon::spawn(func);
+    Ok(())
+}
+
+#[cfg(not(feature = "rayon"))]
+fn spawn<F>(component: usize, func: F) -> io::Result<()>
+where
+    F: FnOnce() + Send + 'static,
+{
+    let thread_builder =
+        std::thread::Builder::new().name(format!("worker thread for component {}", component));
+    thread_builder.spawn(func)?;
+    Ok(())
+}