chore: Update smithay

Cargo.lock

@@ -1901,9 +1901,9 @@ dependencies = [
 
 [[package]]
 name = "gbm"
-version = "0.16.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c724107aa10444b1d2709aae4727c18a33c16b3e15ea8a46cc4ae226c084c88a"
+checksum = "ce852e998d3ca5e4a97014fb31c940dc5ef344ec7d364984525fd11e8a547e6a"
 dependencies = [
  "bitflags 2.6.0",
  "drm 0.14.0",
@@ -1914,9 +1914,9 @@ dependencies = [
 
 [[package]]
 name = "gbm-sys"
-version = "0.3.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9cc2f64de9fa707b5c6b2d2f10d7a7e49e845018a9f5685891eb40d3bab2538"
+checksum = "c13a5f2acc785d8fb6bf6b7ab6bfb0ef5dad4f4d97e8e70bb8e470722312f76f"
 dependencies = [
  "libc",
 ]
@@ -3874,9 +3874,9 @@ dependencies = [
 
 [[package]]
 name = "pixman"
-version = "0.1.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d24a24da0bec14f4e43a495c1837a3c358b87532e7fe66bd75c348b89f0451b6"
+checksum = "cea217d496c19ac0a8e502b37078e1f683d16344adee9eb247a5d57c165e1edf"
 dependencies = [
  "drm-fourcc",
  "paste",
@@ -4638,7 +4638,7 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/smithay//smithay?rev=bc1d732#bc1d7320f95cdf17f9e7aa6867cccc5903548032"
+source = "git+https://github.com/smithay//smithay?rev=14c7e43#14c7e43255968e2d979a19e1fd9bd694e5a9726e"
 dependencies = [
  "appendlist",
  "ash",

Cargo.toml

@@ -119,4 +119,4 @@ inherits = "release"
 lto = "fat"
 
 [patch."https://github.com/Smithay/smithay.git"]
-smithay = { git = "https://github.com/smithay//smithay", rev = "bc1d732" }
+smithay = { git = "https://github.com/smithay//smithay", rev = "14c7e43" }

src/backend/kms/surface/mod.rs

@@ -27,7 +27,9 @@ use smithay::{
             Fourcc,
         },
         drm::{
-            compositor::{BlitFrameResultError, DrmCompositor, FrameError, PrimaryPlaneElement},
+            compositor::{
+                BlitFrameResultError, DrmCompositor, FrameError, FrameFlags, PrimaryPlaneElement,
+            },
             DrmDeviceFd, DrmEventMetadata, DrmEventTime, DrmNode, DrmSurface, VrrSupport,
         },
         egl::EGLContext,
@@ -127,6 +129,7 @@ pub struct SurfaceThreadState {
     target_node: DrmNode,
     active: Arc<AtomicBool>,
     vrr_mode: AdaptiveSync,
+    frame_flags: FrameFlags,
     compositor: Option<GbmDrmCompositor>,
 
     state: QueueState,
@@ -533,6 +536,7 @@ fn surface_thread(
         target_node,
         active,
         compositor: None,
+        frame_flags: FrameFlags::DEFAULT,
         vrr_mode: AdaptiveSync::Disabled,
 
         state: QueueState::Idle,
@@ -706,7 +710,7 @@ impl SurfaceThreadState {
                 GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
             ),
             gbm.clone(),
-            &[
+            [
                 Fourcc::Abgr2101010,
                 Fourcc::Argb2101010,
                 Fourcc::Abgr8888,
@@ -716,9 +720,9 @@ impl SurfaceThreadState {
             cursor_size,
             Some(gbm),
         ) {
-            Ok(mut compositor) => {
+            Ok(compositor) => {
                 if crate::utils::env::bool_var("COSMIC_DISABLE_DIRECT_SCANOUT").unwrap_or(false) {
-                    compositor.use_direct_scanout(false);
+                    self.frame_flags.remove(FrameFlags::ALLOW_SCANOUT);
                 }
                 self.active.store(true, Ordering::SeqCst);
                 self.compositor = Some(compositor);
@@ -1171,7 +1175,12 @@ impl SurfaceThreadState {
             if let Err(err) = compositor.use_vrr(false) {
                 warn!("Unable to set adaptive VRR state: {}", err);
             }
-            compositor.render_frame(&mut renderer, &elements, [0.0, 0.0, 0.0, 1.0])
+            compositor.render_frame(
+                &mut renderer,
+                &elements,
+                [0.0, 0.0, 0.0, 1.0],
+                FrameFlags::DEFAULT,
+            )
         } else {
             if let Err(err) = compositor.use_vrr(vrr) {
                 warn!("Unable to set adaptive VRR state: {}", err);
@@ -1180,6 +1189,7 @@ impl SurfaceThreadState {
                 &mut renderer,
                 &elements,
                 CLEAR_COLOR, // TODO use a theme neutral color
+                FrameFlags::DEFAULT,
             )
         };
         self.timings.draw_done(&self.clock);
@@ -1234,10 +1244,10 @@ impl SurfaceThreadState {
                                 if let Ok(dmabuf) = get_dmabuf(&buffer) {
                                     renderer
                                         .bind(dmabuf.clone())
-                                        .map_err(RenderError::<GlMultiRenderer>::Rendering)?;
+                                        .map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
                                 } else {
                                     let size = buffer_dimensions(&buffer).ok_or(RenderError::<
-                                        GlMultiRenderer,
+                                        <GlMultiRenderer as Renderer>::Error,
                                     >::Rendering(
                                         MultiError::ImportFailed,
                                     ))?;
@@ -1251,10 +1261,10 @@ impl SurfaceThreadState {
                                             format,
                                             size,
                                         )
-                                        .map_err(RenderError::<GlMultiRenderer>::Rendering)?;
+                                        .map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
                                     renderer
                                         .bind(render_buffer)
-                                        .map_err(RenderError::<GlMultiRenderer>::Rendering)?;
+                                        .map_err(RenderError::<<GlMultiRenderer as Renderer>::Error>::Rendering)?;
                                 }
 
                                 let (output_size, output_scale, output_transform) = (
@@ -1296,14 +1306,16 @@ impl SurfaceThreadState {
                                         filter,
                                     )
                                     .map_err(|err| match err {
-                                        BlitFrameResultError::Rendering(err) => {
+                                        BlitFrameResultError::Rendering(err) => RenderError::<
-                                            RenderError::<GlMultiRenderer>::Rendering(err)
+                                            <GlMultiRenderer as Renderer>::Error,
-                                        }
+                                        >::Rendering(
-                                        BlitFrameResultError::Export(_) => {
+                                            err
-                                            RenderError::<GlMultiRenderer>::Rendering(
+                                        ),
+                                        BlitFrameResultError::Export(_) => RenderError::<
+                                            <GlMultiRenderer as Renderer>::Error,
+                                        >::Rendering(
                                             MultiError::DeviceMissing,
-                                            )
+                                        ),
-                                        }
                                     }) {
                                     Ok(new_sync) => {
                                         sync = new_sync;

src/backend/render/mod.rs

@@ -511,7 +511,7 @@ pub fn workspace_elements<R>(
     cursor_mode: CursorMode,
     element_filter: ElementFilter,
     _fps: Option<(&EguiState, &Timings)>,
-) -> Result<Vec<CosmicElement<R>>, RenderError<R>>
+) -> Result<Vec<CosmicElement<R>>, RenderError<<R as Renderer>::Error>>
 where
     R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
     <R as Renderer>::TextureId: Send + Clone + 'static,
@@ -867,7 +867,7 @@ pub fn render_output<'d, R, Target, OffTarget>(
     now: Time<Monotonic>,
     output: &Output,
     cursor_mode: CursorMode,
-) -> Result<RenderOutputResult<'d>, RenderError<R>>
+) -> Result<RenderOutputResult<'d>, RenderError<<R as Renderer>::Error>>
 where
     R: Renderer
         + ImportAll
@@ -1026,7 +1026,7 @@ pub fn render_workspace<'d, R, Target, OffTarget>(
     current: (WorkspaceHandle, usize),
     cursor_mode: CursorMode,
     element_filter: ElementFilter,
-) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<R>>
+) -> Result<(RenderOutputResult<'d>, Vec<CosmicElement<R>>), RenderError<<R as Renderer>::Error>>
 where
     R: Renderer
         + ImportAll

src/wayland/handlers/screencopy/render.rs

@@ -140,7 +140,7 @@ pub fn render_session<F, R>(
     frame: Frame,
     transform: Transform,
     render_fn: F,
-) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<R>>
+) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<<R as Renderer>::Error>>
 where
     R: ExportMem,
     <R as Renderer>::Error: FromGlesError,
@@ -150,7 +150,7 @@ where
         &'d mut OutputDamageTracker,
         usize,
         Vec<Rectangle<i32, BufferCoords>>,
-    ) -> Result<RenderOutputResult<'d>, DTError<R>>,
+    ) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>,
 {
     let mut session_damage_tracking = session.lock().unwrap();
 
@@ -225,7 +225,7 @@ pub fn render_workspace_to_buffer(
         common: &mut Common,
         output: &Output,
         handle: (WorkspaceHandle, usize),
-    ) -> Result<RenderOutputResult<'d>, DTError<R>>
+    ) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
     where
         R: Renderer
             + ImportAll
@@ -464,7 +464,7 @@ pub fn render_window_to_buffer(
         common: &mut Common,
         window: &CosmicSurface,
         geometry: Rectangle<i32, Logical>,
-    ) -> Result<RenderOutputResult<'d>, DTError<R>>
+    ) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
     where
         R: Renderer
             + ImportAll
@@ -700,7 +700,7 @@ pub fn render_cursor_to_buffer(
         additional_damage: Vec<Rectangle<i32, BufferCoords>>,
         common: &mut Common,
         seat: &Seat<State>,
-    ) -> Result<RenderOutputResult<'d>, DTError<R>>
+    ) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
     where
         R: Renderer
             + ImportAll