renderer: Return a SyncPoint from blit; and use in blit_frame_result()

Author: ids1024

src/backend/drm/compositor/frame_result.rs

@@ -347,28 +347,33 @@ where
         }
 
         // first do the potential blit
-        if let Some((sync, mut dmabuf, geometry)) = primary_dmabuf {
+        if let Some((primary_dmabuf_sync, mut dmabuf, geometry)) = primary_dmabuf {
             let blit_damage = damage
                 .iter()
                 .filter_map(|d| d.intersection(geometry))
                 .collect::<Vec<_>>();
 
             tracing::trace!("blitting frame with damage: {:#?}", blit_damage);
 
-            renderer.wait(&sync).map_err(BlitFrameResultError::Rendering)?;
+            renderer
+                .wait(&primary_dmabuf_sync)
+                .map_err(BlitFrameResultError::Rendering)?;
             let fb = renderer
                 .bind(&mut dmabuf)
                 .map_err(BlitFrameResultError::Rendering)?;
             for rect in blit_damage {
-                renderer
-                    .blit(
-                        &fb,
-                        framebuffer,
-                        rect,
-                        rect,
-                        crate::backend::renderer::TextureFilter::Linear,
-                    )
-                    .map_err(BlitFrameResultError::Rendering)?;
+                // TODO: On Vulkan, may need to combine sync points instead of just using latest?
+                sync = Some(
+                    renderer
+                        .blit(
+                            &fb,
+                            framebuffer,
+                            rect,
+                            rect,
+                            crate::backend::renderer::TextureFilter::Linear,
+                        )
+                        .map_err(BlitFrameResultError::Rendering)?,
+                );
             }
         }
 

src/backend/renderer/gles/mod.rs

@@ -1702,7 +1702,7 @@ impl<'buffer> BlitFrame<GlesTarget<'buffer>> for GlesFrame<'_, 'buffer> {
         self.target
             .0
             .make_current(&self.renderer.gl, &self.renderer.egl)?;
-        res
+        res.map(|_| ())
     }
 
     fn blit_from(
@@ -1716,7 +1716,7 @@ impl<'buffer> BlitFrame<GlesTarget<'buffer>> for GlesFrame<'_, 'buffer> {
         self.target
             .0
             .make_current(&self.renderer.gl, &self.renderer.egl)?;
-        res
+        res.map(|_| ())
     }
 }
 
@@ -1730,7 +1730,7 @@ impl Blit for GlesRenderer {
         src: Rectangle<i32, Physical>,
         dst: Rectangle<i32, Physical>,
         filter: TextureFilter,
-    ) -> Result<(), GlesError> {
+    ) -> Result<SyncPoint, GlesError> {
         // glBlitFramebuffer is sadly only available for GLES 3.0 and higher
         if self.gl_version < version::GLES_3_0 {
             return Err(GlesError::GLVersionNotSupported(version::GLES_3_0));
@@ -1808,7 +1808,14 @@ impl Blit for GlesRenderer {
         if errno == ffi::INVALID_OPERATION {
             Err(GlesError::BlitError)
         } else {
-            Ok(())
+            if let Some(sync_point) = self.export_sync_point() {
+                return Ok(sync_point);
+            }
+
+            unsafe {
+                self.gl.Finish();
+            }
+            Ok(SyncPoint::signaled())
         }
     }
 }

src/backend/renderer/glow.rs

@@ -548,7 +548,7 @@ impl Blit for GlowRenderer {
         src: Rectangle<i32, Physical>,
         dst: Rectangle<i32, Physical>,
         filter: TextureFilter,
-    ) -> Result<(), GlesError> {
+    ) -> Result<sync::SyncPoint, GlesError> {
         self.gl.blit(from, to, src, dst, filter)
     }
 }

src/backend/renderer/mod.rs

@@ -59,6 +59,7 @@ pub mod element;
 pub mod damage;
 
 pub mod sync;
+use sync::SyncPoint;
 
 // Note: This doesn't fully work yet due to <https://github.com/rust-lang/rust/issues/67295>.
 // Use `--features renderer_test` when running doc tests manually.
@@ -342,7 +343,7 @@ pub trait Frame {
     /// Output transformation that is applied to this frame
     fn transformation(&self) -> Transform;
 
-    /// Wait for a [`SyncPoint`](sync::SyncPoint) to be signaled
+    /// Wait for a [`SyncPoint`] to be signaled
     fn wait(&mut self, sync: &sync::SyncPoint) -> Result<(), Self::Error>;
 
     /// Finish this [`Frame`] returning any error that may happen during any cleanup.
@@ -419,7 +420,7 @@ pub trait Renderer: RendererSuper {
     where
         'buffer: 'frame;
 
-    /// Wait for a [`SyncPoint`](sync::SyncPoint) to be signaled
+    /// Wait for a [`SyncPoint`] to be signaled
     fn wait(&mut self, sync: &sync::SyncPoint) -> Result<(), Self::Error>;
 
     /// Forcibly clean up the renderer internal texture cache
@@ -802,7 +803,7 @@ where
         src: Rectangle<i32, Physical>,
         dst: Rectangle<i32, Physical>,
         filter: TextureFilter,
-    ) -> Result<(), Self::Error>;
+    ) -> Result<SyncPoint, Self::Error>;
 }
 
 /// Trait for frames supporting blitting contents from/to the current framebuffer to/from another.

src/backend/renderer/multigpu/mod.rs

@@ -2863,11 +2863,13 @@ where
             let MultiFramebufferInternal::Target(ref mut to_fb) = &mut to.0 else {
                 unreachable!()
             };
-            target
+            let sync = target
                 .device
                 .renderer_mut()
                 .blit(target.framebuffer, to_fb, src, dst, filter)
-                .map_err(Error::Target)
+                .map_err(Error::Target)?;
+            target.device.renderer_mut().wait(&sync).map_err(Error::Target)?;
+            Ok(())
         } else {
             let MultiFramebufferInternal::Render(ref mut to_fb) = &mut to.0 else {
                 unreachable!()
@@ -2894,11 +2896,13 @@ where
             let MultiFramebufferInternal::Target(ref from_fb) = &from.0 else {
                 unreachable!()
             };
-            target
+            let sync = target
                 .device
                 .renderer_mut()
                 .blit(from_fb, target.framebuffer, src, dst, filter)
-                .map_err(Error::Target)
+                .map_err(Error::Target)?;
+            target.device.renderer_mut().wait(&sync).map_err(Error::Target)?;
+            Ok(())
         } else {
             let MultiFramebufferInternal::Render(ref from_fb) = &from.0 else {
                 unreachable!()
@@ -2935,7 +2939,7 @@ where
         src: Rectangle<i32, Physical>,
         dst: Rectangle<i32, Physical>,
         filter: TextureFilter,
-    ) -> Result<(), <Self as RendererSuper>::Error> {
+    ) -> Result<SyncPoint, <Self as RendererSuper>::Error> {
         if let Some(target) = self.target.as_mut() {
             let MultiFramebufferInternal::Target(ref from_fb) = &from.0 else {
                 unreachable!()