Update Smithay (Framebuffer type)

17 files changed, 72 insertions, 59 deletions

diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index 003413bf..cbb8c8c0 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -28,7 +28,7 @@ use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface}
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::backend::renderer::multigpu::gbm::GbmGlesBackend;
 use smithay::backend::renderer::multigpu::{GpuManager, MultiFrame, MultiRenderer};
-use smithay::backend::renderer::{DebugFlags, ImportDma, ImportEgl, Renderer};
+use smithay::backend::renderer::{DebugFlags, ImportDma, ImportEgl, RendererSuper};
 use smithay::backend::session::libseat::LibSeatSession;
 use smithay::backend::session::{Event as SessionEvent, Session};
 use smithay::backend::udev::{self, UdevBackend, UdevEvent};
@@ -101,15 +101,16 @@ pub type TtyRenderer<'render> = MultiRenderer<
     GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
 >;
 
-pub type TtyFrame<'render, 'frame> = MultiFrame<
+pub type TtyFrame<'render, 'frame, 'buffer> = MultiFrame<
     'render,
     'render,
     'frame,
+    'buffer,
     GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
     GbmGlesBackend<GlesRenderer, DrmDeviceFd>,
 >;
 
-pub type TtyRendererError<'render> = <TtyRenderer<'render> as Renderer>::Error;
+pub type TtyRendererError<'render> = <TtyRenderer<'render> as RendererSuper>::Error;
 
 type GbmDrmCompositor = DrmCompositor<
     GbmAllocator<DrmDeviceFd>,
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 3deec7a3..667b9209 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -190,12 +190,16 @@ impl Winit {
         }
 
         // Hand them over to winit.
-        self.backend.bind().unwrap();
-        let age = self.backend.buffer_age().unwrap();
-        let res = self
-            .damage_tracker
-            .render_output(self.backend.renderer(), age, &elements, [0.; 4])
-            .unwrap();
+        let res = {
+            let (renderer, mut framebuffer) = self.backend.bind().unwrap();
+            // FIXME: currently impossible to call due to a mutable borrow.
+            //
+            // let age = self.backend.buffer_age().unwrap();
+            let age = 0;
+            self.damage_tracker
+                .render_output(renderer, &mut framebuffer, age, &elements, [0.; 4])
+                .unwrap()
+        };
 
         niri.update_primary_scanout_output(output, &res.states);
 
diff --git a/src/niri.rs b/src/niri.rs
index bc8d1ad8..ef3d8594 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -33,7 +33,7 @@ use smithay::backend::renderer::element::{
 };
 use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::backend::renderer::sync::SyncPoint;
-use smithay::backend::renderer::{Color32F, Unbind};
+use smithay::backend::renderer::Color32F;
 use smithay::desktop::utils::{
     bbox_from_surface_tree, output_update, send_dmabuf_feedback_surface_tree,
     send_frames_surface_tree, surface_presentation_feedback_flags_from_states,
@@ -4536,10 +4536,6 @@ impl Niri {
             }
         };
 
-        if let Err(err) = renderer.unbind() {
-            warn!("error unbinding after rendering for screencopy: {err:?}");
-        }
-
         Ok((sync, damages))
     }
 
diff --git a/src/render_helpers/border.rs b/src/render_helpers/border.rs
index 588e53b1..a645212a 100644
--- a/src/render_helpers/border.rs
+++ b/src/render_helpers/border.rs
@@ -277,7 +277,7 @@ impl Element for BorderRenderElement {
 impl RenderElement<GlesRenderer> for BorderRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -294,7 +294,7 @@ impl RenderElement<GlesRenderer> for BorderRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for BorderRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/clipped_surface.rs b/src/render_helpers/clipped_surface.rs
index f8d074e9..805e1bf3 100644
--- a/src/render_helpers/clipped_surface.rs
+++ b/src/render_helpers/clipped_surface.rs
@@ -218,7 +218,7 @@ impl<R: NiriRenderer> Element for ClippedSurfaceRenderElement<R> {
 impl RenderElement<GlesRenderer> for ClippedSurfaceRenderElement<GlesRenderer> {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -242,7 +242,7 @@ impl<'render> RenderElement<TtyRenderer<'render>>
 {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'render, '_>,
+        frame: &mut TtyFrame<'render, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/damage.rs b/src/render_helpers/damage.rs
index 328851e8..d5d899de 100644
--- a/src/render_helpers/damage.rs
+++ b/src/render_helpers/damage.rs
@@ -65,7 +65,7 @@ impl Element for ExtraDamage {
 impl<R: Renderer> RenderElement<R> for ExtraDamage {
     fn draw(
         &self,
-        _frame: &mut <R as Renderer>::Frame<'_>,
+        _frame: &mut R::Frame<'_, '_>,
         _src: Rectangle<f64, Buffer>,
         _dst: Rectangle<i32, Physical>,
         _damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/mod.rs b/src/render_helpers/mod.rs
index 36df83dc..369ee5c2 100644
--- a/src/render_helpers/mod.rs
+++ b/src/render_helpers/mod.rs
@@ -6,7 +6,7 @@ use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::{Buffer, Fourcc};
 use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
 use smithay::backend::renderer::element::{Kind, RenderElement};
-use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTexture};
+use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTarget, GlesTexture};
 use smithay::backend::renderer::sync::SyncPoint;
 use smithay::backend::renderer::{Bind, Color32F, ExportMem, Frame, Offscreen, Renderer};
 use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
@@ -197,15 +197,18 @@ pub fn render_to_texture(
 
     let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
 
-    let texture: GlesTexture = renderer
+    let mut texture: GlesTexture = renderer
         .create_buffer(fourcc, buffer_size)
         .context("error creating texture")?;
 
-    renderer
-        .bind(texture.clone())
-        .context("error binding texture")?;
+    let sync_point = {
+        let mut target = renderer
+            .bind(&mut texture)
+            .context("error binding texture")?;
+
+        render_elements(renderer, &mut target, size, scale, transform, elements)?
+    };
 
-    let sync_point = render_elements(renderer, size, scale, transform, elements)?;
     Ok((texture, sync_point))
 }
 
@@ -219,11 +222,16 @@ pub fn render_and_download(
 ) -> anyhow::Result<GlesMapping> {
     let _span = tracy_client::span!();
 
-    let (_, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;
+    let (mut texture, _) = render_to_texture(renderer, size, scale, transform, fourcc, elements)?;
 
     let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
+    // FIXME: would be nice to avoid binding the second time here (after render_to_texture()), but
+    // borrowing makes this invonvenient.
+    let target = renderer
+        .bind(&mut texture)
+        .context("error binding texture")?;
     let mapping = renderer
-        .copy_framebuffer(Rectangle::from_size(buffer_size), fourcc)
+        .copy_framebuffer(&target, Rectangle::from_size(buffer_size), fourcc)
         .context("error copying framebuffer")?;
     Ok(mapping)
 }
@@ -248,7 +256,7 @@ pub fn render_to_vec(
 
 pub fn render_to_dmabuf(
     renderer: &mut GlesRenderer,
-    dmabuf: Dmabuf,
+    mut dmabuf: Dmabuf,
     size: Size<i32, Physical>,
     scale: Scale<f64>,
     transform: Transform,
@@ -259,8 +267,10 @@ pub fn render_to_dmabuf(
         dmabuf.width() == size.w as u32 && dmabuf.height() == size.h as u32,
         "invalid buffer size"
     );
-    renderer.bind(dmabuf).context("error binding texture")?;
-    render_elements(renderer, size, scale, transform, elements)
+    let mut target = renderer
+        .bind(&mut dmabuf)
+        .context("error binding texture")?;
+    render_elements(renderer, &mut target, size, scale, transform, elements)
 }
 
 pub fn render_to_shm(
@@ -301,6 +311,7 @@ pub fn render_to_shm(
 
 fn render_elements(
     renderer: &mut GlesRenderer,
+    target: &mut GlesTarget,
     size: Size<i32, Physical>,
     scale: Scale<f64>,
     transform: Transform,
@@ -310,7 +321,7 @@ fn render_elements(
     let output_rect = Rectangle::from_size(transform.transform_size(size));
 
     let mut frame = renderer
-        .render(size, transform)
+        .render(target, size, transform)
         .context("error starting frame")?;
 
     frame
diff --git a/src/render_helpers/offscreen.rs b/src/render_helpers/offscreen.rs
index 96b0692f..9005e80c 100644
--- a/src/render_helpers/offscreen.rs
+++ b/src/render_helpers/offscreen.rs
@@ -171,7 +171,7 @@ impl Element for OffscreenRenderElement {
 impl RenderElement<GlesRenderer> for OffscreenRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -212,7 +212,7 @@ impl RenderElement<GlesRenderer> for OffscreenRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for OffscreenRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/primary_gpu_texture.rs b/src/render_helpers/primary_gpu_texture.rs
index 702b70b4..1d318582 100644
--- a/src/render_helpers/primary_gpu_texture.rs
+++ b/src/render_helpers/primary_gpu_texture.rs
@@ -56,7 +56,7 @@ impl Element for PrimaryGpuTextureRenderElement {
 impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -77,7 +77,7 @@ impl RenderElement<GlesRenderer> for PrimaryGpuTextureRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for PrimaryGpuTextureRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/render_elements.rs b/src/render_helpers/render_elements.rs
index 6dcba09d..0ff74352 100644
--- a/src/render_helpers/render_elements.rs
+++ b/src/render_helpers/render_elements.rs
@@ -99,7 +99,7 @@ macro_rules! niri_render_elements {
         {
             fn draw(
                 &self,
-                frame: &mut smithay::backend::renderer::gles::GlesFrame<'_>,
+                frame: &mut smithay::backend::renderer::gles::GlesFrame<'_, '_>,
                 src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
                 dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
                 damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
@@ -124,7 +124,7 @@ macro_rules! niri_render_elements {
         {
             fn draw(
                 &self,
-                frame: &mut $crate::backend::tty::TtyFrame<'render, '_>,
+                frame: &mut $crate::backend::tty::TtyFrame<'render, '_, '_>,
                 src: smithay::utils::Rectangle<f64, smithay::utils::Buffer>,
                 dst: smithay::utils::Rectangle<i32, smithay::utils::Physical>,
                 damage: &[smithay::utils::Rectangle<i32, smithay::utils::Physical>],
diff --git a/src/render_helpers/renderer.rs b/src/render_helpers/renderer.rs
index 605c0caa..9c42ea3d 100644
--- a/src/render_helpers/renderer.rs
+++ b/src/render_helpers/renderer.rs
@@ -1,7 +1,7 @@
 use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::renderer::gles::{GlesFrame, GlesRenderer, GlesTexture};
 use smithay::backend::renderer::{
-    Bind, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, Texture,
+    Bind, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, RendererSuper, Texture,
 };
 
 use crate::backend::tty::{TtyFrame, TtyRenderer};
@@ -21,7 +21,7 @@ pub trait NiriRenderer:
     type NiriError: std::error::Error
         + Send
         + Sync
-        + From<<GlesRenderer as Renderer>::Error>
+        + From<<GlesRenderer as RendererSuper>::Error>
         + 'static;
 }
 
@@ -29,7 +29,8 @@ impl<R> NiriRenderer for R
 where
     R: ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Offscreen<GlesTexture> + AsGlesRenderer,
     R::TextureId: Texture + Clone + Send + 'static,
-    R::Error: std::error::Error + Send + Sync + From<<GlesRenderer as Renderer>::Error> + 'static,
+    R::Error:
+        std::error::Error + Send + Sync + From<<GlesRenderer as RendererSuper>::Error> + 'static,
 {
     type NiriTextureId = R::TextureId;
     type NiriError = R::Error;
@@ -53,21 +54,21 @@ impl AsGlesRenderer for TtyRenderer<'_> {
 }
 
 /// Trait for getting the underlying `GlesFrame`.
-pub trait AsGlesFrame<'frame>
+pub trait AsGlesFrame<'frame, 'buffer>
 where
     Self: 'frame,
 {
-    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame>;
+    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer>;
 }
 
-impl<'frame> AsGlesFrame<'frame> for GlesFrame<'frame> {
-    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
+impl<'frame, 'buffer> AsGlesFrame<'frame, 'buffer> for GlesFrame<'frame, 'buffer> {
+    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer> {
         self
     }
 }
 
-impl<'frame> AsGlesFrame<'frame> for TtyFrame<'_, 'frame> {
-    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame> {
+impl<'frame, 'buffer> AsGlesFrame<'frame, 'buffer> for TtyFrame<'_, 'frame, 'buffer> {
+    fn as_gles_frame(&mut self) -> &mut GlesFrame<'frame, 'buffer> {
         self.as_mut()
     }
 }
diff --git a/src/render_helpers/resize.rs b/src/render_helpers/resize.rs
index f8cbadda..827eada2 100644
--- a/src/render_helpers/resize.rs
+++ b/src/render_helpers/resize.rs
@@ -163,7 +163,7 @@ impl Element for ResizeRenderElement {
 impl RenderElement<GlesRenderer> for ResizeRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -181,7 +181,7 @@ impl RenderElement<GlesRenderer> for ResizeRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for ResizeRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/shader_element.rs b/src/render_helpers/shader_element.rs
index 09cd721e..5f7beed0 100644
--- a/src/render_helpers/shader_element.rs
+++ b/src/render_helpers/shader_element.rs
@@ -283,7 +283,7 @@ impl Element for ShaderRenderElement {
 impl RenderElement<GlesRenderer> for ShaderRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dest: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -514,7 +514,7 @@ impl RenderElement<GlesRenderer> for ShaderRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for ShaderRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/shaders/mod.rs b/src/render_helpers/shaders/mod.rs
index ddc58cdb..f1d11739 100644
--- a/src/render_helpers/shaders/mod.rs
+++ b/src/render_helpers/shaders/mod.rs
@@ -107,7 +107,7 @@ impl Shaders {
         }
     }
 
-    pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_>) -> &'a Self {
+    pub fn get_from_frame<'a>(frame: &'a mut GlesFrame<'_, '_>) -> &'a Self {
         let data = frame.egl_context().user_data();
         data.get()
             .expect("shaders::init() must be called when creating the renderer")
diff --git a/src/render_helpers/shadow.rs b/src/render_helpers/shadow.rs
index 332703a0..0a8c731d 100644
--- a/src/render_helpers/shadow.rs
+++ b/src/render_helpers/shadow.rs
@@ -233,7 +233,7 @@ impl Element for ShadowRenderElement {
 impl RenderElement<GlesRenderer> for ShadowRenderElement {
     fn draw(
         &self,
-        frame: &mut GlesFrame<'_>,
+        frame: &mut GlesFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
@@ -250,7 +250,7 @@ impl RenderElement<GlesRenderer> for ShadowRenderElement {
 impl<'render> RenderElement<TtyRenderer<'render>> for ShadowRenderElement {
     fn draw(
         &self,
-        frame: &mut TtyFrame<'_, '_>,
+        frame: &mut TtyFrame<'_, '_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
diff --git a/src/render_helpers/solid_color.rs b/src/render_helpers/solid_color.rs
index 5dfb5843..8cf9cca8 100644
--- a/src/render_helpers/solid_color.rs
+++ b/src/render_helpers/solid_color.rs
@@ -153,12 +153,12 @@ impl Element for SolidColorRenderElement {
 impl<R: Renderer> RenderElement<R> for SolidColorRenderElement {
     fn draw(
         &self,
-        frame: &mut <R as Renderer>::Frame<'_>,
+        frame: &mut R::Frame<'_, '_>,
         _src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
         _opaque_regions: &[Rectangle<i32, Physical>],
-    ) -> Result<(), <R as Renderer>::Error> {
+    ) -> Result<(), R::Error> {
         frame.draw_solid(dst, damage, self.color)
     }
 
diff --git a/src/render_helpers/texture.rs b/src/render_helpers/texture.rs
index 8273c6f6..a5d38a6f 100644
--- a/src/render_helpers/texture.rs
+++ b/src/render_helpers/texture.rs
@@ -58,7 +58,7 @@ impl<T> TextureBuffer<T> {
         scale: impl Into<Scale<f64>>,
         transform: Transform,
         opaque_regions: Vec<Rectangle<i32, Buffer>>,
-    ) -> Result<Self, <R as Renderer>::Error> {
+    ) -> Result<Self, R::Error> {
         let texture = renderer.import_memory(data, format, size.into(), flipped)?;
         Ok(TextureBuffer::from_texture(
             renderer,
@@ -72,7 +72,7 @@ impl<T> TextureBuffer<T> {
     pub fn from_memory_buffer<R: Renderer<TextureId = T> + ImportMem>(
         renderer: &mut R,
         buffer: &MemoryBuffer,
-    ) -> Result<Self, <R as Renderer>::Error> {
+    ) -> Result<Self, R::Error> {
         Self::from_memory(
             renderer,
             buffer.data(),
@@ -213,12 +213,12 @@ where
 {
     fn draw(
         &self,
-        frame: &mut <R as Renderer>::Frame<'_>,
+        frame: &mut R::Frame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dest: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
         opaque_regions: &[Rectangle<i32, Physical>],
-    ) -> Result<(), <R as Renderer>::Error> {
+    ) -> Result<(), R::Error> {
         if frame.id() != self.buffer.renderer_id {
             warn!("trying to render texture from different renderer");
             return Ok(());