Merge remote-tracking branch 'origin/master' into idct-scale

Author: kevinmehall

.travis.yml

@@ -1,6 +1,6 @@
 language: rust
 rust:
-  - 1.28.0
+  - 1.34.2
   - stable
   - beta
   - nightly

README.md

@@ -32,4 +32,4 @@ fn main() {
 ```
 
 ## Requirements
-This crate compiles only with rust >= 1.28.
+This crate compiles only with rust >= 1.34.

src/decoder.rs

@@ -251,7 +251,7 @@ impl<R: Read> Decoder<R> {
                 Marker::DQT => {
                     let tables = parse_dqt(&mut self.reader)?;
 
-                    for (i, &table) in tables.into_iter().enumerate() {
+                    for (i, &table) in tables.iter().enumerate() {
                         if let Some(table) = table {
                             let mut unzigzagged_table = [0u16; 64];
 
@@ -352,23 +352,22 @@ impl<R: Read> Decoder<R> {
     }
 
     fn read_marker(&mut self) -> Result<Marker> {
-        // This should be an error as the JPEG spec doesn't allow extraneous data between marker segments.
-        // libjpeg allows this though and there are images in the wild utilising it, so we are
-        // forced to support this behavior.
-        // Sony Ericsson P990i is an example of a device which produce this sort of JPEGs.
-        while self.reader.read_u8()? != 0xFF {}
-
-        let mut byte = self.reader.read_u8()?;
-
-        // Section B.1.1.2
-        // "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code X’FF’."
-        while byte == 0xFF {
-            byte = self.reader.read_u8()?;
-        }
-
-        match byte {
-            0x00 => Err(Error::Format("FF 00 found where marker was expected".to_owned())),
-            _    => Ok(Marker::from_u8(byte).unwrap()),
+        loop {
+            // This should be an error as the JPEG spec doesn't allow extraneous data between marker segments.
+            // libjpeg allows this though and there are images in the wild utilising it, so we are
+            // forced to support this behavior.
+            // Sony Ericsson P990i is an example of a device which produce this sort of JPEGs.
+            while self.reader.read_u8()? != 0xFF {}
+
+            // Section B.1.1.2
+            // All markers are assigned two-byte codes: an X’FF’ byte followed by a
+            // byte which is not equal to 0 or X’FF’ (see Table B.1). Any marker may
+            // optionally be preceded by any number of fill bytes, which are bytes
+            // assigned code X’FF’.
+            let byte = self.reader.read_u8()?;
+            if byte != 0x00 && byte != 0xFF {
+                return Ok(Marker::from_u8(byte).unwrap());
+            }
         }
     }
 
@@ -539,7 +538,10 @@ impl<R: Read> Decoder<R> {
             }
         }
 
-        let marker = huffman.take_marker(&mut self.reader)?;
+        let mut marker = huffman.take_marker(&mut self.reader)?;
+        while let Some(Marker::RST(_)) = marker {
+            marker = self.read_marker().ok();
+        }
 
         if produce_data {
             // Retrieve all the data from the worker thread.

src/error.rs

@@ -1,8 +1,6 @@
-use std::any::Any;
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
-use std::sync::mpsc::{RecvError, SendError};
 
 pub type Result<T> = ::std::result::Result<T, Error>;
 
@@ -41,7 +39,7 @@ pub enum Error {
     /// An I/O error occurred while decoding the image.
     Io(IoError),
     /// An internal error occurred while decoding the image.
-    Internal(Box<dyn StdError>),
+    Internal(Box<dyn StdError + Send + Sync + 'static>), //TODO: not used, can be removed with the next version bump
 }
 
 impl fmt::Display for Error {
@@ -79,15 +77,3 @@ impl From<IoError> for Error {
         Error::Io(err)
     }
 }
-
-impl From<RecvError> for Error {
-    fn from(err: RecvError) -> Error {
-        Error::Internal(Box::new(err))
-    }
-}
-
-impl<T: Any + Send> From<SendError<T>> for Error {
-    fn from(err: SendError<T>) -> Error {
-        Error::Internal(Box::new(err))
-    }
-}

src/marker.rs

@@ -132,7 +132,6 @@ impl Marker {
             0xFD => Some(JPGn(13)),
             0xFE => Some(COM),
             0xFF => None, // Fill byte
-            _ => unreachable!(),
         }
     }
 }

src/worker/threaded.rs

@@ -40,14 +40,14 @@ impl Worker for ThreadedWorker {
         Ok(ThreadedWorker { sender: tx })
     }
     fn start(&mut self, row_data: RowData) -> Result<()> {
-        Ok(self.sender.send(WorkerMsg::Start(row_data))?)
+        Ok(self.sender.send(WorkerMsg::Start(row_data)).expect("jpeg-decoder worker thread error"))
     }
     fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> {
-        Ok(self.sender.send(WorkerMsg::AppendRow(row))?)
+        Ok(self.sender.send(WorkerMsg::AppendRow(row)).expect("jpeg-decoder worker thread error"))
     }
     fn get_result(&mut self, index: usize) -> Result<Vec<u8>> {
         let (tx, rx) = mpsc::channel();
-        self.sender.send(WorkerMsg::GetResult((index, tx)))?;
-        Ok(rx.recv()?)
+        self.sender.send(WorkerMsg::GetResult((index, tx))).expect("jpeg-decoder worker thread error");
+        Ok(rx.recv().expect("jpeg-decoder worker thread error"))
     }
 }

tests/crashtest/images/README.md

@@ -5,3 +5,4 @@ imagetestsuite/           | The files in this directory were taken from https://
 dc-predictor-overflow.jpg | Found by Wim Looman (@Nemo157) while fuzzing
 derive-huffman-codes-overflow.jpg | Found by Pascal Hertleif (@killercup) while fuzzing
 missing-sof.jpg           | Found by Corey Farwell (@frewsxcv) when fuzz testing
+extraneous-bytes-after-sos.jpg | Scan from brother DSmobile 920DW provided by Filip Lundborg (@filipl)