Set scale factor with a decoder method, rather than constructor.

Author: kevinmehall

src/decoder.rs

@@ -50,7 +50,6 @@ pub struct ImageInfo {
 /// JPEG decoder
 pub struct Decoder<R> {
     reader: R,
-    requested_size: Option<Dimensions>,
 
     frame: Option<FrameInfo>,
     dc_huffman_tables: Vec<Option<HuffmanTable>>,
@@ -71,26 +70,8 @@ pub struct Decoder<R> {
 impl<R: Read> Decoder<R> {
     /// Creates a new `Decoder` using the reader `reader`.
     pub fn new(reader: R) -> Decoder<R> {
-        Decoder::init(reader, None)
-    }
-
-    /// Creates a new `Decoder` using the reader `reader` that returns a
-    /// scaled image that is equal to or larger than the requested size in at
-    /// least one axis, or the full size of the image if the requested size is
-    /// larger.
-    /// 
-    /// This efficiently scales down the image by one of a fixed set of
-    /// available ratios during decoding. To generate a thumbnail of an
-    /// exact size, pass the desired size or larger and then scale to the
-    /// final size using a traditional resampling algorithm.
-    pub fn scaled(reader: R, requested_width: u16, requested_height: u16) -> Decoder<R> {
-        Decoder::init(reader, Some(Dimensions{ width: requested_width, height: requested_height }))
-    }
-    
-    fn init(reader: R, requested_size: Option<Dimensions>) -> Decoder<R> {
         Decoder {
             reader: reader,
-            requested_size,
             frame: None,
             dc_huffman_tables: vec![None, None, None, None],
             ac_huffman_tables: vec![None, None, None, None],
@@ -135,6 +116,23 @@ impl<R: Read> Decoder<R> {
         self.decode_internal(true).map(|_| ())
     }
 
+    /// Configure the decoder to scale the image during decoding.
+    /// 
+    /// This efficiently scales the image by the smallest supported scale
+    /// factor that produces an image larger than or equal to the requested
+    /// size in at least one axis. The currently implemented scale factors
+    /// are 1/8, 1/4, 1/2 and 1.
+    /// 
+    /// To generate a thumbnail of an exact size, pass the desired size and
+    /// then scale to the final size using a traditional resampling algorithm.
+    pub fn scale(&mut self, requested_width: u16, requested_height: u16) -> Result<(u16, u16)> {
+        self.read_info()?;
+        let frame = self.frame.as_mut().unwrap();
+        let idct_size = crate::idct::choose_idct_size(frame.image_size, Dimensions{ width: requested_width, height: requested_height });
+        frame.update_idct_size(idct_size);
+        Ok((frame.output_size.width, frame.output_size.height))
+    }
+
     /// Decodes the image and returns the decoded pixels if successful.
     pub fn decode(&mut self) -> Result<Vec<u8>> {
         self.decode_internal(false)
@@ -172,7 +170,7 @@ impl<R: Read> Decoder<R> {
                         return Err(Error::Unsupported(UnsupportedFeature::Hierarchical));
                     }
 
-                    let frame = parse_sof(&mut self.reader, marker, self.requested_size)?;
+                    let frame = parse_sof(&mut self.reader, marker)?;
                     let component_count = frame.components.len();
 
                     if frame.is_differential {

src/idct.rs

@@ -3,7 +3,7 @@
 // That's why wrapping operators are needed.
 use crate::parser::Dimensions;
 
-pub fn choose_idct_size(full_size: Dimensions, requested_size: Dimensions) -> usize {
+pub(crate) fn choose_idct_size(full_size: Dimensions, requested_size: Dimensions) -> usize {
     fn scaled(len: u16, scale: usize) -> u16 { ((len as u32 * scale as u32 - 1) / 8 + 1) as u16 }
 
     for &scale in &[1, 2, 4] {
@@ -34,7 +34,7 @@ fn test_choose_idct_size() {
     assert_eq!(choose_idct_size(Dimensions{width: 5472, height: 3648}, Dimensions{width: 16384, height: 16384}), 8);
 }
 
-pub 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], 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),

src/parser.rs

@@ -82,6 +82,21 @@ pub enum AdobeColorTransform {
     YCCK,
 }
 
+impl FrameInfo {
+    pub(crate) fn update_idct_size(&mut self, idct_size: usize) {
+        for component in &mut self.components {
+            component.dct_scale = idct_size;
+        }
+
+        update_component_sizes(self.image_size, &mut self.components);
+
+        self.output_size = Dimensions {
+            width: (self.image_size.width as f32 * idct_size as f32 / 8.0).ceil() as u16,
+            height: (self.image_size.height as f32 * idct_size as f32 / 8.0).ceil() as u16
+        };
+    }
+}
+
 fn read_length<R: Read>(reader: &mut R, marker: Marker) -> Result<usize> {
     assert!(marker.has_length());
 
@@ -107,7 +122,7 @@ fn skip_bytes<R: Read>(reader: &mut R, length: usize) -> Result<()> {
 }
 
 // Section B.2.2
-pub fn parse_sof<R: Read>(reader: &mut R, marker: Marker, requested_size: Option<Dimensions>) -> Result<FrameInfo> {
+pub fn parse_sof<R: Read>(reader: &mut R, marker: Marker) -> Result<FrameInfo> {
     let length = read_length(reader, marker)?;
 
     if length <= 6 {
@@ -159,10 +174,6 @@ pub fn parse_sof<R: Read>(reader: &mut R, marker: Marker, requested_size: Option
         return Err(Error::Format("zero width in frame header".to_owned()));
     }
 
-    let scale = if let Some(req) = requested_size {
-        crate::idct::choose_idct_size(Dimensions { width, height }, req)
-    } else { 8 };
-
     let component_count = reader.read_u8()?;
 
     if component_count == 0 {
@@ -208,38 +219,45 @@ pub fn parse_sof<R: Read>(reader: &mut R, marker: Marker, requested_size: Option
             horizontal_sampling_factor: horizontal_sampling_factor,
             vertical_sampling_factor: vertical_sampling_factor,
             quantization_table_index: quantization_table_index as usize,
-            dct_scale: scale,
+            dct_scale: 8,
             size: Dimensions {width: 0, height: 0},
             block_size: Dimensions {width: 0, height: 0},
         });
     }
 
+    let mcu_size = update_component_sizes(Dimensions { width, height }, &mut components);
+
+    Ok(FrameInfo {
+        is_baseline: is_baseline,
+        is_differential: is_differential,
+        coding_process: coding_process,
+        entropy_coding: entropy_coding,
+        precision: precision,
+        image_size: Dimensions { width, height },
+        output_size: Dimensions { width, height },
+        mcu_size,
+        components: components,
+    })
+}
+
+fn update_component_sizes(size: Dimensions, components: &mut [Component]) -> Dimensions {
     let h_max = components.iter().map(|c| c.horizontal_sampling_factor).max().unwrap();
     let v_max = components.iter().map(|c| c.vertical_sampling_factor).max().unwrap();
+
     let mcu_size = Dimensions {
-        width: (width as f32 / (h_max as f32 * 8.0)).ceil() as u16,
-        height: (height as f32 / (v_max as f32 * 8.0)).ceil() as u16,
+        width: (size.width as f32 / (h_max as f32 * 8.0)).ceil() as u16,
+        height: (size.height as f32 / (v_max as f32 * 8.0)).ceil() as u16,
     };
 
-    for component in &mut components {
-        component.size.width = (width as f32 * component.horizontal_sampling_factor as f32 * component.dct_scale as f32 / (h_max as f32 * 8.0)).ceil() as u16;
-        component.size.height = (height as f32 * component.vertical_sampling_factor as f32 * component.dct_scale as f32 / (v_max as f32 * 8.0)).ceil() as u16;
+    for component in components {
+        component.size.width = (size.width as f32 * component.horizontal_sampling_factor as f32 * component.dct_scale as f32 / (h_max as f32 * 8.0)).ceil() as u16;
+        component.size.height = (size.height as f32 * component.vertical_sampling_factor as f32 * component.dct_scale as f32 / (v_max as f32 * 8.0)).ceil() as u16;
 
         component.block_size.width = mcu_size.width * component.horizontal_sampling_factor as u16;
         component.block_size.height = mcu_size.height * component.vertical_sampling_factor as u16;
     }
 
-    Ok(FrameInfo {
-        is_baseline: is_baseline,
-        is_differential: is_differential,
-        coding_process: coding_process,
-        entropy_coding: entropy_coding,
-        precision: precision,
-        image_size: Dimensions {width: width, height: height},
-        output_size: Dimensions {width: (width as f32 * scale as f32 / 8.0).ceil() as u16, height: (height as f32 * scale as f32 / 8.0).ceil() as u16},
-        mcu_size: mcu_size,
-        components: components,
-    })
+    mcu_size
 }
 
 // Section B.2.3

tests/reftest/mod.rs

@@ -32,7 +32,9 @@ fn reftest_file(path: &Path) {
 
 fn reftest_scaled_file(path: &Path, width: u16, height: u16, ref_path: &Path) {
     let file = File::open(path).unwrap();
-    let decoder = jpeg::Decoder::scaled(file, width, height);
+    let mut decoder = jpeg::Decoder::new(file);
+    decoder.read_info().unwrap();
+    decoder.scale(width, height).unwrap();
     reftest_decoder(decoder, path, &ref_path);
 }