Merge branch 'background_reduce_memory_usage' into 'master'

background: Drop background image as soon as possible

See merge request redox-os/orbutils!67

Author: jackpot51

calculator/build.rs

@@ -8,7 +8,7 @@ fn main() {
 }
 
 #[cfg(feature = "slint-default")]
-fn main() { 
+fn main() {
     coop_widgets::generate_import().unwrap();
     slint_build::compile("ui/app.slint").unwrap();
-}
+}

orbutils/src/background/main.rs

@@ -1,16 +1,19 @@
+extern crate dirs;
+extern crate event;
+extern crate libredox;
+extern crate log;
 extern crate orbclient;
 extern crate orbimage;
 extern crate redox_log;
-extern crate log;
-extern crate event;
-extern crate libredox;
-extern crate dirs;
 
-use std::{
-    collections::HashMap, env, fs::File, os::unix::io::{AsRawFd, FromRawFd, RawFd}, rc::Rc
-};
 use libredox::flag;
 use log::error;
+use std::{
+    collections::HashMap,
+    env,
+    fs::File,
+    os::unix::io::{AsRawFd, FromRawFd, RawFd},
+};
 
 use orbclient::{Color, EventOption, Renderer, Window, WindowFlag};
 use orbimage::Image;
@@ -48,14 +51,15 @@ impl BackgroundMode {
     }
 }
 
-fn find_scale(image: &Image, mode: BackgroundMode, display_width: u32, display_height: u32) -> (u32, u32) {
+fn find_scale(
+    image: &Image,
+    mode: BackgroundMode,
+    display_width: u32,
+    display_height: u32,
+) -> (u32, u32) {
     match mode {
-        BackgroundMode::Center => {
-            (image.width(), image.height())
-        },
-        BackgroundMode::Fill => {
-            (display_width, display_height)
-        },
+        BackgroundMode::Center => (image.width(), image.height()),
+        BackgroundMode::Fill => (display_width, display_height),
         BackgroundMode::Scale => {
             let d_w = display_width as f64;
             let d_h = display_height as f64;
@@ -69,7 +73,7 @@ fn find_scale(image: &Image, mode: BackgroundMode, display_width: u32, display_h
             };
 
             ((i_w * scale) as u32, (i_h * scale) as u32)
-        },
+        }
         BackgroundMode::Zoom => {
             let d_w = display_width as f64;
             let d_h = display_height as f64;
@@ -90,10 +94,7 @@ fn find_scale(image: &Image, mode: BackgroundMode, display_width: u32, display_h
 fn find_background() -> String {
     match dirs::home_dir() {
         Some(home) => {
-            for name in &[
-                "background.png",
-                "background.jpg",
-            ] {
+            for name in &["background.png", "background.jpg"] {
                 let path = home.join(name);
                 if path.is_file() {
                     if let Some(path_str) = path.to_str() {
@@ -118,15 +119,12 @@ fn get_full_url(path: &str) -> Result<String, String> {
     let count = libredox::call::fpath(file.as_raw_fd() as usize, &mut buf)
         .map_err(|err| format!("{}", err))?;
 
-    String::from_utf8(Vec::from(&buf[..count]))
-        .map_err(|err| format!("{}", err))
+    String::from_utf8(Vec::from(&buf[..count])).map_err(|err| format!("{}", err))
 }
 
 //TODO: determine x, y of display by talking to orbital instead of guessing!
 fn get_display_rects() -> Result<Vec<DisplayRect>, String> {
-    let url = get_full_url(
-        &env::var("DISPLAY").or(Err("DISPLAY not set"))?
-    )?;
+    let url = get_full_url(&env::var("DISPLAY").or(Err("DISPLAY not set"))?)?;
 
     let mut url_parts = url.split(':');
     let scheme_name = url_parts.next().ok_or(format!("no scheme name"))?;
@@ -152,7 +150,8 @@ fn get_display_rects() -> Result<Vec<DisplayRect>, String> {
         let start_screen_i = parts.next().unwrap_or("").parse::<usize>().unwrap_or(0);
         //TODO: determine maximum number of screens
         for screen_i in start_screen_i + 1..1024 {
-            let url = match get_full_url(&format!("/scheme/{}/{}.{}", scheme_name, vt_i, screen_i)) {
+            let url = match get_full_url(&format!("/scheme/{}/{}.{}", scheme_name, vt_i, screen_i))
+            {
                 Ok(ok) => ok,
                 //TODO: only check for ENOENT?
                 Err(_err) => break,
@@ -192,105 +191,115 @@ fn main() {
             OutputBuilder::stdout()
                 .with_filter(log::LevelFilter::Debug)
                 .with_ansi_escape_codes()
-                .build()
+                .build(),
         )
         .with_process_name("background".into())
         .enable();
 
     let mut args = env::args().skip(1);
 
-    let path = match args.next() {
+    let path = &match args.next() {
         Some(arg) => arg,
         None => find_background(),
     };
 
     let mode = BackgroundMode::from_str(&args.next().unwrap_or_default());
 
-    match Image::from_path(&path).map(Rc::new) {
-        Ok(image) => {
-            let event_queue = RawEventQueue::new().expect("background: failed to create event queue");
-
-            let mut handlers = HashMap::<usize, Box<dyn FnMut()>>::new();
-
-            for display in get_display_rects().expect("background: failed to get display rects") {
-                let mut window = Window::new_flags(
-                    display.x, display.y, display.width, display.height, "",
-                    &[WindowFlag::Async, WindowFlag::Back, WindowFlag::Borderless, WindowFlag::Unclosable]
-                ).unwrap();
-
-                let image = image.clone();
-                let mut scaled_image = (*image).clone();
-                let mut resize = Some((display.width, display.height));
-
-                event_queue.subscribe(window.as_raw_fd() as usize, window.as_raw_fd() as usize, event::EventFlags::READ)
-                    .expect("background: failed to add event");
-
-                let window_raw_fd = window.as_raw_fd();
-                let mut handler: Box<dyn FnMut()> = Box::new(move || {
-                    for event in window.events() {
-                        match event.to_option() {
-                            EventOption::Resize(resize_event) => {
-                                resize = Some((resize_event.width, resize_event.height));
-                            },
-                            EventOption::Screen(screen_event) => {
-                                window.set_size(screen_event.width, screen_event.height);
-                                resize = Some((screen_event.width, screen_event.height));
-                            },
-                            _ => ()
-                        }
+    let event_queue = RawEventQueue::new().expect("background: failed to create event queue");
+
+    let mut handlers = HashMap::<usize, Box<dyn FnMut()>>::new();
+
+    for display in get_display_rects().expect("background: failed to get display rects") {
+        let mut window = Window::new_flags(
+            display.x,
+            display.y,
+            display.width,
+            display.height,
+            "",
+            &[
+                WindowFlag::Async,
+                WindowFlag::Back,
+                WindowFlag::Borderless,
+                WindowFlag::Unclosable,
+            ],
+        )
+        .unwrap();
+
+        let mut resize = Some((display.width, display.height));
+
+        event_queue
+            .subscribe(
+                window.as_raw_fd() as usize,
+                window.as_raw_fd() as usize,
+                event::EventFlags::READ,
+            )
+            .expect("background: failed to add event");
+
+        let window_raw_fd = window.as_raw_fd();
+        let mut handler: Box<dyn FnMut()> = Box::new(move || {
+            for event in window.events() {
+                match event.to_option() {
+                    EventOption::Resize(resize_event) => {
+                        resize = Some((resize_event.width, resize_event.height));
                     }
-
-                    if let Some((w, h)) = resize.take() {
-                        let (width, height) = find_scale(&image, mode, w, h);
-
-                        if width == scaled_image.width() && height == scaled_image.height() {
-                            // Do not resize scaled image
-                        } else if width == image.width() && height == image.height() {
-                            scaled_image = (*image).clone();
-                        } else {
-                            scaled_image = image.resize(width, height, orbimage::ResizeType::Lanczos3).unwrap();
-                        }
-
-                        let (crop_x, crop_w) = if width > w  {
-                            ((width - w)/2, w)
-                        } else {
-                            (0, width)
-                        };
-
-                        let (crop_y, crop_h) = if height > h {
-                            ((height - h)/2, h)
-                        } else {
-                            (0, height)
-                        };
-
-                        window.set(Color::rgb(0, 0, 0));
-
-                        let x = (w as i32 - crop_w as i32)/2;
-                        let y = (h as i32 - crop_h as i32)/2;
-                        scaled_image.roi(
-                            crop_x, crop_y,
-                            crop_w, crop_h,
-                        ).draw(
-                            &mut window,
-                            x, y
-                        );
-
-                        window.sync();
+                    EventOption::Screen(screen_event) => {
+                        window.set_size(screen_event.width, screen_event.height);
+                        resize = Some((screen_event.width, screen_event.height));
                     }
-                });
-                handler();
-                handlers.insert(window_raw_fd as usize, handler);
+                    _ => (),
+                }
             }
 
-            for event in event_queue.map(|e| e.expect("background: failed to get next event")) {
-                let Some(handler) = handlers.get_mut(&event.fd) else {
-                    continue;
+            if let Some((w, h)) = resize.take() {
+                let image = match Image::from_path(&path) {
+                    Ok(image) => image,
+                    Err(err) => {
+                        error!("error loading {}: {}", path, err);
+                        return;
+                    }
+                };
+
+                let (width, height) = find_scale(&image, mode, w, h);
+
+                let scaled_image = if width == image.width() && height == image.height() {
+                    image
+                } else {
+                    image
+                        .resize(width, height, orbimage::ResizeType::Lanczos3)
+                        .unwrap()
+                };
+
+                let (crop_x, crop_w) = if width > w {
+                    ((width - w) / 2, w)
+                } else {
+                    (0, width)
                 };
-                (*handler)();
+
+                let (crop_y, crop_h) = if height > h {
+                    ((height - h) / 2, h)
+                } else {
+                    (0, height)
+                };
+
+                window.set(Color::rgb(0, 0, 0));
+
+                let x = (w as i32 - crop_w as i32) / 2;
+                let y = (h as i32 - crop_h as i32) / 2;
+                scaled_image
+                    .roi(crop_x, crop_y, crop_w, crop_h)
+                    .draw(&mut window, x, y);
+
+                window.sync();
             }
-        },
-        Err(err) => {
-            error!("error loading {}: {}", path, err);
-        }
+        });
+        handler();
+        handlers.insert(window_raw_fd as usize, handler);
+    }
+
+    for event in event_queue.map(|e| e.expect("background: failed to get next event")) {
+        let Some(handler) = handlers.get_mut(&event.fd) else {
+            continue;
+        };
+        (*handler)();
     }
 }