// SPDX-License-Identifier: GPL-3.0-only use crate::{ backend::{kms::KmsState, winit::WinitState, x11::X11State}, config::{Config, OutputConfig}, shell::{layout::floating::SeatMoveGrabState, Shell}, utils::prelude::*, wayland::protocols::{ drm::WlDrmState, output_configuration::OutputConfigurationState, screencopy::{BufferParams, ScreencopyState, Session as ScreencopySession}, workspace::WorkspaceClientState, }, xwayland::XWaylandState, }; use cosmic_protocols::screencopy::v1::server::zcosmic_screencopy_manager_v1::CursorMode; #[cfg(feature = "debug")] use smithay::utils::Rectangle; use smithay::{ backend::{ drm::DrmNode, renderer::{ element::{ default_primary_scanout_output_compare, utils::select_dmabuf_feedback, RenderElementStates, }, glow::GlowRenderer, }, }, desktop::utils::{ send_dmabuf_feedback_surface_tree, send_frames_surface_tree, surface_presentation_feedback_flags_from_states, surface_primary_scanout_output, take_presentation_feedback_surface_tree, update_surface_primary_scanout_output, with_surfaces_surface_tree, OutputPresentationFeedback, }, input::{pointer::CursorImageStatus, Seat, SeatState}, output::{Mode as OutputMode, Output, Scale}, reexports::{ calloop::{LoopHandle, LoopSignal}, wayland_protocols_misc::server_decoration::server::org_kde_kwin_server_decoration_manager::Mode, wayland_server::{ backend::{ClientData, ClientId, DisconnectReason}, protocol::wl_shm, Display, DisplayHandle, }, }, utils::{Clock, IsAlive, Monotonic}, wayland::{ compositor::CompositorState, data_device::DataDeviceState, dmabuf::{DmabufFeedback, DmabufState}, keyboard_shortcuts_inhibit::KeyboardShortcutsInhibitState, output::OutputManagerState, presentation::PresentationState, primary_selection::PrimarySelectionState, shell::{kde::decoration::KdeDecorationState, xdg::decoration::XdgDecorationState}, shm::ShmState, viewporter::ViewporterState, }, }; use tracing::error; use std::{cell::RefCell, ffi::OsString, time::Duration}; use std::{collections::VecDeque, time::Instant}; pub struct ClientState { pub workspace_client_state: WorkspaceClientState, pub drm_node: Option, pub privileged: bool, } impl ClientData for ClientState { fn initialized(&self, _client_id: ClientId) {} fn disconnected(&self, _client_id: ClientId, _reason: DisconnectReason) {} } pub struct Data { pub display: Display, pub state: State, } pub struct State { pub backend: BackendData, pub common: Common, } pub struct Common { pub config: Config, pub socket: OsString, pub display_handle: DisplayHandle, pub event_loop_handle: LoopHandle<'static, Data>, pub event_loop_signal: LoopSignal, //pub output_conf: ConfigurationManager, pub shell: Shell, seats: Vec>, last_active_seat: Option>, pub clock: Clock, pub should_stop: bool, #[cfg(feature = "debug")] pub egui: Egui, // wayland state pub compositor_state: CompositorState, pub data_device_state: DataDeviceState, pub dmabuf_state: DmabufState, pub keyboard_shortcuts_inhibit_state: KeyboardShortcutsInhibitState, pub output_state: OutputManagerState, pub output_configuration_state: OutputConfigurationState, pub presentation_state: PresentationState, pub primary_selection_state: PrimarySelectionState, pub screencopy_state: ScreencopyState, pub seat_state: SeatState, pub shm_state: ShmState, pub wl_drm_state: WlDrmState, pub viewporter_state: ViewporterState, pub kde_decoration_state: KdeDecorationState, pub xdg_decoration_state: XdgDecorationState, // xwayland state pub xwayland_state: Option, } pub enum BackendData { X11(X11State), Winit(WinitState), Kms(KmsState), // TODO // Wayland(WaylandState), Unset, } pub struct SurfaceDmabufFeedback { pub render_feedback: DmabufFeedback, pub scanout_feedback: DmabufFeedback, } impl BackendData { pub fn kms(&mut self) -> &mut KmsState { match self { BackendData::Kms(ref mut kms_state) => kms_state, _ => unreachable!("Called kms in non kms backend"), } } pub fn x11(&mut self) -> &mut X11State { match self { BackendData::X11(ref mut x11_state) => x11_state, _ => unreachable!("Called x11 in non x11 backend"), } } pub fn winit(&mut self) -> &mut WinitState { match self { BackendData::Winit(ref mut winit_state) => winit_state, _ => unreachable!("Called winit in non winit backend"), } } pub fn apply_config_for_output( &mut self, output: &Output, test_only: bool, shell: &mut Shell, seats: impl Iterator>, loop_handle: &LoopHandle<'_, Data>, ) -> Result<(), anyhow::Error> { let result = match self { BackendData::Kms(ref mut state) => { state.apply_config_for_output(output, seats, shell, test_only, loop_handle) } BackendData::Winit(ref mut state) => state.apply_config_for_output(output, test_only), BackendData::X11(ref mut state) => state.apply_config_for_output(output, test_only), _ => unreachable!("No backend set when applying output config"), }; if result.is_ok() { // apply to Output let final_config = output .user_data() .get::>() .unwrap() .borrow(); let mode = Some(OutputMode { size: final_config.mode_size(), refresh: final_config.mode_refresh() as i32, }) .filter(|m| match output.current_mode() { None => true, Some(c_m) => m.size != c_m.size || m.refresh != c_m.refresh, }); let transform = Some(final_config.transform.into()).filter(|x| *x != output.current_transform()); let scale = Some(final_config.scale) .filter(|x| *x != output.current_scale().fractional_scale()); let location = Some(final_config.position.into()).filter(|x| *x != output.current_location()); output.change_current_state(mode, transform, scale.map(Scale::Fractional), location); } result } pub fn schedule_render( &mut self, loop_handle: &LoopHandle<'_, Data>, output: &Output, screencopy: Option>, ) { match self { BackendData::Winit(ref mut state) => state.pending_screencopy(screencopy), // We cannot do this on the winit backend. // Winit has a very strict render-loop and skipping frames breaks atleast the wayland winit-backend. // Swapping with damage (which should be empty on these frames) is likely good enough anyway. BackendData::X11(ref mut state) => state.schedule_render(output, screencopy), BackendData::Kms(ref mut state) => { if let Err(err) = state.schedule_render(loop_handle, output, None, screencopy) { error!(?err, "Failed to schedule event, are we shutting down?"); } } _ => unreachable!("No backend was initialized"), } } } impl State { pub fn new( dh: &DisplayHandle, socket: OsString, handle: LoopHandle<'static, Data>, signal: LoopSignal, ) -> State { let clock = Clock::new().expect("Failed to initialize clock"); let config = Config::load(); let compositor_state = CompositorState::new::(dh); let data_device_state = DataDeviceState::new::(dh); let dmabuf_state = DmabufState::new(); let keyboard_shortcuts_inhibit_state = KeyboardShortcutsInhibitState::new::(dh); let output_state = OutputManagerState::new_with_xdg_output::(dh); let output_configuration_state = OutputConfigurationState::new(dh, |_| true); let presentation_state = PresentationState::new::(dh, clock.id() as u32); let primary_selection_state = PrimarySelectionState::new::(dh); let screencopy_state = ScreencopyState::new::( dh, vec![CursorMode::Embedded, CursorMode::Hidden], |_| true, ); // TODO: privileged let shm_state = ShmState::new::(dh, vec![wl_shm::Format::Xbgr8888, wl_shm::Format::Abgr8888]); let seat_state = SeatState::::new(); let viewporter_state = ViewporterState::new::(dh); let wl_drm_state = WlDrmState; let kde_decoration_state = KdeDecorationState::new::(&dh, Mode::Client); let xdg_decoration_state = XdgDecorationState::new::(&dh); let shell = Shell::new(&config, dh); State { common: Common { config, socket, display_handle: dh.clone(), event_loop_handle: handle, event_loop_signal: signal, shell, seats: Vec::new(), last_active_seat: None, clock, should_stop: false, #[cfg(feature = "debug")] egui: Egui { active: false, state: smithay_egui::EguiState::new(Rectangle::from_loc_and_size( (0, 0), (800, 600), )), }, compositor_state, data_device_state, dmabuf_state, screencopy_state, shm_state, seat_state, keyboard_shortcuts_inhibit_state, output_state, output_configuration_state, presentation_state, primary_selection_state, viewporter_state, wl_drm_state, kde_decoration_state, xdg_decoration_state, xwayland_state: None, }, backend: BackendData::Unset, } } pub fn new_client_state(&self) -> ClientState { ClientState { workspace_client_state: WorkspaceClientState::default(), drm_node: match &self.backend { BackendData::Kms(kms_state) => { match std::env::var("COSMIC_RENDER_AUTO_ASSIGN").map(|val| val.to_lowercase()) { Ok(val) if val == "y" || val == "yes" || val == "true" => Some( kms_state .target_node_for_output( &self.common.last_active_seat().active_output(), ) .unwrap_or(kms_state.primary), ), _ => Some(kms_state.primary), } } _ => None, }, privileged: false, } } pub fn new_client_state_with_node(&self, drm_node: DrmNode) -> ClientState { ClientState { workspace_client_state: WorkspaceClientState::default(), drm_node: Some(drm_node), privileged: false, } } pub fn new_privileged_client_state(&self) -> ClientState { ClientState { workspace_client_state: WorkspaceClientState::default(), drm_node: match &self.backend { BackendData::Kms(kms_state) => Some(kms_state.primary), _ => None, }, privileged: true, } } } impl Common { pub fn add_seat(&mut self, seat: Seat) { if self.seats.is_empty() { self.last_active_seat = Some(seat.clone()); } self.seats.push(seat); } pub fn remove_seat(&mut self, seat: &Seat) { self.seats.retain(|s| s != seat); if self.seats.is_empty() { self.last_active_seat = None; } else if self.last_active_seat() == seat { self.last_active_seat = Some(self.seats[0].clone()); } } pub fn seats(&self) -> impl Iterator> { self.seats.iter() } pub fn last_active_seat(&self) -> &Seat { self.last_active_seat.as_ref().expect("No seat?") } pub fn send_frames( &self, output: &Output, render_element_states: &RenderElementStates, dmabuf_feedback: Option<&SurfaceDmabufFeedback>, ) { let time = self.clock.now(); let throttle = Some(Duration::from_secs(1)); for seat in self.seats.iter() { if &seat.active_output() == output { let cursor_status = seat .user_data() .get::>() .map(|cell| { let mut cursor_status = cell.borrow_mut(); if let CursorImageStatus::Surface(ref surface) = *cursor_status { if !surface.alive() { *cursor_status = CursorImageStatus::Default; } } cursor_status.clone() }) .unwrap_or(CursorImageStatus::Default); if let CursorImageStatus::Surface(wl_surface) = cursor_status { send_frames_surface_tree( &wl_surface, output, time, Some(Duration::ZERO), |_, _| None, ) } if let Some(move_grab) = seat.user_data().get::() { if let Some(grab_state) = move_grab.borrow().as_ref() { grab_state.send_frames( output, time, throttle, surface_primary_scanout_output, ); if let Some(feedback) = dmabuf_feedback { grab_state.send_dmabuf_feedback( output, feedback, render_element_states, surface_primary_scanout_output, ); } } } } } let active = self.shell.active_space(output); active.mapped().for_each(|mapped| { let outputs_for_element: Vec<_> = active.outputs_for_element(mapped).collect(); if outputs_for_element.contains(&output) { let window = mapped.active_window(); window.with_surfaces(|surface, states| { update_surface_primary_scanout_output( surface, output, states, render_element_states, |current_output, current_state, next_output, next_state| { if outputs_for_element.contains(current_output) { default_primary_scanout_output_compare( current_output, current_state, next_output, next_state, ) } else { next_output } }, ); }); window.send_frame(output, time, throttle, surface_primary_scanout_output); if let Some(feedback) = dmabuf_feedback { window.send_dmabuf_feedback( output, feedback, render_element_states, surface_primary_scanout_output, ); } } }); for space in self .shell .workspaces .spaces() .filter(|w| w.handle != active.handle) { space.mapped().for_each(|mapped| { if space.outputs_for_element(mapped).any(|o| &o == output) { let window = mapped.active_window(); window.send_frame(output, time, throttle, |_, _| None); } }); } self.shell.override_redirect_windows.iter().for_each(|or| { if let Some(wl_surface) = or.wl_surface() { with_surfaces_surface_tree(&wl_surface, |surface, states| { update_surface_primary_scanout_output( surface, output, states, render_element_states, default_primary_scanout_output_compare, ); }); send_frames_surface_tree( &wl_surface, output, time, throttle, surface_primary_scanout_output, ); if let Some(feedback) = dmabuf_feedback { send_dmabuf_feedback_surface_tree( &wl_surface, output, surface_primary_scanout_output, |surface, _| { select_dmabuf_feedback( surface, render_element_states, &feedback.render_feedback, &feedback.scanout_feedback, ) }, ) } } }); let map = smithay::desktop::layer_map_for_output(output); for layer_surface in map.layers() { layer_surface.with_surfaces(|surface, states| { update_surface_primary_scanout_output( surface, output, states, render_element_states, default_primary_scanout_output_compare, ); }); layer_surface.send_frame(output, time, throttle, surface_primary_scanout_output); if let Some(feedback) = dmabuf_feedback { layer_surface.send_dmabuf_feedback( output, surface_primary_scanout_output, |surface, _| { select_dmabuf_feedback( surface, render_element_states, &feedback.render_feedback, &feedback.scanout_feedback, ) }, ); } } } pub fn take_presentation_feedback( &self, output: &Output, render_element_states: &RenderElementStates, ) -> OutputPresentationFeedback { let mut output_presentation_feedback = OutputPresentationFeedback::new(output); let active = self.shell.active_space(output); active.mapped().for_each(|mapped| { mapped.active_window().take_presentation_feedback( &mut output_presentation_feedback, surface_primary_scanout_output, |surface, _| { surface_presentation_feedback_flags_from_states(surface, render_element_states) }, ); }); self.shell.override_redirect_windows.iter().for_each(|or| { if let Some(wl_surface) = or.wl_surface() { take_presentation_feedback_surface_tree( &wl_surface, &mut output_presentation_feedback, surface_primary_scanout_output, |surface, _| { surface_presentation_feedback_flags_from_states( surface, render_element_states, ) }, ) } }); let map = smithay::desktop::layer_map_for_output(output); for layer_surface in map.layers() { layer_surface.take_presentation_feedback( &mut output_presentation_feedback, surface_primary_scanout_output, |surface, _| { surface_presentation_feedback_flags_from_states(surface, render_element_states) }, ); } output_presentation_feedback } } #[cfg(feature = "debug")] pub struct Egui { pub active: bool, pub state: smithay_egui::EguiState, } pub struct Fps { #[cfg(feature = "debug")] pub rd: Option>, #[cfg(feature = "debug")] pub state: smithay_egui::EguiState, pending_frame: Option, pub frames: VecDeque, } #[derive(Debug)] struct PendingFrame { start: Instant, duration_elements: Option, duration_render: Option, duration_screencopy: Option, duration_displayed: Option, } #[derive(Debug)] pub struct Frame { pub start: Instant, pub duration_elements: Duration, pub duration_render: Duration, pub duration_screencopy: Option, pub duration_displayed: Duration, } impl Frame { fn render_time(&self) -> Duration { self.duration_elements + self.duration_render } fn frame_time(&self) -> Duration { self.duration_elements + self.duration_render + self.duration_screencopy.clone().unwrap_or(Duration::ZERO) } fn time_to_display(&self) -> Duration { self.duration_elements + self.duration_render + self.duration_screencopy.clone().unwrap_or(Duration::ZERO) + self.duration_displayed } } impl From for Frame { fn from(pending: PendingFrame) -> Self { Frame { start: pending.start, duration_elements: pending.duration_elements.unwrap_or(Duration::ZERO), duration_render: pending.duration_render.unwrap_or(Duration::ZERO), duration_screencopy: pending.duration_screencopy, duration_displayed: pending.duration_displayed.unwrap_or(Duration::ZERO), } } } impl Fps { const WINDOW_SIZE: usize = 360; pub fn start(&mut self) { self.pending_frame = Some(PendingFrame { start: Instant::now(), duration_elements: None, duration_render: None, duration_screencopy: None, duration_displayed: None, }); } pub fn elements(&mut self) { if let Some(frame) = self.pending_frame.as_mut() { frame.duration_elements = Some(Instant::now().duration_since(frame.start)); } } pub fn render(&mut self) { if let Some(frame) = self.pending_frame.as_mut() { frame.duration_render = Some( Instant::now().duration_since(frame.start) - frame.duration_elements.clone().unwrap_or(Duration::ZERO), ); } } pub fn screencopy(&mut self) { if let Some(frame) = self.pending_frame.as_mut() { frame.duration_screencopy = Some( Instant::now().duration_since(frame.start) - frame.duration_elements.clone().unwrap_or(Duration::ZERO) - frame.duration_render.clone().unwrap_or(Duration::ZERO), ); } } pub fn displayed(&mut self) { if let Some(mut frame) = self.pending_frame.take() { frame.duration_displayed = Some( Instant::now().duration_since(frame.start) - frame.duration_elements.clone().unwrap_or(Duration::ZERO) - frame.duration_render.clone().unwrap_or(Duration::ZERO) - frame.duration_screencopy.clone().unwrap_or(Duration::ZERO), ); self.frames.push_back(frame.into()); while self.frames.len() > Fps::WINDOW_SIZE { self.frames.pop_front(); } } } pub fn max_frametime(&self) -> Duration { self.frames .iter() .map(|f| f.frame_time()) .max() .unwrap_or(Duration::ZERO) } pub fn min_frametime(&self) -> Duration { self.frames .iter() .map(|f| f.frame_time()) .min() .unwrap_or(Duration::ZERO) } pub fn max_time_to_display(&self) -> Duration { self.frames .iter() .map(|f| f.time_to_display()) .max() .unwrap_or(Duration::ZERO) } pub fn min_time_to_display(&self) -> Duration { self.frames .iter() .map(|f| f.time_to_display()) .min() .unwrap_or(Duration::ZERO) } pub fn avg_frametime(&self) -> Duration { if self.frames.is_empty() { return Duration::ZERO; } self.frames.iter().map(|f| f.frame_time()).sum::() / (self.frames.len() as u32) } pub fn avg_rendertime(&self, window: usize) -> Duration { self.frames .iter() .take(window) .map(|f| f.render_time()) .sum::() / window as u32 } pub fn avg_fps(&self) -> f64 { if self.frames.is_empty() { return 0.0; } let secs = match (self.frames.front(), self.frames.back()) { (Some(Frame { start, .. }), Some(end_frame)) => { end_frame.start.duration_since(*start) + end_frame.frame_time() } _ => Duration::ZERO, } .as_secs_f64(); 1.0 / (secs / self.frames.len() as f64) } } #[cfg(feature = "debug")] static INTEL_LOGO: &'static [u8] = include_bytes!("../resources/icons/intel.svg"); #[cfg(feature = "debug")] static AMD_LOGO: &'static [u8] = include_bytes!("../resources/icons/amd.svg"); #[cfg(feature = "debug")] static NVIDIA_LOGO: &'static [u8] = include_bytes!("../resources/icons/nvidia.svg"); impl Fps { pub fn new(_renderer: &mut GlowRenderer) -> Fps { #[cfg(feature = "debug")] let state = { let state = smithay_egui::EguiState::new(smithay::utils::Rectangle::from_loc_and_size( (0, 0), (400, 800), )); let mut visuals: egui::style::Visuals = Default::default(); visuals.window_shadow.extrusion = 0.0; state.context().set_visuals(visuals); state .load_svg(_renderer, String::from("intel"), INTEL_LOGO) .unwrap(); state .load_svg(_renderer, String::from("amd"), AMD_LOGO) .unwrap(); state .load_svg(_renderer, String::from("nvidia"), NVIDIA_LOGO) .unwrap(); state }; Fps { #[cfg(feature = "debug")] state, #[cfg(feature = "debug")] rd: renderdoc::RenderDoc::new().ok(), pending_frame: None, frames: VecDeque::with_capacity(Fps::WINDOW_SIZE + 1), } } } pub fn avg_fps<'a>(iter: impl Iterator) -> f64 { let sum_secs = iter.map(|d| d.as_secs_f64()).sum::(); 1.0 / (sum_secs / Fps::WINDOW_SIZE as f64) }