feat: apply EXIF orientation when decoding a wallpaper (pop-os#142)

Cameras store portrait photos with the pixels laid out landscape and record
the rotation in the Exif metadata. `ImageReader::decode` ignores it, so those
wallpapers are drawn rotated. It is also why such a photo looks right in an
image viewer but rotated in the wallpaper and in the cosmic-settings preview.

Decode through `into_decoder` instead, so the orientation reported by the
decoder can be applied to the decoded image. Unlike `decode`, `into_decoder`
does not check the allocation limit against the size of the decoded image, so
that check is kept explicitly.

Signed-off-by: Leandro Pérez G. <leandropatodo@gmail.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: LeandroPG19

src/wallpaper.rs

@@ -4,13 +4,14 @@ use crate::{CosmicBg, CosmicBgLayer};
 
 use std::collections::VecDeque;
 use std::fs;
+use std::io::BufReader;
 use std::path::PathBuf;
 use std::time::{Duration, Instant};
 
 use cosmic_bg_config::state::State;
 use cosmic_bg_config::{Color, Entry, SamplingMethod, ScalingMode, Source};
 use cosmic_config::CosmicConfigEntry;
-use image::{DynamicImage, ImageReader, Limits};
+use image::{DynamicImage, ImageDecoder, ImageReader, ImageResult, Limits};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
 use rand::rng;
 use rand::seq::SliceRandom;
@@ -126,23 +127,17 @@ impl Wallpaper {
                                 .ok()
                                 .and_then(|f| f.with_guessed_format().ok())
                             {
-                                Some(mut f) => {
-                                    let mut limits = Limits::default();
-                                    limits.max_alloc = Some(1024 * 1024 * 1024);
-                                    f.limits(limits);
-
-                                    match f.decode() {
-                                        Ok(img) => Some(img),
-                                        Err(why) => {
-                                            tracing::warn!(
-                                                ?why,
-                                                "Failed to decode image: {}",
-                                                path.display()
-                                            );
-                                            continue;
-                                        }
+                                Some(f) => match decode(f) {
+                                    Ok(img) => Some(img),
+                                    Err(why) => {
+                                        tracing::warn!(
+                                            ?why,
+                                            "Failed to decode image: {}",
+                                            path.display()
+                                        );
+                                        continue;
                                     }
-                                }
+                                },
                                 None => continue,
                             };
                         }
@@ -371,6 +366,23 @@ impl Wallpaper {
     }
 }
 
+fn decode(mut reader: ImageReader<BufReader<fs::File>>) -> ImageResult<DynamicImage> {
+    let mut limits = Limits::default();
+    limits.max_alloc = Some(1024 * 1024 * 1024);
+    reader.limits(limits.clone());
+
+    let mut decoder = reader.into_decoder()?;
+    let orientation = decoder.orientation()?;
+
+    limits.reserve(decoder.total_bytes())?;
+    decoder.set_limits(limits)?;
+
+    let mut image = DynamicImage::from_decoder(decoder)?;
+    image.apply_orientation(orientation);
+
+    Ok(image)
+}
+
 fn current_image(output: &str) -> Option<Source> {
     let state = State::state().ok()?;
     let mut wallpapers = State::get_entry(&state)