Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 1074 insertions, 0 deletions

diff --git a/vendor/image/src/codecs/jpeg/encoder.rs b/vendor/image/src/codecs/jpeg/encoder.rs
new file mode 100644
index 0000000..edb2a05
--- /dev/null
+++ b/vendor/image/src/codecs/jpeg/encoder.rs
@@ -0,0 +1,1074 @@
+#![allow(clippy::too_many_arguments)]
+
+use std::borrow::Cow;
+use std::convert::TryFrom;
+use std::io::{self, Write};
+
+use crate::error::{
+    ImageError, ImageResult, ParameterError, ParameterErrorKind, UnsupportedError,
+    UnsupportedErrorKind,
+};
+use crate::image::{ImageEncoder, ImageFormat};
+use crate::utils::clamp;
+use crate::{ColorType, GenericImageView, ImageBuffer, Luma, LumaA, Pixel, Rgb, Rgba};
+
+use super::entropy::build_huff_lut_const;
+use super::transform;
+use crate::traits::PixelWithColorType;
+
+// Markers
+// Baseline DCT
+static SOF0: u8 = 0xC0;
+// Huffman Tables
+static DHT: u8 = 0xC4;
+// Start of Image (standalone)
+static SOI: u8 = 0xD8;
+// End of image (standalone)
+static EOI: u8 = 0xD9;
+// Start of Scan
+static SOS: u8 = 0xDA;
+// Quantization Tables
+static DQT: u8 = 0xDB;
+// Application segments start and end
+static APP0: u8 = 0xE0;
+
+// section K.1
+// table K.1
+#[rustfmt::skip]
+static STD_LUMA_QTABLE: [u8; 64] = [
+    16, 11, 10, 16,  24,  40,  51,  61,
+    12, 12, 14, 19,  26,  58,  60,  55,
+    14, 13, 16, 24,  40,  57,  69,  56,
+    14, 17, 22, 29,  51,  87,  80,  62,
+    18, 22, 37, 56,  68, 109, 103,  77,
+    24, 35, 55, 64,  81, 104, 113,  92,
+    49, 64, 78, 87, 103, 121, 120, 101,
+    72, 92, 95, 98, 112, 100, 103,  99,
+];
+
+// table K.2
+#[rustfmt::skip]
+static STD_CHROMA_QTABLE: [u8; 64] = [
+    17, 18, 24, 47, 99, 99, 99, 99,
+    18, 21, 26, 66, 99, 99, 99, 99,
+    24, 26, 56, 99, 99, 99, 99, 99,
+    47, 66, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99,
+];
+
+// section K.3
+// Code lengths and values for table K.3
+static STD_LUMA_DC_CODE_LENGTHS: [u8; 16] = [
+    0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+];
+
+static STD_LUMA_DC_VALUES: [u8; 12] = [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
+];
+
+static STD_LUMA_DC_HUFF_LUT: [(u8, u16); 256] =
+    build_huff_lut_const(&STD_LUMA_DC_CODE_LENGTHS, &STD_LUMA_DC_VALUES);
+
+// Code lengths and values for table K.4
+static STD_CHROMA_DC_CODE_LENGTHS: [u8; 16] = [
+    0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+];
+
+static STD_CHROMA_DC_VALUES: [u8; 12] = [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
+];
+
+static STD_CHROMA_DC_HUFF_LUT: [(u8, u16); 256] =
+    build_huff_lut_const(&STD_CHROMA_DC_CODE_LENGTHS, &STD_CHROMA_DC_VALUES);
+
+// Code lengths and values for table k.5
+static STD_LUMA_AC_CODE_LENGTHS: [u8; 16] = [
+    0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D,
+];
+
+static STD_LUMA_AC_VALUES: [u8; 162] = [
+    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
+    0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
+    0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+    0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+    0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+    0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
+    0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
+    0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
+    0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
+    0xF9, 0xFA,
+];
+
+static STD_LUMA_AC_HUFF_LUT: [(u8, u16); 256] =
+    build_huff_lut_const(&STD_LUMA_AC_CODE_LENGTHS, &STD_LUMA_AC_VALUES);
+
+// Code lengths and values for table k.6
+static STD_CHROMA_AC_CODE_LENGTHS: [u8; 16] = [
+    0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77,
+];
+static STD_CHROMA_AC_VALUES: [u8; 162] = [
+    0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+    0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
+    0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
+    0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+    0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+    0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
+    0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
+    0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
+    0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
+    0xF9, 0xFA,
+];
+
+static STD_CHROMA_AC_HUFF_LUT: [(u8, u16); 256] =
+    build_huff_lut_const(&STD_CHROMA_AC_CODE_LENGTHS, &STD_CHROMA_AC_VALUES);
+
+static DCCLASS: u8 = 0;
+static ACCLASS: u8 = 1;
+
+static LUMADESTINATION: u8 = 0;
+static CHROMADESTINATION: u8 = 1;
+
+static LUMAID: u8 = 1;
+static CHROMABLUEID: u8 = 2;
+static CHROMAREDID: u8 = 3;
+
+/// The permutation of dct coefficients.
+#[rustfmt::skip]
+static UNZIGZAG: [u8; 64] = [
+     0,  1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63,
+];
+
+/// A representation of a JPEG component
+#[derive(Copy, Clone)]
+struct Component {
+    /// The Component's identifier
+    id: u8,
+
+    /// Horizontal sampling factor
+    h: u8,
+
+    /// Vertical sampling factor
+    v: u8,
+
+    /// The quantization table selector
+    tq: u8,
+
+    /// Index to the Huffman DC Table
+    dc_table: u8,
+
+    /// Index to the AC Huffman Table
+    ac_table: u8,
+
+    /// The dc prediction of the component
+    _dc_pred: i32,
+}
+
+pub(crate) struct BitWriter<W> {
+    w: W,
+    accumulator: u32,
+    nbits: u8,
+}
+
+impl<W: Write> BitWriter<W> {
+    fn new(w: W) -> Self {
+        BitWriter {
+            w,
+            accumulator: 0,
+            nbits: 0,
+        }
+    }
+
+    fn write_bits(&mut self, bits: u16, size: u8) -> io::Result<()> {
+        if size == 0 {
+            return Ok(());
+        }
+
+        self.nbits += size;
+        self.accumulator |= u32::from(bits) << (32 - self.nbits) as usize;
+
+        while self.nbits >= 8 {
+            let byte = self.accumulator >> 24;
+            self.w.write_all(&[byte as u8])?;
+
+            if byte == 0xFF {
+                self.w.write_all(&[0x00])?;
+            }
+
+            self.nbits -= 8;
+            self.accumulator <<= 8;
+        }
+
+        Ok(())
+    }
+
+    fn pad_byte(&mut self) -> io::Result<()> {
+        self.write_bits(0x7F, 7)
+    }
+
+    fn huffman_encode(&mut self, val: u8, table: &[(u8, u16); 256]) -> io::Result<()> {
+        let (size, code) = table[val as usize];
+
+        if size > 16 {
+            panic!("bad huffman value");
+        }
+
+        self.write_bits(code, size)
+    }
+
+    fn write_block(
+        &mut self,
+        block: &[i32; 64],
+        prevdc: i32,
+        dctable: &[(u8, u16); 256],
+        actable: &[(u8, u16); 256],
+    ) -> io::Result<i32> {
+        // Differential DC encoding
+        let dcval = block[0];
+        let diff = dcval - prevdc;
+        let (size, value) = encode_coefficient(diff);
+
+        self.huffman_encode(size, dctable)?;
+        self.write_bits(value, size)?;
+
+        // Figure F.2
+        let mut zero_run = 0;
+
+        for &k in &UNZIGZAG[1..] {
+            if block[k as usize] == 0 {
+                zero_run += 1;
+            } else {
+                while zero_run > 15 {
+                    self.huffman_encode(0xF0, actable)?;
+                    zero_run -= 16;
+                }
+
+                let (size, value) = encode_coefficient(block[k as usize]);
+                let symbol = (zero_run << 4) | size;
+
+                self.huffman_encode(symbol, actable)?;
+                self.write_bits(value, size)?;
+
+                zero_run = 0;
+            }
+        }
+
+        if block[UNZIGZAG[63] as usize] == 0 {
+            self.huffman_encode(0x00, actable)?;
+        }
+
+        Ok(dcval)
+    }
+
+    fn write_marker(&mut self, marker: u8) -> io::Result<()> {
+        self.w.write_all(&[0xFF, marker])
+    }
+
+    fn write_segment(&mut self, marker: u8, data: &[u8]) -> io::Result<()> {
+        self.w.write_all(&[0xFF, marker])?;
+        self.w.write_all(&(data.len() as u16 + 2).to_be_bytes())?;
+        self.w.write_all(data)
+    }
+}
+
+/// Represents a unit in which the density of an image is measured
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PixelDensityUnit {
+    /// Represents the absence of a unit, the values indicate only a
+    /// [pixel aspect ratio](https://en.wikipedia.org/wiki/Pixel_aspect_ratio)
+    PixelAspectRatio,
+
+    /// Pixels per inch (2.54 cm)
+    Inches,
+
+    /// Pixels per centimeter
+    Centimeters,
+}
+
+/// Represents the pixel density of an image
+///
+/// For example, a 300 DPI image is represented by:
+///
+/// ```rust
+/// use image::codecs::jpeg::*;
+/// let hdpi = PixelDensity::dpi(300);
+/// assert_eq!(hdpi, PixelDensity {density: (300,300), unit: PixelDensityUnit::Inches})
+/// ```
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PixelDensity {
+    /// A couple of values for (Xdensity, Ydensity)
+    pub density: (u16, u16),
+    /// The unit in which the density is measured
+    pub unit: PixelDensityUnit,
+}
+
+impl PixelDensity {
+    /// Creates the most common pixel density type:
+    /// the horizontal and the vertical density are equal,
+    /// and measured in pixels per inch.
+    pub fn dpi(density: u16) -> Self {
+        PixelDensity {
+            density: (density, density),
+            unit: PixelDensityUnit::Inches,
+        }
+    }
+}
+
+impl Default for PixelDensity {
+    /// Returns a pixel density with a pixel aspect ratio of 1
+    fn default() -> Self {
+        PixelDensity {
+            density: (1, 1),
+            unit: PixelDensityUnit::PixelAspectRatio,
+        }
+    }
+}
+
+/// The representation of a JPEG encoder
+pub struct JpegEncoder<W> {
+    writer: BitWriter<W>,
+
+    components: Vec<Component>,
+    tables: Vec<[u8; 64]>,
+
+    luma_dctable: Cow<'static, [(u8, u16); 256]>,
+    luma_actable: Cow<'static, [(u8, u16); 256]>,
+    chroma_dctable: Cow<'static, [(u8, u16); 256]>,
+    chroma_actable: Cow<'static, [(u8, u16); 256]>,
+
+    pixel_density: PixelDensity,
+}
+
+impl<W: Write> JpegEncoder<W> {
+    /// Create a new encoder that writes its output to ```w```
+    pub fn new(w: W) -> JpegEncoder<W> {
+        JpegEncoder::new_with_quality(w, 75)
+    }
+
+    /// Create a new encoder that writes its output to ```w```, and has
+    /// the quality parameter ```quality``` with a value in the range 1-100
+    /// where 1 is the worst and 100 is the best.
+    pub fn new_with_quality(w: W, quality: u8) -> JpegEncoder<W> {
+        let components = vec![
+            Component {
+                id: LUMAID,
+                h: 1,
+                v: 1,
+                tq: LUMADESTINATION,
+                dc_table: LUMADESTINATION,
+                ac_table: LUMADESTINATION,
+                _dc_pred: 0,
+            },
+            Component {
+                id: CHROMABLUEID,
+                h: 1,
+                v: 1,
+                tq: CHROMADESTINATION,
+                dc_table: CHROMADESTINATION,
+                ac_table: CHROMADESTINATION,
+                _dc_pred: 0,
+            },
+            Component {
+                id: CHROMAREDID,
+                h: 1,
+                v: 1,
+                tq: CHROMADESTINATION,
+                dc_table: CHROMADESTINATION,
+                ac_table: CHROMADESTINATION,
+                _dc_pred: 0,
+            },
+        ];
+
+        // Derive our quantization table scaling value using the libjpeg algorithm
+        let scale = u32::from(clamp(quality, 1, 100));
+        let scale = if scale < 50 {
+            5000 / scale
+        } else {
+            200 - scale * 2
+        };
+
+        let mut tables = vec![STD_LUMA_QTABLE, STD_CHROMA_QTABLE];
+        tables.iter_mut().for_each(|t| {
+            t.iter_mut().for_each(|v| {
+                *v = clamp(
+                    (u32::from(*v) * scale + 50) / 100,
+                    1,
+                    u32::from(u8::max_value()),
+                ) as u8;
+            })
+        });
+
+        JpegEncoder {
+            writer: BitWriter::new(w),
+
+            components,
+            tables,
+
+            luma_dctable: Cow::Borrowed(&STD_LUMA_DC_HUFF_LUT),
+            luma_actable: Cow::Borrowed(&STD_LUMA_AC_HUFF_LUT),
+            chroma_dctable: Cow::Borrowed(&STD_CHROMA_DC_HUFF_LUT),
+            chroma_actable: Cow::Borrowed(&STD_CHROMA_AC_HUFF_LUT),
+
+            pixel_density: PixelDensity::default(),
+        }
+    }
+
+    /// Set the pixel density of the images the encoder will encode.
+    /// If this method is not called, then a default pixel aspect ratio of 1x1 will be applied,
+    /// and no DPI information will be stored in the image.
+    pub fn set_pixel_density(&mut self, pixel_density: PixelDensity) {
+        self.pixel_density = pixel_density;
+    }
+
+    /// Encodes the image stored in the raw byte buffer ```image```
+    /// that has dimensions ```width``` and ```height```
+    /// and ```ColorType``` ```c```
+    ///
+    /// The Image in encoded with subsampling ratio 4:2:2
+    pub fn encode(
+        &mut self,
+        image: &[u8],
+        width: u32,
+        height: u32,
+        color_type: ColorType,
+    ) -> ImageResult<()> {
+        match color_type {
+            ColorType::L8 => {
+                let image: ImageBuffer<Luma<_>, _> =
+                    ImageBuffer::from_raw(width, height, image).unwrap();
+                self.encode_image(&image)
+            }
+            ColorType::La8 => {
+                let image: ImageBuffer<LumaA<_>, _> =
+                    ImageBuffer::from_raw(width, height, image).unwrap();
+                self.encode_image(&image)
+            }
+            ColorType::Rgb8 => {
+                let image: ImageBuffer<Rgb<_>, _> =
+                    ImageBuffer::from_raw(width, height, image).unwrap();
+                self.encode_image(&image)
+            }
+            ColorType::Rgba8 => {
+                let image: ImageBuffer<Rgba<_>, _> =
+                    ImageBuffer::from_raw(width, height, image).unwrap();
+                self.encode_image(&image)
+            }
+            _ => Err(ImageError::Unsupported(
+                UnsupportedError::from_format_and_kind(
+                    ImageFormat::Jpeg.into(),
+                    UnsupportedErrorKind::Color(color_type.into()),
+                ),
+            )),
+        }
+    }
+
+    /// Encodes the given image.
+    ///
+    /// As a special feature this does not require the whole image to be present in memory at the
+    /// same time such that it may be computed on the fly, which is why this method exists on this
+    /// encoder but not on others. Instead the encoder will iterate over 8-by-8 blocks of pixels at
+    /// a time, inspecting each pixel exactly once. You can rely on this behaviour when calling
+    /// this method.
+    ///
+    /// The Image in encoded with subsampling ratio 4:2:2
+    pub fn encode_image<I: GenericImageView>(&mut self, image: &I) -> ImageResult<()>
+    where
+        I::Pixel: PixelWithColorType,
+    {
+        let n = I::Pixel::CHANNEL_COUNT;
+        let color_type = I::Pixel::COLOR_TYPE;
+        let num_components = if n == 1 || n == 2 { 1 } else { 3 };
+
+        self.writer.write_marker(SOI)?;
+
+        let mut buf = Vec::new();
+
+        build_jfif_header(&mut buf, self.pixel_density);
+        self.writer.write_segment(APP0, &buf)?;
+
+        build_frame_header(
+            &mut buf,
+            8,
+            // TODO: not idiomatic yet. Should be an EncodingError and mention jpg. Further it
+            // should check dimensions prior to writing.
+            u16::try_from(image.width()).map_err(|_| {
+                ImageError::Parameter(ParameterError::from_kind(
+                    ParameterErrorKind::DimensionMismatch,
+                ))
+            })?,
+            u16::try_from(image.height()).map_err(|_| {
+                ImageError::Parameter(ParameterError::from_kind(
+                    ParameterErrorKind::DimensionMismatch,
+                ))
+            })?,
+            &self.components[..num_components],
+        );
+        self.writer.write_segment(SOF0, &buf)?;
+
+        assert_eq!(self.tables.len(), 2);
+        let numtables = if num_components == 1 { 1 } else { 2 };
+
+        for (i, table) in self.tables[..numtables].iter().enumerate() {
+            build_quantization_segment(&mut buf, 8, i as u8, table);
+            self.writer.write_segment(DQT, &buf)?;
+        }
+
+        build_huffman_segment(
+            &mut buf,
+            DCCLASS,
+            LUMADESTINATION,
+            &STD_LUMA_DC_CODE_LENGTHS,
+            &STD_LUMA_DC_VALUES,
+        );
+        self.writer.write_segment(DHT, &buf)?;
+
+        build_huffman_segment(
+            &mut buf,
+            ACCLASS,
+            LUMADESTINATION,
+            &STD_LUMA_AC_CODE_LENGTHS,
+            &STD_LUMA_AC_VALUES,
+        );
+        self.writer.write_segment(DHT, &buf)?;
+
+        if num_components == 3 {
+            build_huffman_segment(
+                &mut buf,
+                DCCLASS,
+                CHROMADESTINATION,
+                &STD_CHROMA_DC_CODE_LENGTHS,
+                &STD_CHROMA_DC_VALUES,
+            );
+            self.writer.write_segment(DHT, &buf)?;
+
+            build_huffman_segment(
+                &mut buf,
+                ACCLASS,
+                CHROMADESTINATION,
+                &STD_CHROMA_AC_CODE_LENGTHS,
+                &STD_CHROMA_AC_VALUES,
+            );
+            self.writer.write_segment(DHT, &buf)?;
+        }
+
+        build_scan_header(&mut buf, &self.components[..num_components]);
+        self.writer.write_segment(SOS, &buf)?;
+
+        if color_type.has_color() {
+            self.encode_rgb(image)
+        } else {
+            self.encode_gray(image)
+        }?;
+
+        self.writer.pad_byte()?;
+        self.writer.write_marker(EOI)?;
+        Ok(())
+    }
+
+    fn encode_gray<I: GenericImageView>(&mut self, image: &I) -> io::Result<()> {
+        let mut yblock = [0u8; 64];
+        let mut y_dcprev = 0;
+        let mut dct_yblock = [0i32; 64];
+
+        for y in (0..image.height()).step_by(8) {
+            for x in (0..image.width()).step_by(8) {
+                copy_blocks_gray(image, x, y, &mut yblock);
+
+                // Level shift and fdct
+                // Coeffs are scaled by 8
+                transform::fdct(&yblock, &mut dct_yblock);
+
+                // Quantization
+                for (i, dct) in dct_yblock.iter_mut().enumerate() {
+                    *dct = ((*dct / 8) as f32 / f32::from(self.tables[0][i])).round() as i32;
+                }
+
+                let la = &*self.luma_actable;
+                let ld = &*self.luma_dctable;
+
+                y_dcprev = self.writer.write_block(&dct_yblock, y_dcprev, ld, la)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn encode_rgb<I: GenericImageView>(&mut self, image: &I) -> io::Result<()> {
+        let mut y_dcprev = 0;
+        let mut cb_dcprev = 0;
+        let mut cr_dcprev = 0;
+
+        let mut dct_yblock = [0i32; 64];
+        let mut dct_cb_block = [0i32; 64];
+        let mut dct_cr_block = [0i32; 64];
+
+        let mut yblock = [0u8; 64];
+        let mut cb_block = [0u8; 64];
+        let mut cr_block = [0u8; 64];
+
+        for y in (0..image.height()).step_by(8) {
+            for x in (0..image.width()).step_by(8) {
+                // RGB -> YCbCr
+                copy_blocks_ycbcr(image, x, y, &mut yblock, &mut cb_block, &mut cr_block);
+
+                // Level shift and fdct
+                // Coeffs are scaled by 8
+                transform::fdct(&yblock, &mut dct_yblock);
+                transform::fdct(&cb_block, &mut dct_cb_block);
+                transform::fdct(&cr_block, &mut dct_cr_block);
+
+                // Quantization
+                for i in 0usize..64 {
+                    dct_yblock[i] =
+                        ((dct_yblock[i] / 8) as f32 / f32::from(self.tables[0][i])).round() as i32;
+                    dct_cb_block[i] = ((dct_cb_block[i] / 8) as f32 / f32::from(self.tables[1][i]))
+                        .round() as i32;
+                    dct_cr_block[i] = ((dct_cr_block[i] / 8) as f32 / f32::from(self.tables[1][i]))
+                        .round() as i32;
+                }
+
+                let la = &*self.luma_actable;
+                let ld = &*self.luma_dctable;
+                let cd = &*self.chroma_dctable;
+                let ca = &*self.chroma_actable;
+
+                y_dcprev = self.writer.write_block(&dct_yblock, y_dcprev, ld, la)?;
+                cb_dcprev = self.writer.write_block(&dct_cb_block, cb_dcprev, cd, ca)?;
+                cr_dcprev = self.writer.write_block(&dct_cr_block, cr_dcprev, cd, ca)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<W: Write> ImageEncoder for JpegEncoder<W> {
+    fn write_image(
+        mut self,
+        buf: &[u8],
+        width: u32,
+        height: u32,
+        color_type: ColorType,
+    ) -> ImageResult<()> {
+        self.encode(buf, width, height, color_type)
+    }
+}
+
+fn build_jfif_header(m: &mut Vec<u8>, density: PixelDensity) {
+    m.clear();
+    m.extend_from_slice(b"JFIF");
+    m.extend_from_slice(&[
+        0,
+        0x01,
+        0x02,
+        match density.unit {
+            PixelDensityUnit::PixelAspectRatio => 0x00,
+            PixelDensityUnit::Inches => 0x01,
+            PixelDensityUnit::Centimeters => 0x02,
+        },
+    ]);
+    m.extend_from_slice(&density.density.0.to_be_bytes());
+    m.extend_from_slice(&density.density.1.to_be_bytes());
+    m.extend_from_slice(&[0, 0]);
+}
+
+fn build_frame_header(
+    m: &mut Vec<u8>,
+    precision: u8,
+    width: u16,
+    height: u16,
+    components: &[Component],
+) {
+    m.clear();
+
+    m.push(precision);
+    m.extend_from_slice(&height.to_be_bytes());
+    m.extend_from_slice(&width.to_be_bytes());
+    m.push(components.len() as u8);
+
+    for &comp in components.iter() {
+        let hv = (comp.h << 4) | comp.v;
+        m.extend_from_slice(&[comp.id, hv, comp.tq]);
+    }
+}
+
+fn build_scan_header(m: &mut Vec<u8>, components: &[Component]) {
+    m.clear();
+
+    m.push(components.len() as u8);
+
+    for &comp in components.iter() {
+        let tables = (comp.dc_table << 4) | comp.ac_table;
+        m.extend_from_slice(&[comp.id, tables]);
+    }
+
+    // spectral start and end, approx. high and low
+    m.extend_from_slice(&[0, 63, 0]);
+}
+
+fn build_huffman_segment(
+    m: &mut Vec<u8>,
+    class: u8,
+    destination: u8,
+    numcodes: &[u8; 16],
+    values: &[u8],
+) {
+    m.clear();
+
+    let tcth = (class << 4) | destination;
+    m.push(tcth);
+
+    m.extend_from_slice(numcodes);
+
+    let sum: usize = numcodes.iter().map(|&x| x as usize).sum();
+
+    assert_eq!(sum, values.len());
+
+    m.extend_from_slice(values);
+}
+
+fn build_quantization_segment(m: &mut Vec<u8>, precision: u8, identifier: u8, qtable: &[u8; 64]) {
+    m.clear();
+
+    let p = if precision == 8 { 0 } else { 1 };
+
+    let pqtq = (p << 4) | identifier;
+    m.push(pqtq);
+
+    for &i in &UNZIGZAG[..] {
+        m.push(qtable[i as usize]);
+    }
+}
+
+fn encode_coefficient(coefficient: i32) -> (u8, u16) {
+    let mut magnitude = coefficient.unsigned_abs() as u16;
+    let mut num_bits = 0u8;
+
+    while magnitude > 0 {
+        magnitude >>= 1;
+        num_bits += 1;
+    }
+
+    let mask = (1 << num_bits as usize) - 1;
+
+    let val = if coefficient < 0 {
+        (coefficient - 1) as u16 & mask
+    } else {
+        coefficient as u16 & mask
+    };
+
+    (num_bits, val)
+}
+
+#[inline]
+fn rgb_to_ycbcr<P: Pixel>(pixel: P) -> (u8, u8, u8) {
+    use crate::traits::Primitive;
+    use num_traits::cast::ToPrimitive;
+
+    let [r, g, b] = pixel.to_rgb().0;
+    let max: f32 = P::Subpixel::DEFAULT_MAX_VALUE.to_f32().unwrap();
+    let r: f32 = r.to_f32().unwrap();
+    let g: f32 = g.to_f32().unwrap();
+    let b: f32 = b.to_f32().unwrap();
+
+    // Coefficients from JPEG File Interchange Format (Version 1.02), multiplied for 255 maximum.
+    let y = 76.245 / max * r + 149.685 / max * g + 29.07 / max * b;
+    let cb = -43.0185 / max * r - 84.4815 / max * g + 127.5 / max * b + 128.;
+    let cr = 127.5 / max * r - 106.7685 / max * g - 20.7315 / max * b + 128.;
+
+    (y as u8, cb as u8, cr as u8)
+}
+
+/// Returns the pixel at (x,y) if (x,y) is in the image,
+/// otherwise the closest pixel in the image
+#[inline]
+fn pixel_at_or_near<I: GenericImageView>(source: &I, x: u32, y: u32) -> I::Pixel {
+    if source.in_bounds(x, y) {
+        source.get_pixel(x, y)
+    } else {
+        source.get_pixel(x.min(source.width() - 1), y.min(source.height() - 1))
+    }
+}
+
+fn copy_blocks_ycbcr<I: GenericImageView>(
+    source: &I,
+    x0: u32,
+    y0: u32,
+    yb: &mut [u8; 64],
+    cbb: &mut [u8; 64],
+    crb: &mut [u8; 64],
+) {
+    for y in 0..8 {
+        for x in 0..8 {
+            let pixel = pixel_at_or_near(source, x + x0, y + y0);
+            let (yc, cb, cr) = rgb_to_ycbcr(pixel);
+
+            yb[(y * 8 + x) as usize] = yc;
+            cbb[(y * 8 + x) as usize] = cb;
+            crb[(y * 8 + x) as usize] = cr;
+        }
+    }
+}
+
+fn copy_blocks_gray<I: GenericImageView>(source: &I, x0: u32, y0: u32, gb: &mut [u8; 64]) {
+    use num_traits::cast::ToPrimitive;
+    for y in 0..8 {
+        for x in 0..8 {
+            let pixel = pixel_at_or_near(source, x0 + x, y0 + y);
+            let [luma] = pixel.to_luma().0;
+            gb[(y * 8 + x) as usize] = luma.to_u8().unwrap();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+
+    #[cfg(feature = "benchmarks")]
+    extern crate test;
+    #[cfg(feature = "benchmarks")]
+    use test::Bencher;
+
+    use crate::color::ColorType;
+    use crate::error::ParameterErrorKind::DimensionMismatch;
+    use crate::image::ImageDecoder;
+    use crate::{ImageEncoder, ImageError};
+
+    use super::super::JpegDecoder;
+    use super::{
+        build_frame_header, build_huffman_segment, build_jfif_header, build_quantization_segment,
+        build_scan_header, Component, JpegEncoder, PixelDensity, DCCLASS, LUMADESTINATION,
+        STD_LUMA_DC_CODE_LENGTHS, STD_LUMA_DC_VALUES,
+    };
+
+    fn decode(encoded: &[u8]) -> Vec<u8> {
+        let decoder = JpegDecoder::new(Cursor::new(encoded)).expect("Could not decode image");
+
+        let mut decoded = vec![0; decoder.total_bytes() as usize];
+        decoder
+            .read_image(&mut decoded)
+            .expect("Could not decode image");
+        decoded
+    }
+
+    #[test]
+    fn roundtrip_sanity_check() {
+        // create a 1x1 8-bit image buffer containing a single red pixel
+        let img = [255u8, 0, 0];
+
+        // encode it into a memory buffer
+        let mut encoded_img = Vec::new();
+        {
+            let encoder = JpegEncoder::new_with_quality(&mut encoded_img, 100);
+            encoder
+                .write_image(&img, 1, 1, ColorType::Rgb8)
+                .expect("Could not encode image");
+        }
+
+        // decode it from the memory buffer
+        {
+            let decoded = decode(&encoded_img);
+            // note that, even with the encode quality set to 100, we do not get the same image
+            // back. Therefore, we're going to assert that it's at least red-ish:
+            assert_eq!(3, decoded.len());
+            assert!(decoded[0] > 0x80);
+            assert!(decoded[1] < 0x80);
+            assert!(decoded[2] < 0x80);
+        }
+    }
+
+    #[test]
+    fn grayscale_roundtrip_sanity_check() {
+        // create a 2x2 8-bit image buffer containing a white diagonal
+        let img = [255u8, 0, 0, 255];
+
+        // encode it into a memory buffer
+        let mut encoded_img = Vec::new();
+        {
+            let encoder = JpegEncoder::new_with_quality(&mut encoded_img, 100);
+            encoder
+                .write_image(&img[..], 2, 2, ColorType::L8)
+                .expect("Could not encode image");
+        }
+
+        // decode it from the memory buffer
+        {
+            let decoded = decode(&encoded_img);
+            // note that, even with the encode quality set to 100, we do not get the same image
+            // back. Therefore, we're going to assert that the diagonal is at least white-ish:
+            assert_eq!(4, decoded.len());
+            assert!(decoded[0] > 0x80);
+            assert!(decoded[1] < 0x80);
+            assert!(decoded[2] < 0x80);
+            assert!(decoded[3] > 0x80);
+        }
+    }
+
+    #[test]
+    fn jfif_header_density_check() {
+        let mut buffer = Vec::new();
+        build_jfif_header(&mut buffer, PixelDensity::dpi(300));
+        assert_eq!(
+            buffer,
+            vec![
+                b'J',
+                b'F',
+                b'I',
+                b'F',
+                0,
+                1,
+                2, // JFIF version 1.2
+                1, // density is in dpi
+                300u16.to_be_bytes()[0],
+                300u16.to_be_bytes()[1],
+                300u16.to_be_bytes()[0],
+                300u16.to_be_bytes()[1],
+                0,
+                0, // No thumbnail
+            ]
+        );
+    }
+
+    #[test]
+    fn test_image_too_large() {
+        // JPEG cannot encode images larger than 65,535×65,535
+        // create a 65,536×1 8-bit black image buffer
+        let img = [0; 65_536];
+        // Try to encode an image that is too large
+        let mut encoded = Vec::new();
+        let encoder = JpegEncoder::new_with_quality(&mut encoded, 100);
+        let result = encoder.write_image(&img, 65_536, 1, ColorType::L8);
+        match result {
+            Err(ImageError::Parameter(err)) => {
+                assert_eq!(err.kind(), DimensionMismatch)
+            }
+            other => {
+                assert!(
+                    false,
+                    "Encoding an image that is too large should return a DimensionError \
+                                it returned {:?} instead",
+                    other
+                )
+            }
+        }
+    }
+
+    #[test]
+    fn test_build_jfif_header() {
+        let mut buf = vec![];
+        let density = PixelDensity::dpi(100);
+        build_jfif_header(&mut buf, density);
+        assert_eq!(
+            buf,
+            [0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01, 0, 100, 0, 100, 0, 0]
+        );
+    }
+
+    #[test]
+    fn test_build_frame_header() {
+        let mut buf = vec![];
+        let components = vec![
+            Component {
+                id: 1,
+                h: 1,
+                v: 1,
+                tq: 5,
+                dc_table: 5,
+                ac_table: 5,
+                _dc_pred: 0,
+            },
+            Component {
+                id: 2,
+                h: 1,
+                v: 1,
+                tq: 4,
+                dc_table: 4,
+                ac_table: 4,
+                _dc_pred: 0,
+            },
+        ];
+        build_frame_header(&mut buf, 5, 100, 150, &components);
+        assert_eq!(
+            buf,
+            [5, 0, 150, 0, 100, 2, 1, 1 << 4 | 1, 5, 2, 1 << 4 | 1, 4]
+        );
+    }
+
+    #[test]
+    fn test_build_scan_header() {
+        let mut buf = vec![];
+        let components = vec![
+            Component {
+                id: 1,
+                h: 1,
+                v: 1,
+                tq: 5,
+                dc_table: 5,
+                ac_table: 5,
+                _dc_pred: 0,
+            },
+            Component {
+                id: 2,
+                h: 1,
+                v: 1,
+                tq: 4,
+                dc_table: 4,
+                ac_table: 4,
+                _dc_pred: 0,
+            },
+        ];
+        build_scan_header(&mut buf, &components);
+        assert_eq!(buf, [2, 1, 5 << 4 | 5, 2, 4 << 4 | 4, 0, 63, 0]);
+    }
+
+    #[test]
+    fn test_build_huffman_segment() {
+        let mut buf = vec![];
+        build_huffman_segment(
+            &mut buf,
+            DCCLASS,
+            LUMADESTINATION,
+            &STD_LUMA_DC_CODE_LENGTHS,
+            &STD_LUMA_DC_VALUES,
+        );
+        assert_eq!(
+            buf,
+            vec![
+                0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                10, 11
+            ]
+        );
+    }
+
+    #[test]
+    fn test_build_quantization_segment() {
+        let mut buf = vec![];
+        let qtable = [0u8; 64];
+        build_quantization_segment(&mut buf, 8, 1, &qtable);
+        let mut expected = vec![];
+        expected.push(0 << 4 | 1);
+        expected.extend_from_slice(&[0; 64]);
+        assert_eq!(buf, expected)
+    }
+
+    #[cfg(feature = "benchmarks")]
+    #[bench]
+    fn bench_jpeg_encoder_new(b: &mut Bencher) {
+        b.iter(|| {
+            let mut y = vec![];
+            let x = JpegEncoder::new(&mut y);
+        })
+    }
+}