Double allocations on heap when loading image?

[SKTT1Ryze]

I am testing the performance of a Slint application on the Android platform. Compared to native Android applications, Slint seems to use more heap memory in scenarios involving image loading.
Further analysis revealed that after loading an image, the heap memory growth in the Slint application is always twice that of a native Android application.
Using the heap-profile tool for analysis, it was found that Slint allocates heap memory twice each time an image is loaded:

Here is the pseudocode for loading images in the Slint application:

slint::include_modules!();

use std::rc::Rc;
use slint::VecModel;
use slint::ModelRc;

let ui = Rc::new(App::new().unwrap());

let the_images = Rc::new(VecModel::from(vec![])); // A container that holds multiple images

ui.set_images(ModelRc::from(the_images.clone()));

ui.on_button_clicked(move || {
    let img = slint::Image::load_from_path("assets/rust.png")
        .expect("failed to load image"); // Here, a heap memory allocation for an image is made.
    the_images.push(img);
});

At the same time, I reviewed the Slint source code and found that in the core module, the image data is cloned and stored in an in-memory cache, which leads to two heap memory allocations:

// internal/renderers/skia/itemrenderer.rs

impl<'a> SkiaItemRenderer<'a> {
    fn draw_image_impl(&mut self,
        item_rc: &ItemRc,
        item: Pin<&dyn RenderImage>,
        dest_rect: PhysicalRect) {
        
        ...
        
        let skia_image = self.image_cache.get_or_update_cache_entry(item_rc, || {
            let image = item.source();
            super::cached_image::as_skia_image(
                image,
                &|| item.target_size(),
                if tiling != Default::default() { ImageFit::Preserve } else { item.image_fit() },
                self.scale_factor,
                self.canvas,
            ) // Here, a copy of the image data is stored in the memory cache.
            .and_then(|skia_image| {
                let brush = item.colorize();
                if !brush.is_transparent() {
                    self.colorize_image(skia_image, brush)
                } else {
                    Some(skia_image)
                }
            })
        });
        
        ...
    }
}

I want to confirm if this logic is correct and whether this issue can be optimized.

Thanks.

[tronical]

I think this is the steps of what should happen at run-time:

1. slint::Image::load_from_path will decode the image and store it as a SharedImageBuffer (ImageInner::EmbeddedImage) in the cache.
2. The Skia renderer will fetch it from the cache and create a skia_safe::Image. At this point the image exists twice in memory as pixel buffer.
3. The as_skia_image function used to create the skia_safe::Image will call replace_cached_image and replace the first SharedImageBuffer with the skia_safe::Image. At this point the pixel data should exist only once in memory.
4. If a colorize effect is used, then a copy of the image will be done and cached with the effect applied.

[SKTT1Ryze]

What about the memory retained in the the_images container? This portion of memory will not be released either.