`d694d2d`

annotate: add chunked put_image for large screenshots

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

SHA: d694d2d1ea614de7b6d3c223fdbac0f71581224c
Parents: 431fa48
Tree: 7f5bcd2

1 changed file

Status	File	+	-
M	`garshot/src/annotate/overlay.rs`	136	26

garshot/src/annotate/overlay.rsmodified

  use crate::annotate::ui::{Toolbar, TOOLBAR_HEIGHT};
  use gartk_core::{InputEvent, Key, KeyEvent, Modifiers, MouseButton, MouseEvent, Point};
++use gartk_render::Surface;
  use gartk_x11::{Connection, CursorManager, Window, WindowConfig};
  use x11rb::connection::Connection as X11Connection;
--use x11rb::protocol::xproto::{self, AtomEnum, ConnectionExt, PropMode};
++use x11rb::protocol::xproto::{self, AtomEnum, ConnectionExt, ImageFormat, PropMode};
  use x11rb::wrapper::ConnectionExt as WrapperConnectionExt;
++/// Maximum bytes per put_image request (conservative, below typical 256KB limit).
++const MAX_PUT_IMAGE_BYTES: usize = 65536;
++
  /// Annotation overlay for editing screenshots.
  pub struct AnnotationOverlay {
      /// X11 connection.
      history: History,
      /// Toolbar UI.
      toolbar: Toolbar,
++    /// Toolbar surface (reused to avoid allocation each frame).
++    toolbar_surface: Surface,
      /// Cursor manager.
      cursor_manager: CursorManager,
      /// Whether a redraw is needed.
      /// * `width` - Image width
      /// * `height` - Image height
      pub fn new(image_data: &[u8], width: u32, height: u32) -> Result<Self> {
++        tracing::debug!("Creating annotation overlay for image {}x{}", width, height);
++
          // Connect to X11
          let conn = Connection::connect(None).context("Failed to connect to X11")?;
          // Window size = image size + toolbar height
          let window_width = width;
          let window_height = height + TOOLBAR_HEIGHT;
++        tracing::debug!("Window size will be {}x{} (including {}px toolbar)",
++            window_width, window_height, TOOLBAR_HEIGHT);
          // Center window on screen
          let screen_width = conn.screen_width();
              .map_on_create(false);
          let window = Window::create(conn.clone(), config).context("Failed to create window")?;
++        tracing::debug!("Created window {} at position ({}, {})",
++            window.id(), pos_x.max(0), pos_y.max(0));
          // Set window type to DIALOG so gar floats it automatically
          let window_type_atom = conn.inner()
          // Create initial tool
          let tool = tools::create_tool(ToolType::Arrow);
++        // Create reusable toolbar surface
++        let toolbar_surface = Surface::new(width, TOOLBAR_HEIGHT)
++            .context("Failed to create toolbar surface")?;
++
++        // Set WM_NORMAL_HINTS to lock window size (prevents WM from resizing)
++        // Flags: PMinSize (16) | PMaxSize (32) | PSize (8) = 56
++        let size_hints: [u32; 18] = [
++            56,                      // flags: PSize | PMinSize | PMaxSize
++            0, 0,                    // x, y (obsolete)
++            window_width, window_height,  // width, height (PSize)
++            window_width, window_height,  // min_width, min_height (PMinSize)
++            window_width, window_height,  // max_width, max_height (PMaxSize)
++            0, 0,                    // width_inc, height_inc
++            0, 0,                    // min_aspect_num, min_aspect_den
++            0, 0,                    // max_aspect_num, max_aspect_den
++            0, 0,                    // base_width, base_height
++            0,                       // win_gravity
++        ];
++        conn.inner().change_property32(
++            PropMode::REPLACE,
++            window.id(),
++            AtomEnum::WM_NORMAL_HINTS,
++            AtomEnum::WM_SIZE_HINTS,
++            &size_hints,
++        )?;
++        tracing::debug!("Set WM_NORMAL_HINTS: min/max {}x{}", window_width, window_height);
++
++        // Tell compositor to bypass this window (reduces effects/lag from picom)
++        let bypass_atom = conn.inner()
++            .intern_atom(false, b"_NET_WM_BYPASS_COMPOSITOR")?
++            .reply()
++            .context("Failed to intern bypass atom")?
++            .atom;
++        conn.inner().change_property32(
++            PropMode::REPLACE,
++            window.id(),
++            bypass_atom,
++            AtomEnum::CARDINAL,
++            &[1], // 1 = bypass compositor
++        )?;
++
          Ok(Self {
              conn,
              window,
              tool,
              history: History::new(),
              toolbar,
++            toolbar_surface,
              cursor_manager,
              needs_redraw: true,
              image_offset_y: TOOLBAR_HEIGHT as i32,
          // Event loop
          loop {
--            // Wait for event
++            // Wait for first event
              let event = self.conn.inner().wait_for_event()?;
++            let mut needs_redraw = false;
--            // Translate to InputEvent
++            // Translate and handle the first event
              if let Some(input_event) = self.translate_event(&event) {
--                let needs_redraw = self.handle_event(input_event)?;
++                needs_redraw |= self.handle_event(input_event)?;
++            }
--                if needs_redraw {
++            // Check if finished after first event
--                    self.redraw()?;
++            if self.state.is_finished() {
++                break;
++            }
++
++            // Process all pending events before redrawing (batching)
++            while let Some(event) = self.conn.inner().poll_for_event()? {
++                if let Some(input_event) = self.translate_event(&event) {
++                    needs_redraw |= self.handle_event(input_event)?;
++                }
++                if self.state.is_finished() {
++                    break;
+                 }
+             }
++            // Single redraw for all batched events
++            if needs_redraw {
++                self.redraw()?;
++            }
++
              // Check if finished
              if self.state.is_finished() {
                  break;
          let width = self.canvas.width();
          let height = self.canvas.height();
--        // Create toolbar surface and draw toolbar
++        // Draw toolbar to reusable surface
--        let toolbar_surface = gartk_render::Surface::new(width, TOOLBAR_HEIGHT)?;
++        self.toolbar.draw(&self.toolbar_surface)?;
--        self.toolbar.draw(&toolbar_surface)?;
          // Get toolbar data and convert to BGRA
--        let mut toolbar_surface = toolbar_surface;
++        let toolbar_data = self.toolbar_surface.to_rgba()?;
--        let toolbar_data = toolbar_surface.to_rgba()?;
++        let toolbar_bgra = rgba_to_bgra(&toolbar_data);
--        let mut toolbar_bgra: Vec<u8> = toolbar_data;
--        for chunk in toolbar_bgra.chunks_exact_mut(4) {
--            chunk.swap(0, 2);
--        }
--        // Blit toolbar at y=0
++        // Blit toolbar at y=0 (toolbar is small, no chunking needed)
          self.conn.inner().put_image(
--            xproto::ImageFormat::Z_PIXMAP,
++            ImageFormat::Z_PIXMAP,
              self.window.id(),
              self.gc,
              width as u16,
          // Get image composite data
          let surface = self.canvas.composite_surface_mut();
          let data = surface.to_rgba()?;
--        let mut bgra: Vec<u8> = data;
++        let bgra = rgba_to_bgra(&data);
--        for chunk in bgra.chunks_exact_mut(4) {
--            chunk.swap(0, 2);
--        }
--        // Blit image at y=TOOLBAR_HEIGHT
++        // Blit image at y=TOOLBAR_HEIGHT using chunked put_image for large images
--        self.conn.inner().put_image(
++        put_image_chunked(
--            xproto::ImageFormat::Z_PIXMAP,
++            self.conn.inner(),
              self.window.id(),
              self.gc,
              width as u16,
              height as u16,
 ,
              self.image_offset_y as i16,
--            0,
--            24,
              &bgra,
          )?;
          Ok(())
+     }
+ }
++
++/// Convert RGBA to BGRA (X11 native format).
++fn rgba_to_bgra(data: &[u8]) -> Vec<u8> {
++    let mut bgra = data.to_vec();
++    for chunk in bgra.chunks_exact_mut(4) {
++        chunk.swap(0, 2); // Swap R and B
++    }
++    bgra
++}
++
++/// Put image data in chunks to avoid exceeding X11 max request size.
++fn put_image_chunked<C: X11Connection>(
++    conn: &C,
++    drawable: u32,
++    gc: u32,
++    width: u16,
++    height: u16,
++    dst_x: i16,
++    dst_y: i16,
++    data: &[u8],
++) -> Result<()> {
++    let bytes_per_row = width as usize * 4;
++    let rows_per_chunk = (MAX_PUT_IMAGE_BYTES / bytes_per_row).max(1);
++
++    let mut y = 0u16;
++    while (y as usize) < height as usize {
++        let chunk_height = ((height as usize - y as usize).min(rows_per_chunk)) as u16;
++        let start = y as usize * bytes_per_row;
++        let end = start + chunk_height as usize * bytes_per_row;
++        let chunk_data = &data[start..end];
++
++        conn.put_image(
++            ImageFormat::Z_PIXMAP,
++            drawable,
++            gc,
++            width,
++            chunk_height,
++            dst_x,
++            dst_y + y as i16,
++            0,
++            24,
++            chunk_data,
++        )?;
++
++        y += chunk_height;
++    }
++
++    Ok(())
++}