Merge upstream COSMIC 1.5 into wmde-bg

Brings in one upstream commit: apply EXIF orientation when decoding a
wallpaper (upstream pop-os#142). The merge was clean with a single
auto-merged conflict in src/wallpaper.rs (no manual resolution
needed) - decode() now reads orientation from the image decoder and
applies it to the DynamicImage before use.

No Cargo.toml version bump needed (both sides already at 1.2.0), no
i18n .ftl files in this crate, and no debian/ resurrection. Brand
sweep found only pre-existing internal CosmicBg/CosmicConfigEntry
type names (load-bearing, not rebrand leftovers) - nothing to change.

Author: Softer

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 wmde_bg_config::state::State;
 use wmde_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,
                             };
                         }
@@ -349,6 +344,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)