Merge branch 'main' into safe-simd-ycbcr

Author: Shnatsel

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "jpeg-encoder"
-version = "0.6.1"
+version = "0.7.0"
 authors = ["Volker Ströbel <volkerstroebel@mysurdity.de>"]
-edition = "2021"
+edition = "2024"
 license = "(MIT OR Apache-2.0) AND IJG"
 description = "JPEG encoder"
 categories = ["multimedia::images"]

README.md

@@ -41,7 +41,7 @@ encoder.encode(&data, 2, 2, ColorType::Rgb)?;
 
 ## Minimum Supported Version of Rust (MSRV)
 
-This crate needs at least 1.61 or higher.
+This crate needs at least 1.87 or higher.
 
 ## License
 

criterion/Cargo.toml

@@ -28,3 +28,7 @@ harness = false
 [[bench]]
 name = "fdct"
 harness = false
+
+[[bench]]
+name = "ycbcr"
+harness = false

criterion/benches/ycbcr.rs

@@ -0,0 +1,104 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use jpeg_encoder::{ImageBuffer, RgbImage};
+use std::time::Duration;
+
+fn create_bench_img() -> (Vec<u8>, u16, u16) {
+    let width = 1001;
+    let height = 500;
+
+    let mut data = Vec::with_capacity(width * height * 3);
+
+    for y in 0..height {
+        for x in 0..width {
+            if (x * y) % 13 == 0 {
+                data.push(0);
+                data.push(0);
+                data.push(0);
+            } else if (x * y) % 17 == 0 {
+                data.push(255);
+                data.push(255);
+                data.push(255);
+            } else if (x * y) % 19 == 0 {
+                data.push(255);
+                data.push(0);
+                data.push(0);
+            } else if (x * y) % 21 == 0 {
+                data.push(0);
+                data.push(0);
+                data.push(255);
+            } else if (x * y) % 23 == 0 {
+                data.push(0);
+                data.push(255);
+                data.push(0);
+            } else if (x * y) % 25 == 0 {
+                data.push(96);
+                data.push(255);
+                data.push(96);
+            } else if (x * y) % 27 == 0 {
+                data.push(255);
+                data.push(96);
+                data.push(96);
+            } else if (x * y) % 29 == 0 {
+                data.push(96);
+                data.push(96);
+                data.push(255);
+            } else {
+                data.push((x % 256) as u8);
+                data.push((x % 256) as u8);
+                data.push(((x * y) % 256) as u8);
+            }
+        }
+    }
+
+    (data, width as u16, height as u16)
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let (data, width, height) = create_bench_img();
+    let res1 = Vec::with_capacity(usize::from(width));
+    let res2 = Vec::with_capacity(usize::from(width));
+    let res3 = Vec::with_capacity(usize::from(width));
+    let res4 = Vec::with_capacity(usize::from(width));
+
+    let mut res = [res1, res2, res3, res4];
+
+    let mut group = c.benchmark_group("ycbcr");
+    group.measurement_time(Duration::from_secs(45));
+    group.warm_up_time(Duration::from_secs(10));
+
+    group.bench_function("default ycbcr", |b| {
+        let image_buffer = RgbImage(&data, width, height);
+
+        b.iter(|| {
+            for y in 0..height {
+                res[0].clear();
+                res[1].clear();
+                res[2].clear();
+                image_buffer.fill_buffers(y, black_box(&mut res));
+            }
+            black_box(&res);
+        });
+    });
+
+    #[cfg(all(feature = "simd", any(target_arch = "x86", target_arch = "x86_64")))]
+    group.bench_function("ycbcr avx2", |b| {
+        use jpeg_encoder::RgbImageAVX2;
+        let image_buffer = RgbImageAVX2(&data, width, height);
+
+        b.iter(|| {
+            for y in 0..height {
+                res[0].clear();
+                res[1].clear();
+                res[2].clear();
+                image_buffer.fill_buffers(y, black_box(&mut res));
+            }
+            black_box(&res);
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

src/avx2.rs

@@ -3,7 +3,7 @@ mod ycbcr;
 
 use crate::encoder::Operations;
 pub use fdct::fdct_avx2;
-pub(crate) use ycbcr::*;
+pub use ycbcr::*;
 
 pub(crate) struct AVX2Operations;
 

src/avx2/ycbcr.rs

@@ -16,7 +16,7 @@ use crate::{rgb_to_ycbcr, ImageBuffer, JpegColorType};
 
 macro_rules! ycbcr_image_avx2 {
     ($name:ident, $num_colors:expr, $o1:expr, $o2:expr, $o3:expr) => {
-        pub(crate) struct $name<'a>(pub &'a [u8], pub u16, pub u16);
+        pub struct $name<'a>(pub &'a [u8], pub u16, pub u16);
 
         impl<'a> $name<'a> {
             #[target_feature(enable = "avx2")]

src/encoder.rs

@@ -4,7 +4,7 @@ use crate::image_buffer::*;
 use crate::marker::Marker;
 use crate::quantization::{QuantizationTable, QuantizationTableType};
 use crate::writer::{JfifWrite, JfifWriter, ZIGZAG};
-use crate::{Density, EncodingError};
+use crate::{PixelDensity, EncodingError};
 
 use alloc::vec;
 use alloc::vec::Vec;
@@ -194,7 +194,7 @@ macro_rules! add_component {
 /// # The JPEG encoder
 pub struct Encoder<W: JfifWrite> {
     writer: JfifWriter<W>,
-    density: Density,
+    density: PixelDensity,
     quality: u8,
 
     components: Vec<Component>,
@@ -243,7 +243,7 @@ impl<W: JfifWrite> Encoder<W> {
 
         Encoder {
             writer: JfifWriter::new(w),
-            density: Density::None,
+            density: PixelDensity::default(),
             quality,
             components: vec![],
             quantization_tables,
@@ -259,12 +259,12 @@ impl<W: JfifWrite> Encoder<W> {
     /// Set pixel density for the image
     ///
     /// By default, this value is None which is equal to "1 pixel per pixel".
-    pub fn set_density(&mut self, density: Density) {
+    pub fn set_density(&mut self, density: PixelDensity) {
         self.density = density;
     }
 
     /// Return pixel density
-    pub fn density(&self) -> Density {
+    pub fn density(&self) -> PixelDensity {
         self.density
     }
 
@@ -400,6 +400,24 @@ impl<W: JfifWrite> Encoder<W> {
         Ok(())
     }
 
+    /// Embeds Exif metadata into the image
+    ///
+    /// The maximum allowed data length is 65,528 bytes.
+    ///
+    /// # Errors
+    ///
+    /// Returns an Error if the data exceeds the maximum size for the Exif metadata
+    pub fn add_exif_metadata(&mut self, data: &[u8]) -> Result<(), EncodingError> {
+        // E x i f \0 \0
+        /// The header for an EXIF APP1 segment
+        const EXIF_HEADER: [u8; 6] = [0x45, 0x78, 0x69, 0x66, 0x00, 0x00];
+
+        let mut formatted = EXIF_HEADER.to_vec();
+        formatted.extend_from_slice(data);
+
+        self.add_app_segment(1, &formatted)
+    }
+
     /// Encode an image
     ///
     /// Data format and length must conform to specified width, height and color type.

src/image_buffer.rs

@@ -134,7 +134,7 @@ fn get_line(data: &[u8], y: u16, width:u16, num_colors: usize) -> &[u8] {
 
 macro_rules! ycbcr_image {
     ($name:ident, $num_colors:expr, $o1:expr, $o2:expr, $o3:expr) => {
-        pub(crate) struct $name<'a>(pub &'a [u8], pub u16, pub u16);
+        pub struct $name<'a>(pub &'a [u8], pub u16, pub u16);
 
         impl<'a> ImageBuffer for $name<'a> {
             fn get_jpeg_color_type(&self) -> JpegColorType {

src/lib.rs

@@ -46,13 +46,20 @@ pub use encoder::{ColorType, Encoder, JpegColorType, SamplingFactor};
 pub use error::EncodingError;
 pub use image_buffer::{cmyk_to_ycck, rgb_to_ycbcr, ImageBuffer};
 pub use quantization::QuantizationTableType;
-pub use writer::{Density, JfifWrite};
+pub use writer::{PixelDensity, PixelDensityUnit, JfifWrite};
 
 #[cfg(feature = "benchmark")]
 pub use fdct::fdct;
+
+#[cfg(feature = "benchmark")]
+pub use image_buffer::RgbImage;
+
 #[cfg(all(feature = "benchmark", feature = "simd", any(target_arch = "x86", target_arch = "x86_64")))]
 pub use avx2::fdct_avx2;
 
+#[cfg(all(feature = "benchmark", feature = "simd", any(target_arch = "x86", target_arch = "x86_64")))]
+pub use avx2::RgbImageAVX2;
+
 #[cfg(test)]
 mod tests {
     use crate::image_buffer::rgb_to_ycbcr;

src/writer.rs

@@ -4,17 +4,58 @@ use crate::marker::{Marker, SOFType};
 use crate::quantization::QuantizationTable;
 use crate::EncodingError;
 
-/// Density settings
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Density {
-    /// No pixel density is set, which means "1 pixel per pixel"
-    None,
+/// Represents the pixel density of an image
+///
+/// For example, a 300 DPI image is represented by:
+///
+/// ```rust
+/// # use jpeg_encoder::{PixelDensity, PixelDensityUnit};
+/// 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.
+    #[must_use]
+    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,
+        }
+    }
+}
+
+/// 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,
 
-    /// Horizontal and vertical dots per inch (dpi)
-    Inch { x: u16, y: u16 },
+    /// Pixels per inch (2.54 cm)
+    Inches,
 
-    /// Horizontal and vertical dots per centimeters
-    Centimeter { x: u16, y: u16 },
+    /// Pixels per centimeter
+    Centimeters,
 }
 
 /// Zig-zag sequence of quantized DCT coefficients
@@ -172,30 +213,27 @@ impl<W: JfifWrite> JfifWriter<W> {
         Ok(())
     }
 
-    pub fn write_header(&mut self, density: &Density) -> Result<(), EncodingError> {
+    pub fn write_header(&mut self, density: &PixelDensity) -> Result<(), EncodingError> {
         self.write_marker(Marker::APP(0))?;
         self.write_u16(16)?;
 
         self.write(b"JFIF\0")?;
         self.write(&[0x01, 0x02])?;
 
-        match *density {
-            Density::None => {
+        match density.unit {
+            PixelDensityUnit::PixelAspectRatio => {
                 self.write_u8(0x00)?;
-                self.write_u16(1)?;
-                self.write_u16(1)?;
             }
-            Density::Inch { x, y } => {
+            PixelDensityUnit::Inches => {
                 self.write_u8(0x01)?;
-                self.write_u16(x)?;
-                self.write_u16(y)?;
             }
-            Density::Centimeter { x, y } => {
+            PixelDensityUnit::Centimeters => {
                 self.write_u8(0x02)?;
-                self.write_u16(x)?;
-                self.write_u16(y)?;
             }
         }
+        let (x, y) = density.density;
+        self.write_u16(x)?;
+        self.write_u16(y)?;
 
         self.write(&[0x00, 0x00])
     }