Adjust ImageMeta dimensions based on Exif orientation data (#2906)

* Adjust ImageMeta dimensions based on Exif data

* Get image Exif data from the decoder

This lets us avoid reading the file from disk twice - once to get the
dimensions/contents, and once to get the image metadata. Now we create
one decoder, get all the data we need from it, and turn it into a
DynamicImage directly.

* Get image size directly from ImageDecoder in get_rotated_size_test

Author: Insprill

components/imageproc/src/helpers.rs

@@ -9,14 +9,8 @@ use libs::image::DynamicImage;
 
 /// Apply image rotation based on EXIF data
 /// Returns `None` if no transformation is needed
-pub fn fix_orientation(img: &DynamicImage, path: &Path) -> Option<DynamicImage> {
-    let file = std::fs::File::open(path).ok()?;
-    let mut buf_reader = std::io::BufReader::new(&file);
-    let exif_reader = exif::Reader::new();
-    let exif = exif_reader.read_from_container(&mut buf_reader).ok()?;
-    let orientation =
-        exif.get_field(exif::Tag::Orientation, exif::In::PRIMARY)?.value.get_uint(0)?;
-    match orientation {
+pub fn fix_orientation(img: &DynamicImage, raw_metadata: Option<Vec<u8>>) -> Option<DynamicImage> {
+    match get_orientation(raw_metadata)? {
         // Values are taken from the page 30 of
         // https://www.cipa.jp/std/documents/e/DC-008-2012_E.pdf
         // For more details check http://sylvana.net/jpegcrop/exif_orientation.html
@@ -32,6 +26,26 @@ pub fn fix_orientation(img: &DynamicImage, path: &Path) -> Option<DynamicImage>
     }
 }
 
+/// Adjusts the width and height of an image based on EXIF rotation data.
+/// Returns `None` if no transformation is needed.
+pub fn get_rotated_size(w: u32, h: u32, raw_metadata: Option<Vec<u8>>) -> Option<(u32, u32)> {
+    // See fix_orientation for the meaning of these values.
+    match get_orientation(raw_metadata)? {
+        5 | 6 | 7 | 8 => Some((h, w)),
+        _ => None,
+    }
+}
+
+fn get_orientation(raw_metadata: Option<Vec<u8>>) -> Option<u32> {
+    match raw_metadata {
+        Some(metadata) => {
+            let exif = exif::Reader::new().read_raw(metadata).ok()?;
+            Some(exif.get_field(exif::Tag::Orientation, exif::In::PRIMARY)?.value.get_uint(0)?)
+        }
+        None => None,
+    }
+}
+
 /// We only use the input_path to get the file stem.
 /// Hashing the resolved `input_path` would include the absolute path to the image
 /// with all filesystem components.

components/imageproc/src/lib.rs

@@ -4,7 +4,7 @@ mod meta;
 mod ops;
 mod processor;
 
-pub use helpers::fix_orientation;
+pub use helpers::{fix_orientation, get_rotated_size};
 pub use meta::{read_image_metadata, ImageMeta, ImageMetaResponse};
 pub use ops::{ResizeInstructions, ResizeOperation};
 pub use processor::{EnqueueResponse, Processor, RESIZED_SUBDIR};

components/imageproc/src/meta.rs

@@ -1,6 +1,6 @@
 use errors::{anyhow, Context, Result};
 use libs::avif_parse::read_avif;
-use libs::image::ImageReader;
+use libs::image::{ImageDecoder, ImageReader};
 use libs::image::{ImageFormat, ImageResult};
 use libs::svg_metadata::Metadata as SvgMetadata;
 use serde::Serialize;
@@ -9,6 +9,8 @@ use std::fs::File;
 use std::io::BufReader;
 use std::path::Path;
 
+use crate::get_rotated_size;
+
 /// Size and format read cheaply with `image`'s `Reader`.
 #[derive(Debug)]
 pub struct ImageMeta {
@@ -21,7 +23,13 @@ impl ImageMeta {
     pub fn read(path: &Path) -> ImageResult<Self> {
         let reader = ImageReader::open(path).and_then(ImageReader::with_guessed_format)?;
         let format = reader.format();
-        let size = reader.into_dimensions()?;
+        let mut decoder = reader.into_decoder()?;
+        let mut size = decoder.dimensions();
+        let raw_metadata = decoder.exif_metadata()?;
+
+        if let Some((w, h)) = get_rotated_size(size.0, size.1, raw_metadata) {
+            size = (w, h);
+        }
 
         Ok(Self { size, format })
     }

components/imageproc/src/processor.rs

@@ -9,10 +9,10 @@ use libs::ahash::{HashMap, HashSet};
 use libs::image::codecs::avif::AvifEncoder;
 use libs::image::codecs::jpeg::JpegEncoder;
 use libs::image::imageops::FilterType;
-use libs::image::GenericImageView;
+use libs::image::{DynamicImage, GenericImageView, ImageDecoder, ImageReader};
 use libs::image::{EncodableLayout, ImageEncoder, ImageFormat};
 use libs::rayon::prelude::*;
-use libs::{image, webp};
+use libs::webp;
 use serde::{Deserialize, Serialize};
 use utils::fs as ufs;
 
@@ -41,8 +41,13 @@ impl ImageOp {
             return Ok(());
         }
 
-        let img = image::open(&self.input_path)?;
-        let mut img = fix_orientation(&img, &self.input_path).unwrap_or(img);
+        let reader =
+            ImageReader::open(&self.input_path).and_then(ImageReader::with_guessed_format)?;
+        let mut decoder = reader.into_decoder()?;
+        let raw_metadata = decoder.exif_metadata()?;
+        let img = DynamicImage::from_decoder(decoder)?;
+
+        let mut img = fix_orientation(&img, raw_metadata).unwrap_or(img);
 
         let img = match self.instr.crop_instruction {
             Some((x, y, w, h)) => img.crop(x, y, w, h),

components/imageproc/tests/resize_image.rs

@@ -2,8 +2,8 @@ use std::env;
 use std::path::{PathBuf, MAIN_SEPARATOR as SLASH};
 
 use config::Config;
-use imageproc::{fix_orientation, ImageMetaResponse, Processor, ResizeOperation};
-use libs::image::{self, DynamicImage, GenericImageView, Pixel};
+use imageproc::{fix_orientation, get_rotated_size, ImageMetaResponse, Processor, ResizeOperation};
+use libs::image::{self, DynamicImage, GenericImageView, ImageDecoder, ImageReader, Pixel};
 use libs::once_cell::sync::Lazy;
 
 /// Assert that `address` matches `prefix` + RESIZED_FILENAME regex + "." + `extension`,
@@ -513,12 +513,36 @@ fn read_image_metadata_avif() {
     );
 }
 
+#[test]
+fn get_rotated_size_test() {
+    fn is_landscape(img_name: &str) -> bool {
+        let path = TEST_IMGS.join(img_name);
+        let mut decoder = ImageReader::open(path).unwrap().into_decoder().unwrap();
+        let (mut w, mut h) = decoder.dimensions();
+        w = w + 1; // Test images are square, add an offset so we can tell if the dimensions actually changed.
+        let metadata = decoder.exif_metadata().unwrap();
+        (w, h) = get_rotated_size(w, h, metadata).unwrap_or((w, h));
+        w > h
+    }
+    assert!(is_landscape("exif_0.jpg"));
+    assert!(is_landscape("exif_1.jpg"));
+    assert!(is_landscape("exif_2.jpg"));
+    assert!(is_landscape("exif_3.jpg"));
+    assert!(is_landscape("exif_4.jpg"));
+    assert!(!is_landscape("exif_5.jpg"));
+    assert!(!is_landscape("exif_6.jpg"));
+    assert!(!is_landscape("exif_7.jpg"));
+    assert!(!is_landscape("exif_8.jpg"));
+}
+
 #[test]
 fn fix_orientation_test() {
     fn load_img_and_fix_orientation(img_name: &str) -> DynamicImage {
         let path = TEST_IMGS.join(img_name);
-        let img = image::open(&path).unwrap();
-        fix_orientation(&img, &path).unwrap_or(img)
+        let mut decoder = ImageReader::open(path).unwrap().into_decoder().unwrap();
+        let metadata = decoder.exif_metadata().unwrap();
+        let img = DynamicImage::from_decoder(decoder).unwrap();
+        fix_orientation(&img, metadata).unwrap_or(img)
     }
 
     let img = image::open(TEST_IMGS.join("exif_1.jpg")).unwrap();