add extra trace logs, mirrors to support MainThreadWlxCapture

wlx-capture/src/pipewire.rs

@@ -47,12 +47,14 @@ use crate::frame::Transform;
 use crate::frame::WlxFrame;
 use crate::frame::{DmabufFrame, FramePlane, MemFdFrame, MemPtrFrame};
 
+#[derive(Debug, Clone)]
 pub struct PipewireStream {
     pub node_id: u32,
     pub position: Option<(i32, i32)>,
     pub size: Option<(i32, i32)>,
 }
 
+#[derive(Debug, Clone)]
 pub struct PipewireSelectScreenResult {
     pub streams: Vec<PipewireStream>,
     pub restore_token: Option<String>,
@@ -279,6 +281,7 @@ where
     U: Any,
     R: Any,
 {
+    log::debug!("{}: pipewire main_loop start", &name);
     let main_loop = MainLoop::new(None)?;
     let context = Context::new(&main_loop)?;
     let core = context.connect(None)?;

wlx-overlay-s/src/backend/openxr/mod.rs

@@ -238,6 +238,7 @@ pub fn openxr_run(show_by_default: bool, headless: bool) -> Result<(), BackendEr
 
         if !session_running {
             std::thread::sleep(Duration::from_millis(100));
+            log::trace!("session not running: continue");
             continue 'main_loop;
         }
 
@@ -387,10 +388,12 @@ pub fn openxr_run(show_by_default: bool, headless: bool) -> Result<(), BackendEr
         for o in overlays.values_mut() {
             o.data.cur_visible = false;
             let Some(alpha) = o.config.active_state.as_ref().map(|x| x.alpha) else {
+                log::trace!("{}: hidden, skip render", o.config.name);
                 continue;
             };
 
             if !o.data.init {
+                log::trace!("{}: init", o.config.name);
                 o.init(&mut app)?;
                 o.data.init = true;
             }
@@ -400,8 +403,10 @@ pub fn openxr_run(show_by_default: bool, headless: bool) -> Result<(), BackendEr
                 ShouldRender::Can => (o.data.last_alpha - alpha).abs() > f32::EPSILON,
                 ShouldRender::Unable => false, //try show old image if exists
             };
+            log::trace!("{}: should_render returned: {should_render}", o.config.name);
 
             if should_render {
+                log::trace!("{}: render new frame", o.config.name);
                 let meta = o.config.backend.frame_meta().unwrap(); // want panic
                 let wsi = o.ensure_swapchain_acquire(&app, &xr_state, meta.extent)?;
                 let tgt = RenderTarget { views: wsi.views };
@@ -410,7 +415,10 @@ pub fn openxr_run(show_by_default: bool, headless: bool) -> Result<(), BackendEr
                 o.data.last_alpha = alpha;
                 futures.execute_results(rdr.end()?)?;
             } else if o.data.swapchain.is_none() {
+                log::trace!("{}: not showing due to missing swapchain", o.config.name);
                 continue;
+            } else {
+                log::trace!("{}: showing stale frame", o.config.name);
             }
             o.data.cur_visible = true;
         }

wlx-overlay-s/src/gui/panel/button.rs

@@ -174,11 +174,14 @@ pub(super) fn setup_custom_button<S: 'static>(
                     return Ok(EventResult::Pass);
                 }
 
-                let name = crate::overlays::mirror::new_mirror_name();
+                let name = crate::overlays::screen::mirror::new_mirror_name();
                 app.tasks.enqueue(TaskType::Overlay(OverlayTask::Create(
                     OverlaySelector::Name(name.clone()),
                     Box::new(move |app| {
-                        Some(crate::overlays::mirror::new_mirror(name, &app.session))
+                        Some(crate::overlays::screen::mirror::new_mirror(
+                            name,
+                            &app.session,
+                        ))
                     }),
                 )));
                 Ok(EventResult::Consumed)

wlx-overlay-s/src/overlays/mod.rs

@@ -2,8 +2,6 @@ pub mod anchor;
 pub mod custom;
 pub mod edit;
 pub mod keyboard;
-#[cfg(feature = "wayland")]
-pub mod mirror;
 pub mod screen;
 pub mod toast;
 pub mod watch;

wlx-overlay-s/src/overlays/screen/backend.rs

@@ -215,6 +215,7 @@ impl OverlayBackend for ScreenBackend {
                 Ok(ShouldRender::Can)
             }
         } else {
+            log::trace!("{}: backend ready, but no image received.", self.name);
             Ok(ShouldRender::Unable)
         }
     }

wlx-overlay-s/src/overlays/screen/mirror.rs

@@ -8,7 +8,10 @@ use std::{
 
 use futures::{Future, FutureExt};
 use glam::{Affine2, Affine3A, Quat, Vec3, vec3};
-use wlx_capture::pipewire::{PipewireCapture, PipewireSelectScreenResult, pipewire_select_screen};
+use wlx_capture::{
+    WlxCapture,
+    pipewire::{PipewireCapture, PipewireSelectScreenResult, pipewire_select_screen},
+};
 use wlx_common::{
     overlays::{BackendAttrib, BackendAttribValue},
     windowing::OverlayWindowState,
@@ -19,6 +22,7 @@ use crate::{
         input::{HoverResult, PointerHit},
         task::{OverlayTask, TaskType},
     },
+    overlays::screen::capture::{MainThreadWlxCapture, new_wlx_capture},
     state::{AppSession, AppState},
     subsystem::hid::WheelDelta,
     windowing::{
@@ -31,7 +35,7 @@ use crate::{
     },
 };
 
-use super::screen::backend::ScreenBackend;
+use super::backend::ScreenBackend;
 type PinnedSelectorFuture = core::pin::Pin<
     Box<dyn Future<Output = Result<PipewireSelectScreenResult, wlx_capture::pipewire::AshpdError>>>,
 >;
@@ -76,13 +80,21 @@ impl OverlayBackend for MirrorBackend {
 
             match maybe_pw_result {
                 Ok(pw_result) => {
+                    log::debug!(
+                        "{}: PipeWire result streams: {:?}",
+                        self.name,
+                        &pw_result.streams
+                    );
                     let node_id = pw_result.streams.first().unwrap().node_id; // streams guaranteed to have at least one element
-                    log::info!("{}: PipeWire node selected: {}", self.name.clone(), node_id);
+                    log::info!("{}: PipeWire node selected: {}", self.name, node_id);
-                    let capture = PipewireCapture::new(self.name.clone(), node_id);
+                    let capture = new_wlx_capture!(
+                        app.gfx_extras.queue_capture,
+                        PipewireCapture::new(self.name.clone(), node_id)
+                    );
                     self.renderer = Some(ScreenBackend::new_raw(
                         self.name.clone(),
                         app.xr_backend,
-                        Box::new(capture),
+                        capture,
                     ));
                     app.tasks.enqueue(TaskType::Overlay(OverlayTask::Modify(
                         OverlaySelector::Name(self.name.clone()),

wlx-overlay-s/src/overlays/screen/mod.rs

@@ -15,6 +15,8 @@ use crate::{
 
 pub mod backend;
 mod capture;
+#[cfg(feature = "wayland")]
+pub mod mirror;
 #[cfg(feature = "pipewire")]
 pub mod pw;
 #[cfg(feature = "wayland")]

wlx-overlay-s/src/overlays/screen/pw.rs

@@ -42,6 +42,12 @@ impl ScreenBackend {
             false,
         )?;
 
+        log::debug!(
+            "{}: PipeWire result streams: {:?}",
+            output.name,
+            &select_screen_result.streams
+        );
+
         let node_id = select_screen_result.streams.first().unwrap().node_id; // streams guaranteed to have at least one element
 
         let capture = new_wlx_capture!(

wlx-overlay-s/src/windowing/backend.rs

@@ -27,6 +27,7 @@ pub struct FrameMeta {
     pub clear: WGfxClearMode,
 }
 
+#[derive(Debug, Clone, Copy)]
 pub enum ShouldRender {
     /// The overlay is dirty and needs to be rendered.
     Should,