fix: screencopy and portal capture state handling

src/ifs/ext_image_copy/ext_image_copy_capture_frame_v1.rs

@@ -86,9 +86,7 @@ impl ExtImageCopyCaptureFrameV1 {
         let buffer = self.session.buffer.get().unwrap();
         if size != buffer.rect.size() {
             self.session.buffer_size_changed();
-            // https://gitlab.freedesktop.org/wayland/wayland-protocols/-/issues/222
+            return Err(FrameFailureReason::BufferConstraints);
-            // self.fail(FrameFailureReason::BufferConstraints);
-            // return;
         }
         if let Err(e) = buffer.update_framebuffer() {
             log::error!("Could not import buffer: {}", ErrorFmt(e));
@@ -102,6 +100,13 @@ impl ExtImageCopyCaptureFrameV1 {
         let mut shm_staging = self.session.shm_staging.take();
         match storage {
             WlBufferStorage::Shm { mem, stride, .. } => {
+                log::debug!(
+                    "ext-image-copy frame {:?} using wl_shm readback path: {}x{}, stride {}",
+                    self.id,
+                    buffer.rect.width(),
+                    buffer.rect.height(),
+                    *stride,
+                );
                 if let Some(b) = &shm_bridge
                     && (b.physical_size() != buffer.rect.size()
                         || b.format() != buffer.format
@@ -159,6 +164,12 @@ impl ExtImageCopyCaptureFrameV1 {
                 self.session.shm_staging.set(Some(staging));
             }
             WlBufferStorage::Dmabuf { fb, .. } => {
+                log::debug!(
+                    "ext-image-copy frame {:?} using dmabuf GPU copy path: {}x{}",
+                    self.id,
+                    buffer.rect.width(),
+                    buffer.rect.height(),
+                );
                 let Some(fb) = fb else {
                     return Err(FrameFailureReason::BufferConstraints);
                 };
@@ -187,7 +198,11 @@ impl ExtImageCopyCaptureFrameV1 {
     ) {
         match self.try_copy(on, size, f) {
             Ok(()) => self.session.status.set(FrameStatus::Captured),
-            Err(e) => self.fail(e),
+            Err(e) => {
+                if self.session.status.get() != FrameStatus::Failed {
+                    self.fail(e);
+                }
+            }
         }
     }
 

src/ifs/ext_image_copy/ext_image_copy_capture_session_v1.rs

@@ -83,6 +83,11 @@ impl ExtImageCopyCaptureSessionV1 {
         if self.size_debounce.replace(true) {
             return;
         }
+        if let Some(frame) = self.frame.get()
+            && let FrameStatus::Capturing | FrameStatus::Captured = self.status.get()
+        {
+            frame.fail(FrameFailureReason::BufferConstraints);
+        }
         self.force_capture.set(true);
         self.send_current_buffer_size();
         self.send_done();

src/ifs/zwlr_screencopy_frame_v1.rs

@@ -48,16 +48,13 @@ impl ZwlrScreencopyFrameV1 {
     }
 
     pub fn send_damage(&self) {
-        if let Some(output) = self.output.get() {
+        self.client.event(Damage {
-            let pos = output.pos.get();
+            self_id: self.id,
-            self.client.event(Damage {
+            x: 0,
-                self_id: self.id,
+            y: 0,
-                x: 0,
+            width: self.rect.width() as _,
-                y: 0,
+            height: self.rect.height() as _,
-                width: pos.width() as _,
+        });
-                height: pos.height() as _,
-            });
-        }
     }
 
     pub fn send_buffer(&self) {
@@ -111,10 +108,28 @@ impl ZwlrScreencopyFrameV1 {
             return Err(ZwlrScreencopyFrameV1Error::InvalidBufferFormat);
         }
         buffer.update_framebuffer()?;
-        if let Some(WlBufferStorage::Shm { stride, .. }) = buffer.storage.borrow_mut().deref()
+        match buffer.storage.borrow_mut().deref() {
-            && *stride != self.rect.width() * 4
+            Some(WlBufferStorage::Shm { stride, .. }) => {
-        {
+                if *stride != self.rect.width() * 4 {
-            return Err(ZwlrScreencopyFrameV1Error::InvalidBufferStride);
+                    return Err(ZwlrScreencopyFrameV1Error::InvalidBufferStride);
+                }
+                log::debug!(
+                    "zwlr_screencopy frame {:?} using wl_shm readback path: {}x{}, stride {}",
+                    self.id,
+                    self.rect.width(),
+                    self.rect.height(),
+                    *stride,
+                );
+            }
+            Some(WlBufferStorage::Dmabuf { .. }) => {
+                log::debug!(
+                    "zwlr_screencopy frame {:?} using dmabuf GPU copy path: {}x{}",
+                    self.id,
+                    self.rect.width(),
+                    self.rect.height(),
+                );
+            }
+            _ => {}
         }
         self.buffer.set(Some(buffer));
         if !with_damage && let Some(global) = self.output.get() {
@@ -134,6 +149,12 @@ impl ZwlrScreencopyFrameV1 {
         }
         self.pending.take();
     }
+
+    pub fn cancel(&self) {
+        self.buffer.take();
+        self.pending.take();
+        self.send_failed();
+    }
 }
 
 impl ZwlrScreencopyFrameV1RequestHandler for ZwlrScreencopyFrameV1 {

src/ifs/zwlr_screencopy_manager_v1.rs

@@ -104,8 +104,8 @@ impl ZwlrScreencopyManagerV1 {
         let Some(global) = output.global.get() else {
             return Ok(());
         };
-        let mode = global.mode.get();
+        let (width, height) = global.pixel_size();
-        let mut rect = Rect::new_sized_saturating(0, 0, mode.width, mode.height);
+        let mut rect = Rect::new_sized_saturating(0, 0, width, height);
         if let Some(region) = region {
             let scale = global.persistent.scale.get().to_f64();
             let x1 = (region.x1() as f64 * scale).round() as i32;

src/portal/ptl_screencast.rs

@@ -315,6 +315,14 @@ impl PwClientNodeOwner for StartedScreencast {
                 }
             }
         }
+        log::debug!(
+            "Portal screencast using PipeWire dmabuf GPU copy path: {} buffers, format {}, modifier 0x{:08x}, size {}x{}",
+            self.buffers.borrow().len(),
+            self.format.get().name,
+            self.modifier.get(),
+            self.width.get(),
+            self.height.get(),
+        );
         self.node
             .send_port_output_buffers(&self.port, &self.buffers.borrow());
     }
@@ -633,15 +641,18 @@ impl UsrJayScreencastOwner for StartedScreencast {
 
     fn ready(&self, ev: &Ready) {
         let idx = ev.idx as usize;
-        let buffers = &*self.buffers.borrow();
-        let pbuffers = self.port.buffers.borrow();
-        let buffer = &buffers[idx];
         let discard_buffer = || {
             self.jay_screencast.release_buffer(idx);
         };
         if !self.buffers_valid.get() {
             return;
         }
+        let buffers = self.buffers.borrow();
+        let Some(buffer) = buffers.get(idx) else {
+            log::warn!("Ignoring ready event for unknown screencast buffer {idx}");
+            return;
+        };
+        let pbuffers = self.port.buffers.borrow();
         let Some(io) = self.port.io_buffers.get() else {
             discard_buffer();
             return;
@@ -767,7 +778,7 @@ pub(super) fn add_screencast_dbus_members(
     object.add_method::<Start, _>(move |req, pr| {
         dbus_start(&state, req, pr);
     });
-    object.set_property::<AvailableSourceTypes>(Variant::U32(MONITOR.0));
+    object.set_property::<AvailableSourceTypes>(Variant::U32((MONITOR | WINDOW).0));
     object.set_property::<AvailableCursorModes>(Variant::U32(EMBEDDED.0));
     object.set_property::<version>(Variant::U32(5));
 }

src/tree/output.rs

@@ -460,9 +460,15 @@ impl OutputNode {
         }
         self.lock_surface.take();
         self.jay_outputs.clear();
-        self.screencasts.clear();
+        for screencast in self.screencasts.lock().drain_values() {
-        self.screencopies.clear();
+            screencast.do_destroy();
-        self.ext_copy_sessions.clear();
+        }
+        for screencopy in self.screencopies.lock().drain_values() {
+            screencopy.cancel();
+        }
+        for session in self.ext_copy_sessions.lock().drain_values() {
+            session.stop();
+        }
         self.ext_workspace_groups.clear();
         self.latch_event.clear();
         self.vblank_event.clear();