chore: Fix smithay version

src/backend/kms/device.rs

@@ -179,7 +179,7 @@ impl State {
             )
             .with_context(|| format!("Failed to add drm device to event loop: {}", dev))?;
 
-        let socket = match self.create_socket(dh, render_node, render_formats.clone().into_iter()) {
+        let socket = match self.create_socket(dh, render_node, render_formats.clone()) {
             Ok(socket) => Some(socket),
             Err(err) => {
                 warn!(

src/backend/kms/socket.rs

@@ -3,7 +3,7 @@
 use anyhow::{anyhow, Context, Result};
 use smithay::{
     backend::{
-        allocator::Format,
+        allocator::format::FormatSet,
         drm::{DrmNode, NodeType},
     },
     reexports::{
@@ -32,9 +32,8 @@ impl State {
         &mut self,
         dh: &DisplayHandle,
         render_node: DrmNode,
-        formats: impl Iterator<Item = Format>,
+        formats: FormatSet,
     ) -> Result<Socket> {
-        let formats = formats.collect::<Vec<_>>();
         let socket_name = format!(
             "{}-{}",
             &self.common.socket.to_string_lossy(),

src/backend/kms/surface/mod.rs

@@ -21,8 +21,9 @@ use calloop::channel::Channel;
 use smithay::{
     backend::{
         allocator::{
+            format::FormatSet,
             gbm::{GbmAllocator, GbmBufferFlags, GbmDevice},
-            Format, Fourcc,
+            Fourcc,
         },
         drm::{
             compositor::{BlitFrameResultError, DrmCompositor, FrameError, PrimaryPlaneElement},
@@ -108,7 +109,7 @@ pub struct Surface {
 
     active: Arc<AtomicBool>,
     feedback: HashMap<DrmNode, SurfaceDmabufFeedback>,
-    plane_formats: HashSet<Format>,
+    plane_formats: FormatSet,
 
     loop_handle: LoopHandle<'static, State>,
     thread_command: Sender<ThreadCommand>,
@@ -310,20 +311,18 @@ impl Surface {
                                             .api
                                             .single_renderer(&source_node)
                                             .unwrap()
-                                            .dmabuf_formats()
-                                            .collect::<HashSet<_>>();
+                                            .dmabuf_formats();
                                         let target_formats = kms
                                             .api
                                             .single_renderer(&target_node)
                                             .unwrap()
-                                            .dmabuf_formats()
-                                            .collect::<HashSet<_>>();
+                                            .dmabuf_formats();
                                         get_surface_dmabuf_feedback(
                                             source_node,
                                             target_node,
                                             render_formats,
                                             target_formats,
-                                            &surface.plane_formats,
+                                            surface.plane_formats.clone(),
                                         )
                                     })
                                     .clone(),
@@ -341,7 +340,7 @@ impl Surface {
             known_nodes: HashSet::new(),
             active,
             feedback: HashMap::new(),
-            plane_formats: HashSet::new(),
+            plane_formats: FormatSet::default(),
             loop_handle: evlh.clone(),
             thread_command: tx,
             thread_token,
@@ -407,7 +406,7 @@ impl Surface {
             .primary
             .formats
             .iter()
-            .cloned()
+            .copied()
             .chain(
                 surface
                     .planes()
@@ -415,7 +414,7 @@ impl Surface {
                     .iter()
                     .flat_map(|p| p.formats.iter().cloned()),
             )
-            .collect::<HashSet<_>>();
+            .collect::<FormatSet>();
 
         let _ = self.thread_command.send(ThreadCommand::Resume {
             surface,
@@ -593,8 +592,7 @@ impl SurfaceThreadState {
             .api
             .single_renderer(&self.target_node)
             .unwrap()
-            .dmabuf_formats()
-            .collect();
+            .dmabuf_formats();
 
         self.timings.set_refresh_interval(Some(Duration::from_nanos(
             drm_helpers::calculate_refresh_rate(surface.pending_mode()) as u64,
@@ -1368,14 +1366,14 @@ fn render_node_for_output(
 fn get_surface_dmabuf_feedback(
     render_node: DrmNode,
     target_node: DrmNode,
-    render_formats: HashSet<Format>,
-    target_formats: HashSet<Format>,
-    plane_formats: &HashSet<Format>,
+    render_formats: FormatSet,
+    target_formats: FormatSet,
+    plane_formats: FormatSet,
 ) -> SurfaceDmabufFeedback {
     let combined_formats = render_formats
         .intersection(&target_formats)
         .copied()
-        .collect::<HashSet<_>>();
+        .collect::<FormatSet>();
 
     // We limit the scan-out trache to formats we can also render from
     // so that there is always a fallback render path available in case
@@ -1383,7 +1381,7 @@ fn get_surface_dmabuf_feedback(
     let planes_formats = plane_formats
         .intersection(&combined_formats)
         .copied()
-        .collect::<Vec<_>>();
+        .collect::<FormatSet>();
 
     let builder = DmabufFeedbackBuilder::new(render_node.dev_id(), render_formats);
     /*

src/backend/winit.rs

@@ -240,7 +240,7 @@ fn init_egl_client_side(
     let render_node = EGLDevice::device_for_display(renderer.renderer().egl_context().display())
         .and_then(|device| device.try_get_render_node());
 
-    let dmabuf_formats = renderer.renderer().dmabuf_formats().collect::<Vec<_>>();
+    let dmabuf_formats = renderer.renderer().dmabuf_formats();
 
     match render_node {
         Ok(Some(node)) => {

src/backend/x11.rs

@@ -273,9 +273,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
 
     let Some(device) = devices
         .filter(|phd| {
-            phd.has_device_extension(
-                smithay::reexports::ash::extensions::ext::PhysicalDeviceDrm::name(),
-            )
+            phd.has_device_extension(smithay::reexports::ash::ext::physical_device_drm::NAME)
         })
         .find(|phd| {
             phd.primary_node().unwrap() == Some(*node) || phd.render_node().unwrap() == Some(*node)
@@ -480,7 +478,7 @@ where
                 "Could not determine path for gpu node: {}",
                 render_node
             ))?,
-        renderer.dmabuf_formats().collect(),
+        renderer.dmabuf_formats(),
         &dmabuf_global,
     );