`901b4c8`

stream-scale animation frames to prevent OOM on large/multi-monitor setups

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

SHA: 901b4c893f3079951fa3305fae455b925fba2eaa
Parents: 76ffb7a
Tree: b45f047

1 changed file

Status	File	+	-
M	`garbg/src/daemon/state.rs`	181	33

garbg/src/daemon/state.rsmodified

  //! Daemon state management
  use anyhow::{Context, Result};
++use crossbeam_channel::Receiver;
  use std::collections::HashMap;
++use std::sync::Arc;
++use std::thread::JoinHandle;
  use std::time::Duration;
  use tokio::net::UnixStream;
  use tokio::signal::unix::{signal, SignalKind};
+     }
+ }
++/// Frame source strategy for animation playback
++enum FrameSource {
++    /// All frames pre-scaled in memory (small animations within memory budget)
++    Preloaded {
++        scaled_frames: Vec<image::RgbaImage>,
++        frame_delays: Vec<Duration>,
++        current_frame: usize,
++    },
++    /// Frames scaled on demand by a background producer thread (large animations)
++    Streaming {
++        /// Receiver for scaled frames from the producer
++        rx: Receiver<(image::RgbaImage, Duration)>,
++        /// Handle to the producer thread (dropped = detached, thread exits on send error)
++        _producer: JoinHandle<()>,
++        /// The last successfully received frame (re-displayed if producer is behind)
++        last_frame: Option<image::RgbaImage>,
++        /// Delay of the last frame
++        last_delay: Duration,
++        /// Total frame count (for logging)
++        #[allow(dead_code)]
++        frame_count: usize,
++    },
++}
++
  /// Active animation state (works with GIF, WebP, or other animated formats)
  pub struct ActiveAnimation {
--    /// Pre-scaled frames for quick rendering
++    /// Frame source (preloaded or streaming)
--    scaled_frames: Vec<image::RgbaImage>,
++    frame_source: FrameSource,
--    /// Frame delays (parallel to scaled_frames)
--    frame_delays: Vec<Duration>,
      /// Animation renderer (double-buffered)
      renderer: AnimationRenderer,
--    /// Current frame index
--    current_frame: usize,
      /// Max FPS
      max_fps: u32,
      /// Scale mode (for status)
+ }
  impl ActiveAnimation {
--    /// Create from animation frames (scales in parallel with fast filter)
++    /// Create from animation frames, choosing pre-load or streaming based on memory budget
      fn from_frames(
          frames: &[AnimationFrame],
          renderer: AnimationRenderer,
          source: String,
          screen_width: u32,
          screen_height: u32,
++        memory_budget: u64,
      ) -> Self {
--        // Scale frames in parallel, limited to available CPU cores
++        let per_frame_bytes = screen_width as u64 * screen_height as u64 * 4;
++        let total_bytes = per_frame_bytes * frames.len() as u64;
++
++        let frame_source = if total_bytes <= memory_budget {
++            tracing::info!(
++                "Animation fits in memory budget ({:.1} MB <= {:.1} MB), pre-scaling all {} frames",
++                total_bytes as f64 / (1024.0 * 1024.0),
++                memory_budget as f64 / (1024.0 * 1024.0),
++                frames.len(),
++            );
++            Self::preload_frames(frames, screen_width, screen_height, scale_mode)
++        } else {
++            let max_buffered = (memory_budget / 2 / per_frame_bytes).max(2).min(8) as usize;
++            tracing::info!(
++                "Animation exceeds memory budget ({:.1} MB > {:.1} MB), streaming with {} frame buffer",
++                total_bytes as f64 / (1024.0 * 1024.0),
++                memory_budget as f64 / (1024.0 * 1024.0),
++                max_buffered,
++            );
++            Self::stream_frames(frames, screen_width, screen_height, scale_mode, max_buffered)
++        };
++
++        Self {
++            frame_source,
++            renderer,
++            max_fps,
++            scale_mode,
++            source,
++        }
++    }
++
++    /// Pre-scale all frames in parallel (existing behavior, for small animations)
++    fn preload_frames(
++        frames: &[AnimationFrame],
++        screen_width: u32,
++        screen_height: u32,
++        scale_mode: ScaleMode,
++    ) -> FrameSource {
          let num_cpus = std::thread::available_parallelism()
              .map(|n| n.get())
              .unwrap_or(4);
++
          let scaled_frames: Vec<image::RgbaImage> = std::thread::scope(|s| {
              let mut results = Vec::with_capacity(frames.len());
--            // Process in batches of num_cpus to avoid spawning too many threads
              for chunk in frames.chunks(num_cpus) {
                  let handles: Vec<_> = chunk
                      .iter()
              results
          });
--        let frame_delays: Vec<Duration> = frames
++        let frame_delays: Vec<Duration> = frames.iter().map(|f| f.delay).collect();
--            .iter()
--            .map(|frame| frame.delay)
--            .collect();
--        Self {
++        FrameSource::Preloaded {
              scaled_frames,
              frame_delays,
--            renderer,
              current_frame: 0,
--            max_fps,
++        }
--            scale_mode,
++    }
--            source,
++
++    /// Set up streaming producer thread for large animations
++    fn stream_frames(
++        frames: &[AnimationFrame],
++        screen_width: u32,
++        screen_height: u32,
++        scale_mode: ScaleMode,
++        buffer_capacity: usize,
++    ) -> FrameSource {
++        let (tx, rx) = crossbeam_channel::bounded::<(image::RgbaImage, Duration)>(buffer_capacity);
++        let source_frames: Arc<Vec<AnimationFrame>> = Arc::new(frames.to_vec());
++        let frame_count = frames.len();
++
++        let producer = std::thread::Builder::new()
++            .name("garbg-frame-scaler".into())
++            .spawn(move || {
++                let mut index = 0usize;
++                loop {
++                    let frame = &source_frames[index % frame_count];
++                    let scaled = scale_image_fast(
++                        &frame.image,
++                        screen_width,
++                        screen_height,
++                        scale_mode,
++                    );
++                    if tx.send((scaled, frame.delay)).is_err() {
++                        tracing::debug!("Frame producer exiting: receiver dropped");
++                        break;
++                    }
++                    index += 1;
++                }
++            })
++            .expect("failed to spawn frame scaler thread");
++
++        // Block on first frame so animation starts with content
++        let (first_frame, first_delay) = rx.recv().expect("producer died before first frame");
++
++        FrameSource::Streaming {
++            rx,
++            _producer: producer,
++            last_frame: Some(first_frame),
++            last_delay: first_delay,
++            frame_count,
+         }
+     }
      /// Get the delay for the current frame
      fn current_delay(&self) -> Duration {
--        let frame_delay = self.frame_delays[self.current_frame];
++        let frame_delay = match &self.frame_source {
++            FrameSource::Preloaded { frame_delays, current_frame, .. } => {
++                frame_delays[*current_frame]
++            }
++            FrameSource::Streaming { last_delay, .. } => *last_delay,
++        };
          let min_delay = if self.max_fps > 0 {
              Duration::from_secs_f64(1.0 / self.max_fps as f64)
          } else {
      /// Advance to next frame, returning true if looped
      fn advance(&mut self) -> bool {
--        self.current_frame += 1;
++        match &mut self.frame_source {
--        if self.current_frame >= self.scaled_frames.len() {
++            FrameSource::Preloaded { scaled_frames, current_frame, .. } => {
--            self.current_frame = 0;
++                *current_frame += 1;
--            true
++                if *current_frame >= scaled_frames.len() {
--        } else {
++                    *current_frame = 0;
--            false
++                    true
++                } else {
++                    false
++                }
++            }
++            FrameSource::Streaming { rx, last_frame, last_delay, .. } => {
++                match rx.try_recv() {
++                    Ok((frame, delay)) => {
++                        *last_frame = Some(frame);
++                        *last_delay = delay;
++                    }
++                    Err(crossbeam_channel::TryRecvError::Empty) => {
++                        tracing::trace!("Frame producer behind, re-displaying last frame");
++                    }
++                    Err(crossbeam_channel::TryRecvError::Disconnected) => {
++                        tracing::warn!("Frame producer disconnected");
++                    }
++                }
++                false
++            }
+         }
+     }
      /// Get frame count
      #[allow(dead_code)]
      fn frame_count(&self) -> usize {
--        self.scaled_frames.len()
++        match &self.frame_source {
++            FrameSource::Preloaded { scaled_frames, .. } => scaled_frames.len(),
++            FrameSource::Streaming { frame_count, .. } => *frame_count,
++        }
+     }
+ }
          let anim = self.animation.as_mut()
              .ok_or_else(|| anyhow::anyhow!("No active animation"))?;
--        // Render current frame
++        // Render current frame (inline match for split borrowing of frame_source vs renderer)
--        let frame = &anim.scaled_frames[anim.current_frame];
++        match &anim.frame_source {
--        anim.renderer.render_and_present(conn, frame)?;
++            FrameSource::Preloaded { scaled_frames, current_frame, .. } => {
++                anim.renderer.render_and_present(conn, &scaled_frames[*current_frame])?;
++            }
++            FrameSource::Streaming { last_frame, .. } => {
++                if let Some(frame) = last_frame {
++                    anim.renderer.render_and_present(conn, frame)?;
++                }
++            }
++        }
          // Advance to next frame
          anim.advance();
          let renderer = AnimationRenderer::new(conn)?;
          let (width, height) = conn.screen_dimensions();
++        let per_frame_mb = (width as f64 * height as f64 * 4.0) / (1024.0 * 1024.0);
          tracing::info!(
--            "Animation loaded: {} frames, {:.1} FPS ({})",
++            "Animation loaded: {} frames, {:.1} FPS ({}), screen {}x{}, {:.1} MB/frame, {:.1} MB total",
              frame_count,
              avg_fps,
--            format_name
++            format_name,
++            width,
++            height,
++            per_frame_mb,
++            per_frame_mb * frame_count as f64,
          );
++        let memory_budget = self.state.config.animation.memory_budget_mb * 1024 * 1024;
          self.animation = Some(ActiveAnimation::from_frames(
              &frames,
              renderer,
              source.to_string(),
              width as u32,
              height as u32,
++            memory_budget,
          ));
          Ok(())
          let renderer = AnimationRenderer::new(conn)?;
          let (width, height) = conn.screen_dimensions();
++        let per_frame_mb = (width as f64 * height as f64 * 4.0) / (1024.0 * 1024.0);
          tracing::info!(
--            "Video loaded: {} frames, {:.1} FPS",
++            "Video loaded: {} frames, {:.1} FPS, screen {}x{}, {:.1} MB/frame, {:.1} MB total",
              frame_count,
--            avg_fps
++            avg_fps,
++            width,
++            height,
++            per_frame_mb,
++            per_frame_mb * frame_count as f64,
          );
++        let memory_budget = self.state.config.animation.memory_budget_mb * 1024 * 1024;
          self.animation = Some(ActiveAnimation::from_frames(
              &frames,
              renderer,
              source.to_string(),
              width as u32,
              height as u32,
++            memory_budget,
          ));
          Ok(())