Merge pull request #150 from lovasoa/optimize_compute_image

Optimize final grayscale image creation

Author: HeroicKatora

benches/decoding_benchmark.rs

@@ -26,6 +26,10 @@ fn main() {
         read_image(include_bytes!("tower_progressive.jpg"))
     }));
 
+    c.bench_function("decode a 512x512 grayscale JPEG", |b| b.iter(|| {
+        read_image(include_bytes!("tower_grayscale.jpg"))
+    }));
+
     c.bench_function("extract metadata from an image", |b| b.iter(|| {
         read_metadata(include_bytes!("tower.jpg"))
     }));

benches/tower_grayscale.jpg

@@ -346,7 +346,7 @@ impl<R: Read> Decoder<R> {
         }
 
         let frame = self.frame.as_ref().unwrap();
-        compute_image(&frame.components, &planes, frame.output_size, self.is_jfif, self.color_transform)
+        compute_image(&frame.components, planes, frame.output_size, self.is_jfif, self.color_transform)
     }
 
     fn read_marker(&mut self) -> Result<Marker> {
@@ -766,7 +766,7 @@ fn refine_non_zeroes<R: Read>(reader: &mut R,
 }
 
 fn compute_image(components: &[Component],
-                 data: &[Vec<u8>],
+                 mut data: Vec<Vec<u8>>,
                  output_size: Dimensions,
                  is_jfif: bool,
                  color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
@@ -776,29 +776,29 @@ fn compute_image(components: &[Component],
 
     if components.len() == 1 {
         let component = &components[0];
-        let decoded = &data[0];
+        let mut decoded: Vec<u8> = data.remove(0);
 
         let width = component.size.width as usize;
         let height = component.size.height as usize;
         let size = width * height;
-
-        // if the image size is a multiple of the block size
-        if decoded.len() == size {
-            return Ok(decoded.to_vec())
-        }
-
-        let mut buffer = vec![0u8; size];
         let line_stride = component.block_size.width as usize * component.dct_scale;
 
-        for y in 0..height {
-            let destination_idx = y * width;
-            let source_idx = y * line_stride;
-            let destination = &mut buffer[destination_idx..][..width];
-            let source = &decoded[source_idx..][..width];
-            destination.copy_from_slice(source);
+        // if the image width is a multiple of the block size,
+        // then we don't have to move bytes in the decoded data
+        if usize::from(output_size.width) != line_stride {
+            let mut buffer = vec![0u8; width];
+            // The first line already starts at index 0, so we need to move only lines 1..height
+            for y in 1..height {
+                let destination_idx = y * width;
+                let source_idx = y * line_stride;
+                // We could use copy_within, but we need to support old rust versions
+                buffer.copy_from_slice(&decoded[source_idx..][..width]);
+                let destination = &mut decoded[destination_idx..][..width];
+                destination.copy_from_slice(&buffer);
+            }
         }
-
-        Ok(buffer)
+        decoded.resize(size, 0);
+        Ok(decoded)
     }
     else {
         compute_image_parallel(components, data, output_size, is_jfif, color_transform)
@@ -807,10 +807,10 @@ fn compute_image(components: &[Component],
 
 #[cfg(feature="rayon")]
 fn compute_image_parallel(components: &[Component],
-                 data: &[Vec<u8>],
-                 output_size: Dimensions,
-                 is_jfif: bool,
-                 color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
+                          data: Vec<Vec<u8>>,
+                          output_size: Dimensions,
+                          is_jfif: bool,
+                          color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
     use rayon::prelude::*;
 
     let color_convert_func = choose_color_convert_func(components.len(), is_jfif, color_transform)?;
@@ -822,7 +822,7 @@ fn compute_image_parallel(components: &[Component],
          .with_max_len(1)
          .enumerate()
          .for_each(|(row, line)| {
-             upsampler.upsample_and_interleave_row(data, row, output_size.width as usize, line);
+             upsampler.upsample_and_interleave_row(&data, row, output_size.width as usize, line);
              color_convert_func(line, output_size.width as usize);
          });
 
@@ -831,18 +831,18 @@ fn compute_image_parallel(components: &[Component],
 
 #[cfg(not(feature="rayon"))]
 fn compute_image_parallel(components: &[Component],
-                 data: &[Vec<u8>],
-                 output_size: Dimensions,
-                 is_jfif: bool,
-                 color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
+                          data: Vec<Vec<u8>>,
+                          output_size: Dimensions,
+                          is_jfif: bool,
+                          color_transform: Option<AdobeColorTransform>) -> Result<Vec<u8>> {
     let color_convert_func = choose_color_convert_func(components.len(), is_jfif, color_transform)?;
     let upsampler = Upsampler::new(components, output_size.width, output_size.height)?;
     let line_size = output_size.width as usize * components.len();
     let mut image = vec![0u8; line_size * output_size.height as usize];
 
     for (row, line) in image.chunks_mut(line_size)
          .enumerate() {
-             upsampler.upsample_and_interleave_row(data, row, output_size.width as usize, line);
+             upsampler.upsample_and_interleave_row(&data, row, output_size.width as usize, line);
              color_convert_func(line, output_size.width as usize);
          }