chore: Update smithay

2023-03-31 14:04:47 +02:00 · 2023-03-31 14:04:47 +02:00 · 636d38921a
commit 636d38921a
parent bb59a2d437
7 changed files with 76 additions and 103 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -757,9 +757,9 @@ checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"

 [[package]]
 name = "drm"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98d190a8cb219483212f462d9e34abebe24a13cdb7f0c9a64c5b59175ccd62d2"
+checksum = "edf9159ef4bcecd0c5e4cbeb573b8d0037493403d542780dba5d840bbf9df56f"
 dependencies = [
 "bitflags",
 "bytemuck",
@ -770,9 +770,9 @@ dependencies = [

 [[package]]
 name = "drm-ffi"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48310b65d262ac1140f63e2bbc605c73a417c7e46452ea8c20a3cad698af96d0"
+checksum = "1352481b7b90e27a8a1bf8ef6b33cf18b98dba7c410e75c24bb3eef2f0d8d525"
 dependencies = [
 "drm-sys",
 "nix 0.26.2",
@ -786,9 +786,9 @@ checksum = "0aafbcdb8afc29c1a7ee5fbe53b5d62f4565b35a042a662ca9fecd0b54dae6f4"

 [[package]]
 name = "drm-sys"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ecd1ca96a64fd7444a58a2ce3aa8be79cea3c1c7f7f69a4b89624018b46377"
+checksum = "1369f1679d6b706d234c4c1e0613c415c2c74b598a09ad28080ba2474b72e42d"
 dependencies = [
 "libc",
 ]
@ -1265,9 +1265,9 @@ dependencies = [

 [[package]]
 name = "gbm"
-version = "0.11.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fffcdb4a9a42ceeb8170a916a84d44ec1fbfbbd753070180a98db92b71bfd431"
+checksum = "f2ec389cda876966cf824111bf6e533fb934c711d473498279964a990853b3c6"
 dependencies = [
 "bitflags",
 "drm",
@ -3306,7 +3306,7 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/pop-os/smithay?rev=4e287a585a#4e287a585ae257393a0377694b2d284da243f4b2"
+source = "git+https://github.com/smithay//smithay?rev=a5a3c2bd4e#a5a3c2bd4e129e6895e1884b075a9994c9affe66"
 dependencies = [
 "appendlist",
 "ash",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -70,4 +70,4 @@ debug = true
 lto = "fat"

 [patch."https://github.com/Smithay/smithay.git"]
-smithay = { git = "https://github.com/pop-os/smithay", rev = "4e287a585a" }
+smithay = { git = "https://github.com/smithay//smithay", rev = "a5a3c2bd4e" }
--- a/src/backend/kms/mod.rs
+++ b/src/backend/kms/mod.rs
@ -33,7 +33,7 @@ use smithay::{
        libinput::{LibinputInputBackend, LibinputSessionInterface},
        renderer::{
            buffer_dimensions,
-            damage::{DamageTrackedRendererError as RenderError, OutputNoMode},
+            damage::{Error as RenderError, OutputNoMode},
            gles2::Gles2Renderbuffer,
            glow::GlowRenderer,
            multigpu::{gbm::GbmGlesBackend, Error as MultiError, GpuManager},
@ -1013,8 +1013,8 @@ impl Surface {
                            &session,
                            params,
                            self.output.current_transform(),
-                            |_node, buffer, renderer, dtr, age| {
-                                let res = dtr.damage_output(age, &elements)?;
+                            |_node, buffer, renderer, dt, age| {
+                                let res = dt.damage_output(age, &elements)?;

                                if let (Some(ref damage), _) = &res {
                                    if let Ok(dmabuf) = get_dmabuf(buffer) {
--- a/src/backend/render/mod.rs
+++ b/src/backend/render/mod.rs
@ -35,9 +35,7 @@ use smithay::{
        drm::DrmNode,
        renderer::{
            buffer_dimensions,
-            damage::{
-                DamageTrackedRenderer, DamageTrackedRendererError as RenderError, OutputNoMode,
-            },
+            damage::{Error as RenderError, OutputDamageTracker, OutputNoMode},
            element::{Element, RenderElement, RenderElementStates},
            gles2::{
                element::PixelShaderElement, Gles2Error, Gles2PixelProgram, Gles2Renderer, Uniform,
@ -316,7 +314,7 @@ pub fn render_output<'frame, R, Target, OffTarget, Source>(
    gpu: Option<&DrmNode>,
    renderer: &mut R,
    target: Target,
-    damage_tracker: &mut DamageTrackedRenderer,
+    damage_tracker: &mut OutputDamageTracker,
    age: usize,
    state: &mut Common,
    output: &Output,
@ -364,7 +362,7 @@ pub fn render_workspace<'frame, R, Target, OffTarget, Source>(
    gpu: Option<&DrmNode>,
    renderer: &mut R,
    target: Target,
-    damage_tracker: &mut DamageTrackedRenderer,
+    damage_tracker: &mut OutputDamageTracker,
    age: usize,
    state: &mut Common,
    output: &Output,
@ -450,8 +448,8 @@ where
                    &session,
                    params,
                    output.current_transform(),
-                    |_node, buffer, renderer, dtr, age| {
-                        let res = dtr.damage_output(age, &elements)?;
+                    |_node, buffer, renderer, dt, age| {
+                        let res = dt.damage_output(age, &elements)?;

                        if let (Some(ref damage), _) = &res {
                            if let Ok(dmabuf) = get_dmabuf(buffer) {
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@ -13,7 +13,7 @@ use smithay::{
    backend::{
        egl::EGLDevice,
        renderer::{
-            damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
+            damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
            ImportEgl,
        },
        winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice},
@ -40,7 +40,7 @@ pub struct WinitState {
    // The winit backend currently has no notion of multiple windows
    pub backend: WinitGraphicsBackend<GlowRenderer>,
    output: Output,
-    damage_tracker: DamageTrackedRenderer,
+    damage_tracker: OutputDamageTracker,
    screencopy: Vec<(ScreencopySession, BufferParams)>,
    #[cfg(feature = "debug")]
    fps: Fps,
@ -240,7 +240,7 @@ pub fn init_backend(
    state.backend = BackendData::Winit(WinitState {
        backend,
        output: output.clone(),
-        damage_tracker: DamageTrackedRenderer::from_output(&output),
+        damage_tracker: OutputDamageTracker::from_output(&output),
        screencopy: Vec::new(),
        #[cfg(feature = "debug")]
        fps,
--- a/src/backend/x11.rs
+++ b/src/backend/x11.rs
@ -20,7 +20,7 @@ use smithay::{
        egl::{EGLContext, EGLDevice, EGLDisplay},
        input::{Event, InputEvent},
        renderer::{
-            damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind,
+            damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind,
            ImportDma, ImportEgl,
        },
        vulkan::{version::Version, Instance, PhysicalDevice},
@ -141,7 +141,7 @@ impl X11State {
        self.surfaces.push(Surface {
            window,
            surface,
-            damage_tracker: DamageTrackedRenderer::from_output(&output),
+            damage_tracker: OutputDamageTracker::from_output(&output),
            output: output.clone(),
            render: ping.clone(),
            dirty: false,
@ -204,7 +204,7 @@ impl X11State {

 pub struct Surface {
    window: Window,
-    damage_tracker: DamageTrackedRenderer,
+    damage_tracker: OutputDamageTracker,
    screencopy: Vec<(ScreencopySession, BufferParams)>,
    surface: X11Surface,
    output: Output,
--- a/src/wayland/handlers/screencopy.rs
+++ b/src/wayland/handlers/screencopy.rs
@ -16,7 +16,7 @@ use smithay::{
        egl::EGLDevice,
        renderer::{
            buffer_dimensions, buffer_type,
-            damage::{DamageTrackedRenderer, DamageTrackedRendererError},
+            damage::{Error as DTError, OutputDamageTracker},
            element::{
                surface::WaylandSurfaceRenderElement, AsRenderElements, RenderElement,
                RenderElementStates,
@ -92,7 +92,7 @@ impl PartialEq<Session> for DropableSession {
    }
 }

-pub type SessionDTR = RefCell<DamageTrackedRenderer>;
+pub type SessionDT = RefCell<OutputDamageTracker>;

 impl ScreencopyHandler for State {
    fn capture_output(&mut self, output: Output, session: Session) -> Vec<BufferInfo> {
@ -117,7 +117,7 @@ impl ScreencopyHandler for State {

        session
            .user_data()
-            .insert_if_missing(|| SessionDTR::new(DamageTrackedRenderer::from_output(&output)));
+            .insert_if_missing(|| SessionDT::new(OutputDamageTracker::from_output(&output)));
        output
            .user_data()
            .insert_if_missing(ScreencopySessions::default);
@ -156,7 +156,7 @@ impl ScreencopyHandler for State {

        session
            .user_data()
-            .insert_if_missing(|| SessionDTR::new(DamageTrackedRenderer::from_output(&output)));
+            .insert_if_missing(|| SessionDT::new(OutputDamageTracker::from_output(&output)));

        workspace
            .screencopy_sessions
@ -226,7 +226,7 @@ impl ScreencopyHandler for State {

        let size = toplevel.geometry().size.to_physical(1);
        session.user_data().insert_if_missing(|| {
-            SessionDTR::new(DamageTrackedRenderer::new(size, 1.0, Transform::Normal))
+            SessionDT::new(OutputDamageTracker::new(size, 1.0, Transform::Normal))
        });
        toplevel
            .user_data()
@ -547,40 +547,34 @@ pub fn render_session<F, R>(
    params: &BufferParams,
    transform: Transform,
    render_fn: F,
-) -> Result<bool, DamageTrackedRendererError<R>>
+) -> Result<bool, DTError<R>>
 where
    R: ExportMem,
    F: FnOnce(
        Option<&DrmNode>,
        &WlBuffer,
        &mut R,
-        &mut DamageTrackedRenderer,
+        &mut OutputDamageTracker,
        usize,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >,
+    )
+        -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>,
 {
    #[cfg(feature = "debug")]
    puffin::profile_function!();

-    let mut dtr = session
-        .user_data()
-        .get::<SessionDTR>()
-        .unwrap()
-        .borrow_mut();
+    let mut dt = session.user_data().get::<SessionDT>().unwrap().borrow_mut();

    let res = render_fn(
        node.as_ref(),
        &params.buffer,
        renderer,
-        &mut *dtr,
+        &mut *dt,
        params.age as usize,
    )?;

    if let (Some(damage), _) = res {
        submit_buffer(session, &params.buffer, renderer, transform, damage)
-            .map_err(DamageTrackedRendererError::Rendering)?;
+            .map_err(DTError::Rendering)?;
        Ok(true)
    } else {
        Ok(false)
@ -605,15 +599,12 @@ pub fn render_output_to_buffer(
        node: Option<&DrmNode>,
        buffer: &WlBuffer,
        renderer: &mut R,
-        dtr: &mut DamageTrackedRenderer,
+        dt: &mut OutputDamageTracker,
        age: usize,
        common: &mut Common,
        session: &Session,
        output: &Output,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >
+    ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
    where
        R: Renderer
            + ImportAll
@ -639,7 +630,7 @@ pub fn render_output_to_buffer(
                node,
                renderer,
                dmabuf,
-                dtr,
+                dt,
                age,
                common,
                &output,
@ -650,12 +641,12 @@ pub fn render_output_to_buffer(
        } else {
            let size = buffer_dimensions(buffer).unwrap();
            let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+                .map_err(DTError::Rendering)?;
            render_output::<_, _, Gles2Renderbuffer, Dmabuf>(
                node,
                renderer,
                render_buffer,
-                dtr,
+                dt,
                age,
                common,
                &output,
@ -680,13 +671,13 @@ pub fn render_output_to_buffer(
                session,
                &params,
                output.current_transform(),
-                |node, buffer, renderer, dtr, age| {
-                    render_fn(node, buffer, renderer, dtr, age, common, session, output)
+                |node, buffer, renderer, dt, age| {
+                    render_fn(node, buffer, renderer, dt, age, common, session, output)
                },
            )
            .map_err(|err| match err {
-                DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
-                DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()),
+                DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
+                DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
            })
        }
        BackendData::Winit(winit) => render_session::<_, _>(
@ -695,8 +686,8 @@ pub fn render_output_to_buffer(
            session,
            &params,
            output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
-                render_fn(node, buffer, renderer, dtr, age, common, session, output)
+            |node, buffer, renderer, dt, age| {
+                render_fn(node, buffer, renderer, dt, age, common, session, output)
            },
        )
        .map_err(|err| (FailureReason::Unspec, err.into())),
@ -706,8 +697,8 @@ pub fn render_output_to_buffer(
            session,
            &params,
            output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
-                render_fn(node, buffer, renderer, dtr, age, common, session, output)
+            |node, buffer, renderer, dt, age| {
+                render_fn(node, buffer, renderer, dt, age, common, session, output)
            },
        )
        .map_err(|err| (FailureReason::Unspec, err.into())),
@ -734,16 +725,13 @@ pub fn render_workspace_to_buffer(
        node: Option<&DrmNode>,
        buffer: &WlBuffer,
        renderer: &mut R,
-        dtr: &mut DamageTrackedRenderer,
+        dt: &mut OutputDamageTracker,
        age: usize,
        common: &mut Common,
        session: &Session,
        output: &Output,
        handle: &WorkspaceHandle,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >
+    ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
    where
        R: Renderer
            + ImportAll
@ -768,7 +756,7 @@ pub fn render_workspace_to_buffer(
                node,
                renderer,
                dmabuf,
-                dtr,
+                dt,
                age,
                common,
                &output,
@ -781,12 +769,12 @@ pub fn render_workspace_to_buffer(
        } else {
            let size = buffer_dimensions(buffer).unwrap();
            let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+                .map_err(DTError::Rendering)?;
            render_workspace::<_, _, Gles2Renderbuffer, Dmabuf>(
                node,
                renderer,
                render_buffer,
-                dtr,
+                dt,
                age,
                common,
                &output,
@ -813,15 +801,15 @@ pub fn render_workspace_to_buffer(
                session,
                &params,
                output.current_transform(),
-                |node, buffer, renderer, dtr, age| {
+                |node, buffer, renderer, dt, age| {
                    render_fn(
-                        node, buffer, renderer, dtr, age, common, session, output, handle,
+                        node, buffer, renderer, dt, age, common, session, output, handle,
                    )
                },
            )
            .map_err(|err| match err {
-                DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
-                DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()),
+                DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
+                DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
            })
        }
        BackendData::Winit(winit) => render_session::<_, _>(
@ -830,9 +818,9 @@ pub fn render_workspace_to_buffer(
            session,
            &params,
            output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
+            |node, buffer, renderer, dt, age| {
                render_fn(
-                    node, buffer, renderer, dtr, age, common, session, output, handle,
+                    node, buffer, renderer, dt, age, common, session, output, handle,
                )
            },
        )
@ -843,9 +831,9 @@ pub fn render_workspace_to_buffer(
            session,
            &params,
            output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
+            |node, buffer, renderer, dt, age| {
                render_fn(
-                    node, buffer, renderer, dtr, age, common, session, output, handle,
+                    node, buffer, renderer, dt, age, common, session, output, handle,
                )
            },
        )
@ -878,16 +866,13 @@ pub fn render_window_to_buffer(
    fn render_fn<R>(
        buffer: &WlBuffer,
        renderer: &mut R,
-        dtr: &mut DamageTrackedRenderer,
+        dt: &mut OutputDamageTracker,
        age: usize,
        session: &Session,
        common: &mut Common,
        window: &CosmicSurface,
        geometry: Rectangle<i32, Logical>,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >
+    ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
    where
        R: Renderer
            + ImportAll
@ -952,19 +937,15 @@ pub fn render_window_to_buffer(
        }

        if let Ok(dmabuf) = get_dmabuf(buffer) {
-            renderer
-                .bind(dmabuf)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+            renderer.bind(dmabuf).map_err(DTError::Rendering)?;
        } else {
            let size = buffer_dimensions(buffer).unwrap();
            let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
-                .map_err(DamageTrackedRendererError::Rendering)?;
-            renderer
-                .bind(render_buffer)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+                .map_err(DTError::Rendering)?;
+            renderer.bind(render_buffer).map_err(DTError::Rendering)?;
        }

-        dtr.render_output(renderer, age, &elements, CLEAR_COLOR)
+        dt.render_output(renderer, age, &elements, CLEAR_COLOR)
    }

    let node = node_from_params(&params, &mut state.backend, None);
@ -981,15 +962,13 @@ pub fn render_window_to_buffer(
                session,
                &params,
                Transform::Normal,
-                |_node, buffer, renderer, dtr, age| {
-                    render_fn(
-                        buffer, renderer, dtr, age, session, common, window, geometry,
-                    )
+                |_node, buffer, renderer, dt, age| {
+                    render_fn(buffer, renderer, dt, age, session, common, window, geometry)
                },
            )
            .map_err(|err| match err {
-                DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
-                DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()),
+                DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
+                DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
            })
        }
        BackendData::Winit(winit) => render_session::<_, _>(
@ -998,10 +977,8 @@ pub fn render_window_to_buffer(
            session,
            &params,
            Transform::Normal,
-            |_node, buffer, renderer, dtr, age| {
-                render_fn(
-                    buffer, renderer, dtr, age, session, common, window, geometry,
-                )
+            |_node, buffer, renderer, dt, age| {
+                render_fn(buffer, renderer, dt, age, session, common, window, geometry)
            },
        )
        .map_err(|err| (FailureReason::Unspec, err.into())),
@ -1011,10 +988,8 @@ pub fn render_window_to_buffer(
            session,
            &params,
            Transform::Normal,
-            |_node, buffer, renderer, dtr, age| {
-                render_fn(
-                    buffer, renderer, dtr, age, session, common, window, geometry,
-                )
+            |_node, buffer, renderer, dt, age| {
+                render_fn(buffer, renderer, dt, age, session, common, window, geometry)
            },
        )
        .map_err(|err| (FailureReason::Unspec, err.into())),