321 lines
12 KiB
Rust
321 lines
12 KiB
Rust
|
use cosmic::widget;
|
||
|
|
use image::ImageReader;
|
||
|
|
use std::{
|
||
|
|
collections::{HashMap, HashSet},
|
||
|
|
path::{Path, PathBuf},
|
||
|
|
};
|
||
|
|
|
||
|
|
/// Bytes per pixel in RGBA format (Red, Green, Blue, Alpha = 4 bytes)
|
||
|
|
pub const RGBA_BYTES_PER_PIXEL: u64 = 4;
|
||
|
|
|
||
|
|
/// Overhead factor for image decoding operations (30% additional memory for decode buffers,
|
||
|
|
/// fragment allocations, and intermediate representations during image decoding)
|
||
|
|
const DECODE_OVERHEAD_FACTOR: f64 = 1.3;
|
||
|
|
|
||
|
|
/// System memory reserve in MB to maintain for system stability (prevents thrashing)
|
||
|
|
/// Note: RAM checking is currently only available on Linux via procfs.
|
||
|
|
/// On Windows and macOS, only GPU buffer limits are enforced.
|
||
|
|
const SYSTEM_MEMORY_RESERVE_MB: u64 = 500;
|
||
|
|
|
||
|
|
/// Maximum memory allocation for gallery image decoding in MB.
|
||
|
|
/// Gallery mode uses the full memory budget since only one image decodes at a time.
|
||
|
|
/// This matches the ThumbCfg max_mem_mb budget for consistency.
|
||
|
|
const GALLERY_MEMORY_LIMIT_MB: u64 = 2000;
|
||
|
|
|
||
|
|
/// Threshold for considering an image "large" requiring GPU tiling
|
||
|
|
/// Atlas fragment/tile size in pixels. Large images are split into fragments of this size.
|
||
|
|
/// Must match the atlas SIZE constant in libcosmic/iced/wgpu/src/image/atlas.rs
|
||
|
|
pub const ATLAS_FRAGMENT_SIZE: u32 = 4096;
|
||
|
|
|
||
|
|
/// Conservative GPU buffer size limit in MB. Each atlas fragment can be up to this size.
|
||
|
|
/// Based on wgpu device limits - most GPUs support at least 256MB buffers.
|
||
|
|
/// Reference: https://docs.rs/wgpu/latest/wgpu/struct.Limits.html#structfield.max_buffer_size
|
||
|
|
const MAX_GPU_BUFFER_MB: u64 = 256;
|
||
|
|
|
||
|
|
/// Conversion factor: 1 MB = 1024 * 1024 bytes (binary megabyte, used for RAM calculations)
|
||
|
|
pub const MB_TO_BYTES: u64 = 1024 * 1024;
|
||
|
|
|
||
|
|
/// Conversion factor: 1 MB = 1000 * 1000 bytes (decimal megabyte, used by image crate)
|
||
|
|
/// The image crate's memory limits use decimal MB, not binary MB.
|
||
|
|
pub const DECIMAL_MB_TO_BYTES: u64 = 1000 * 1000;
|
||
|
|
|
||
|
|
/// Maximum dimension for image decoding
|
||
|
|
pub const MAX_DIMENSION_FOR_DECODE: u32 = 65536;
|
||
|
|
|
||
|
|
/// Get the dimensions of an image without fully decoding it
|
||
|
|
pub fn get_image_dimensions(path: &Path) -> Option<(u32, u32)> {
|
||
|
|
match ImageReader::open(path) {
|
||
|
|
Ok(reader) => match reader.into_dimensions() {
|
||
|
|
Ok((width, height)) => {
|
||
|
|
log::debug!(
|
||
|
|
"Image dimensions: {}x{} for {}",
|
||
|
|
width,
|
||
|
|
height,
|
||
|
|
path.display()
|
||
|
|
);
|
||
|
|
Some((width, height))
|
||
|
|
}
|
||
|
|
Err(e) => {
|
||
|
|
log::warn!("Failed to get dimensions for {}: {}", path.display(), e);
|
||
|
|
None
|
||
|
|
}
|
||
|
|
},
|
||
|
|
Err(e) => {
|
||
|
|
log::warn!("Failed to open image reader for {}: {}", path.display(), e);
|
||
|
|
None
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Check if there's sufficient memory to decode an image.
|
||
|
|
///
|
||
|
|
/// This function performs two types of checks:
|
||
|
|
/// 1. System RAM availability (Linux only via procfs)
|
||
|
|
/// 2. GPU buffer limits (all platforms)
|
||
|
|
///
|
||
|
|
/// Platform-specific behavior:
|
||
|
|
/// - Linux: Full RAM checking via /proc/meminfo + GPU checks
|
||
|
|
/// - Windows/macOS: GPU buffer checks only (RAM checking not yet implemented)
|
||
|
|
///
|
||
|
|
/// Returns: (has_memory, error_message)
|
||
|
|
pub fn check_memory_available(width: u32, height: u32) -> (bool, Option<String>) {
|
||
|
|
if width == 0 || height == 0 {
|
||
|
|
let error_msg = format!(
|
||
|
|
"Invalid image dimensions: {}x{} (zero dimension)",
|
||
|
|
width, height
|
||
|
|
);
|
||
|
|
log::error!("{}", error_msg);
|
||
|
|
return (false, Some(error_msg));
|
||
|
|
}
|
||
|
|
|
||
|
|
let pixels = match (width as u64).checked_mul(height as u64) {
|
||
|
|
Some(p) => p,
|
||
|
|
None => {
|
||
|
|
let error_msg = format!(
|
||
|
|
"Image dimensions too large: {}x{} causes overflow in pixel calculation",
|
||
|
|
width, height
|
||
|
|
);
|
||
|
|
log::error!("{}", error_msg);
|
||
|
|
return (false, Some(error_msg));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
let bytes_needed = match pixels.checked_mul(RGBA_BYTES_PER_PIXEL) {
|
||
|
|
Some(b) => b,
|
||
|
|
None => {
|
||
|
|
let error_msg = format!(
|
||
|
|
"Image memory requirements overflow: {}x{} pixels requires more than {} bytes",
|
||
|
|
width,
|
||
|
|
height,
|
||
|
|
u64::MAX
|
||
|
|
);
|
||
|
|
log::error!("{}", error_msg);
|
||
|
|
return (false, Some(error_msg));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// Add overhead for decode buffers, fragment allocations, and intermediate representations
|
||
|
|
let bytes_with_overhead = (bytes_needed as f64 * DECODE_OVERHEAD_FACTOR) as u64;
|
||
|
|
let mb_needed = bytes_with_overhead / MB_TO_BYTES;
|
||
|
|
|
||
|
|
// Check system RAM availability (Linux only)
|
||
|
|
#[cfg(target_os = "linux")]
|
||
|
|
{
|
||
|
|
use procfs::Current;
|
||
|
|
match procfs::Meminfo::current() {
|
||
|
|
Ok(meminfo) => {
|
||
|
|
// MemAvailable includes reclaimable cache and is the best estimate of
|
||
|
|
// actually available memory for new allocations
|
||
|
|
let available_kb = meminfo.mem_available.unwrap_or(0);
|
||
|
|
let available_bytes = available_kb * 1024;
|
||
|
|
|
||
|
|
// Maintain system reserve to prevent thrashing and OOM killer
|
||
|
|
let min_reserve_bytes = SYSTEM_MEMORY_RESERVE_MB * MB_TO_BYTES;
|
||
|
|
let usable_bytes = available_bytes.saturating_sub(min_reserve_bytes);
|
||
|
|
|
||
|
|
if bytes_with_overhead > usable_bytes {
|
||
|
|
let available_mb = available_bytes / MB_TO_BYTES;
|
||
|
|
let error_msg = format!(
|
||
|
|
"Insufficient memory: need {}MB, available {}MB. Try closing other applications.",
|
||
|
|
mb_needed, available_mb
|
||
|
|
);
|
||
|
|
log::warn!("{}", error_msg);
|
||
|
|
return (false, Some(error_msg));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => {
|
||
|
|
log::warn!("Failed to read /proc/meminfo: {}. Skipping RAM check.", e);
|
||
|
|
// Graceful fallback: continue to GPU checks
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: RAM checking not implemented for Windows/macOS
|
||
|
|
// These platforms will only validate against GPU buffer limits below
|
||
|
|
#[cfg(not(target_os = "linux"))]
|
||
|
|
{
|
||
|
|
log::debug!(
|
||
|
|
"RAM checking not available on this platform. Only GPU limits will be enforced."
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check GPU fragment/atlas tile limits
|
||
|
|
// Large images are split into atlas fragments for GPU upload.
|
||
|
|
// Each fragment must fit within GPU buffer size limits.
|
||
|
|
let fragment_bytes =
|
||
|
|
(ATLAS_FRAGMENT_SIZE as u64) * (ATLAS_FRAGMENT_SIZE as u64) * RGBA_BYTES_PER_PIXEL;
|
||
|
|
let max_gpu_buffer_bytes = MAX_GPU_BUFFER_MB * MB_TO_BYTES;
|
||
|
|
|
||
|
|
let fragments_x = (width + ATLAS_FRAGMENT_SIZE - 1) / ATLAS_FRAGMENT_SIZE;
|
||
|
|
let fragments_y = (height + ATLAS_FRAGMENT_SIZE - 1) / ATLAS_FRAGMENT_SIZE;
|
||
|
|
let fragment_count = fragments_x as u64 * fragments_y as u64;
|
||
|
|
|
||
|
|
// Fragments are uploaded sequentially, so we only need one fragment buffer at a time.
|
||
|
|
// However, each individual fragment must fit within GPU buffer size limits.
|
||
|
|
if fragment_bytes > max_gpu_buffer_bytes {
|
||
|
|
let max_dimension = (MAX_GPU_BUFFER_MB * MB_TO_BYTES / RGBA_BYTES_PER_PIXEL) as f64;
|
||
|
|
let max_dimension = (max_dimension.sqrt() as u32).saturating_sub(100); // Add safety margin
|
||
|
|
|
||
|
|
let error_msg = format!(
|
||
|
|
"Image too large for GPU: {}x{} pixels exceeds GPU buffer limits. \
|
||
|
|
Maximum supported dimension is approximately {}x{} pixels.",
|
||
|
|
width, height, max_dimension, max_dimension
|
||
|
|
);
|
||
|
|
log::error!("{}", error_msg);
|
||
|
|
return (false, Some(error_msg));
|
||
|
|
}
|
||
|
|
|
||
|
|
log::debug!(
|
||
|
|
"Memory check passed: {}x{} image needs {}MB RAM, will use {} GPU fragment(s) of {}MB each",
|
||
|
|
width,
|
||
|
|
height,
|
||
|
|
mb_needed,
|
||
|
|
fragment_count,
|
||
|
|
fragment_bytes / MB_TO_BYTES
|
||
|
|
);
|
||
|
|
|
||
|
|
(true, None)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Decode a large image asynchronously in a blocking thread pool.
|
||
|
|
///
|
||
|
|
/// This function is used for gallery mode where full-resolution images need to be loaded.
|
||
|
|
/// It uses the full memory budget (GALLERY_MEMORY_LIMIT_MB) since only one image
|
||
|
|
/// decodes at a time in gallery mode.
|
||
|
|
pub async fn decode_large_image(path: PathBuf) -> Option<(PathBuf, u32, u32, Vec<u8>)> {
|
||
|
|
// Decode image in blocking thread pool (CPU-intensive work should not block)
|
||
|
|
tokio::task::spawn_blocking(move || {
|
||
|
|
log::info!("Starting async decode of {}", path.display());
|
||
|
|
|
||
|
|
// Use ImageReader with explicit memory limits to avoid "Memory limit exceeded" errors
|
||
|
|
// Gallery mode uses the full memory budget since only one image decodes at a time
|
||
|
|
match image::ImageReader::open(&path) {
|
||
|
|
Ok(reader) => {
|
||
|
|
match reader.with_guessed_format() {
|
||
|
|
Ok(mut reader) => {
|
||
|
|
// Note: image crate uses decimal MB (1000^2), not binary MB (1024^2)
|
||
|
|
let mut limits = image::Limits::default();
|
||
|
|
limits.max_alloc = Some(GALLERY_MEMORY_LIMIT_MB * DECIMAL_MB_TO_BYTES);
|
||
|
|
reader.limits(limits);
|
||
|
|
|
||
|
|
match reader.decode() {
|
||
|
|
Ok(img) => {
|
||
|
|
let rgba = img.into_rgba8();
|
||
|
|
let width = rgba.width();
|
||
|
|
let height = rgba.height();
|
||
|
|
let pixels = rgba.into_raw();
|
||
|
|
|
||
|
|
log::info!(
|
||
|
|
"Decoded {}x{} image: {}",
|
||
|
|
width,
|
||
|
|
height,
|
||
|
|
path.display()
|
||
|
|
);
|
||
|
|
Some((path, width, height, pixels))
|
||
|
|
}
|
||
|
|
Err(e) => {
|
||
|
|
log::warn!("Failed to decode {}: {}", path.display(), e);
|
||
|
|
None
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => {
|
||
|
|
log::warn!("Failed to guess format for {}: {}", path.display(), e);
|
||
|
|
None
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => {
|
||
|
|
log::warn!("Failed to open {}: {}", path.display(), e);
|
||
|
|
None
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
.await
|
||
|
|
.ok()
|
||
|
|
.flatten()
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/// Manages state and operations for large image decoding in gallery mode
|
||
|
|
#[derive(Debug, Default)]
|
||
|
|
pub struct LargeImageManager {
|
||
|
|
/// Paths of images currently being decoded
|
||
|
|
decoding_images: HashSet<PathBuf>,
|
||
|
|
/// Cache of decoded image handles
|
||
|
|
decoded_images: HashMap<PathBuf, widget::image::Handle>,
|
||
|
|
/// Errors encountered during decoding
|
||
|
|
decode_errors: HashMap<PathBuf, String>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl LargeImageManager {
|
||
|
|
pub fn new() -> Self {
|
||
|
|
Self::default()
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn is_decoding(&self, path: &Path) -> bool {
|
||
|
|
self.decoding_images.contains(path)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn get_decoded(&self, path: &Path) -> Option<&widget::image::Handle> {
|
||
|
|
self.decoded_images.get(path)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn get_error(&self, path: &Path) -> Option<&String> {
|
||
|
|
self.decode_errors.get(path)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn mark_decoding(&mut self, path: PathBuf) {
|
||
|
|
self.decoding_images.insert(path);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn store_decoded(&mut self, path: PathBuf, handle: widget::image::Handle) {
|
||
|
|
self.decoded_images.insert(path.clone(), handle);
|
||
|
|
self.decoding_images.remove(&path);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn store_error(&mut self, path: PathBuf, error: String) {
|
||
|
|
self.decode_errors.insert(path, error);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn clear_error(&mut self, path: &Path) {
|
||
|
|
self.decode_errors.remove(path);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn clear_cache(&mut self) {
|
||
|
|
log::info!(
|
||
|
|
"Clearing {} cached images from large image manager",
|
||
|
|
self.decoded_images.len()
|
||
|
|
);
|
||
|
|
self.decoded_images.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn cache_size(&self) -> usize {
|
||
|
|
self.decoded_images.len()
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn cache_is_empty(&self) -> bool {
|
||
|
|
self.decoded_images.is_empty()
|
||
|
|
}
|
||
|
|
}
|