`31fc5ea`

Fix alpha channel for compositor overlay captures

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

Status	File	+	-
M	`garshot/src/capture/region.rs`	3	2
M	`garshot/src/capture/screen.rs`	3	2
M	`garshot/src/selection/overlay.rs`	2	1
M	`garshot/src/x11/shm.rs`	18	1

garshot/src/capture/region.rsmodified

  //! Region capture functionality.
  use crate::error::{GarshotError, Result};
 -use crate::x11::{shm::bgra_to_rgba, Connection, ShmCapture};
 +use crate::x11::{shm::bgra_to_rgba_with_alpha, Connection, ShmCapture};
  /// A rectangular region on the screen.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
      );
      let data = shm.capture(conn, clipped.x, clipped.y, clipped.width, clipped.height)?;
 -    let rgba = bgra_to_rgba(data);
 +    // Force opaque alpha when capturing from compositor overlay (which has alpha=0)
 +    let rgba = bgra_to_rgba_with_alpha(data, conn.compositor_active);
      Ok(RegionCaptureResult {
          data: rgba,

garshot/src/capture/screen.rsmodified

  //! Full screen capture functionality.
  use crate::error::Result;
 -use crate::x11::{shm::bgra_to_rgba, Connection, ShmCapture};
 +use crate::x11::{shm::bgra_to_rgba_with_alpha, Connection, ShmCapture};
  /// Capture the full screen.
  ///
      let data = shm.capture(conn, 0, 0, conn.width, conn.height)?;
      // Convert BGRA (X11 format) to RGBA (standard format)
 -    let rgba = bgra_to_rgba(data);
 +    // Force opaque alpha when capturing from compositor overlay (which has alpha=0)
 +    let rgba = bgra_to_rgba_with_alpha(data, conn.compositor_active);
      Ok(CaptureResult {
          data: rgba,

garshot/src/selection/overlay.rsmodified

      // 1. Capture current screen
      let capture_data = shm.capture(conn, 0, 0, conn.width, conn.height)?;
      // Convert BGRA to RGBA and copy to owned buffer
 -    let original_data = crate::x11::shm::bgra_to_rgba(capture_data);
 +    // Force opaque alpha when capturing from compositor overlay (which has alpha=0)
 +    let original_data = crate::x11::shm::bgra_to_rgba_with_alpha(capture_data, conn.compositor_active);
      // 2. Apply blur for overlay background
      let mut blurred_data = original_data.clone();

garshot/src/x11/shm.rsmodified

  /// This is necessary because X11 returns pixels in BGRA format, but most
  /// image formats expect RGBA.
  pub fn bgra_to_rgba(data: &[u8]) -> Vec<u8> {
 +    bgra_to_rgba_with_alpha(data, false)
 +}
++
 +/// Convert BGRA pixel data (X11 format) to RGBA, optionally forcing opaque alpha.
 +///
 +/// When `force_opaque` is true, all alpha values are set to 255. This is needed
 +/// when capturing from the compositor overlay window, which returns valid RGB
 +/// data but with alpha=0 (transparent).
 +pub fn bgra_to_rgba_with_alpha(data: &[u8], force_opaque: bool) -> Vec<u8> {
      let mut rgba = Vec::with_capacity(data.len());
      for chunk in data.chunks_exact(4) {
          rgba.push(chunk[2]); // R (was B)
          rgba.push(chunk[1]); // G
          rgba.push(chunk[0]); // B (was R)
 -        rgba.push(chunk[3]); // A
 +        rgba.push(if force_opaque { 255 } else { chunk[3] }); // A
+     }
      rgba
  /// Convert BGRA pixel data to RGBA in place.
  pub fn bgra_to_rgba_inplace(data: &mut [u8]) {
 +    bgra_to_rgba_inplace_with_alpha(data, false)
 +}
++
 +/// Convert BGRA pixel data to RGBA in place, optionally forcing opaque alpha.
 +pub fn bgra_to_rgba_inplace_with_alpha(data: &mut [u8], force_opaque: bool) {
      for chunk in data.chunks_exact_mut(4) {
          chunk.swap(0, 2); // Swap B and R
 +        if force_opaque {
 +            chunk[3] = 255;
 +        }
+     }
+ }