`4f987ab`

apply memory budget to AnimationLoop CLI path to prevent OOM

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 4f987aba17b4c03229da1340cd6721eab9276f55
Parents: 901b4c8
Tree: c9592b4

1 changed file

Status	File	+	-
M	`garbg/src/daemon/animation_loop.rs`	64	19

garbg/src/daemon/animation_loop.rsmodified

  use crate::media::{scale_image_fast, AnimatedGif};
  use crate::x11::{AnimationRenderer, Connection};
++/// Default memory budget for pre-scaled animation frames (256 MB)
++const DEFAULT_MEMORY_BUDGET: u64 = 256 * 1024 * 1024;
++
  /// Configuration for the animation loop
  #[derive(Debug, Clone)]
  pub struct AnimationConfig {
      gif: AnimatedGif,
      /// X11 animation renderer
      renderer: AnimationRenderer,
--    /// Pre-scaled frames (cached)
++    /// Pre-scaled frames (empty if streaming mode)
      scaled_frames: Vec<image::RgbaImage>,
++    /// Whether to scale frames on-the-fly instead of pre-scaling
++    streaming: bool,
++    /// Screen dimensions (used for on-the-fly scaling)
++    screen_width: u32,
++    screen_height: u32,
      /// Configuration
      config: AnimationConfig,
      /// Whether the animation is paused
      ) -> Result<Self> {
          let renderer = AnimationRenderer::new(conn)?;
          let (screen_width, screen_height) = renderer.dimensions();
--
++        let sw = screen_width as u32;
--        // Pre-scale all frames
++        let sh = screen_height as u32;
--        let scaled_frames: Vec<image::RgbaImage> = gif
++
--            .frames()
++        let per_frame_bytes = sw as u64 * sh as u64 * 4;
--            .iter()
++        let total_bytes = per_frame_bytes * gif.frame_count() as u64;
--            .map(|frame| {
++
--                scale_image_fast(
++        let (scaled_frames, streaming) = if total_bytes <= DEFAULT_MEMORY_BUDGET {
--                    &frame.image,
++            tracing::info!(
--                    screen_width as u32,
++                "Animation fits in memory budget ({:.1} MB), pre-scaling all {} frames",
--                    screen_height as u32,
++                total_bytes as f64 / (1024.0 * 1024.0),
--                    config.scale_mode,
++                gif.frame_count(),
--                )
++            );
--            })
++            let frames: Vec<image::RgbaImage> = gif
--            .collect();
++                .frames()
++                .iter()
++                .map(|frame| {
++                    scale_image_fast(&frame.image, sw, sh, config.scale_mode)
++                })
++                .collect();
++            (frames, false)
++        } else {
++            tracing::info!(
++                "Animation exceeds memory budget ({:.1} MB > {:.1} MB), scaling frames on-the-fly",
++                total_bytes as f64 / (1024.0 * 1024.0),
++                DEFAULT_MEMORY_BUDGET as f64 / (1024.0 * 1024.0),
++            );
++            (Vec::new(), true)
++        };
          Ok(Self {
              gif,
              renderer,
              scaled_frames,
++            streaming,
++            screen_width: sw,
++            screen_height: sh,
              config,
              paused: Arc::new(AtomicBool::new(false)),
              stop: Arc::new(AtomicBool::new(false)),
+             }
              // Render current frame
--            let scaled_frame = &self.scaled_frames[frame_index];
++            if self.streaming {
--            self.renderer.render_and_present(conn, scaled_frame)?;
++                let scaled = scale_image_fast(
++                    &self.gif.frames()[frame_index].image,
++                    self.screen_width,
++                    self.screen_height,
++                    self.config.scale_mode,
++                );
++                self.renderer.render_and_present(conn, &scaled)?;
++            } else {
++                let scaled_frame = &self.scaled_frames[frame_index];
++                self.renderer.render_and_present(conn, scaled_frame)?;
++            }
              // Get delay for current frame
              let frame_delay = self.gif.frames()[frame_index].delay;
+         }
          let frame_index = self.gif.current_index();
--        let scaled_frame = &self.scaled_frames[frame_index];
          // Render current frame
--        self.renderer.render_and_present(conn, scaled_frame)?;
++        if self.streaming {
++            let scaled = scale_image_fast(
++                &self.gif.frames()[frame_index].image,
++                self.screen_width,
++                self.screen_height,
++                self.config.scale_mode,
++            );
++            self.renderer.render_and_present(conn, &scaled)?;
++        } else {
++            let scaled_frame = &self.scaled_frames[frame_index];
++            self.renderer.render_and_present(conn, scaled_frame)?;
++        }
          // Get delay for current frame
          let delay = self.gif.current_frame().delay;