leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

image-copy: Use damage_output() for additional damage

Browse source 
The important change here is that we now apply the additional damage
first, instead of using `.extend()` to add it after other elements. This
is important since `OutputDamageTracker` will ignore our damage elements
if there are behind an element with an opaque region.

This also makes things a bit simpler, especially `take_screencopy_frames()`,
which no longer needs a mutable references to extend then truncate.

The implementation of `OutputDamageTracker` isn't entirely clear, but as
far as I can tell this is intended to work, and it seems to work in some
testing.
This commit is contained in:
Ian Douglas Scott 2025-09-17 11:06:02 -07:00 • committed by Victoria Brekenfeld
parent cac7a5aca6
commit 9bc1b6e1ee
4 changed files with 74 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

62
src/backend/kms/surface/mod.rs
View file

@ -1080,7 +1080,7 @@ impl SurfaceThreadState {
let frames = self let frames = self
.mirroring .mirroring
.is_none() .is_none()
.then(|| take_screencopy_frames(&self.output, &mut elements, &mut has_cursor_mode_none)) .then(|| take_screencopy_frames(&self.output, &elements, &mut has_cursor_mode_none))
.unwrap_or_default(); .unwrap_or_default();
// actual rendering // actual rendering
@ -1606,10 +1606,9 @@ fn get_surface_dmabuf_feedback(
} }
} }
// TODO: Don't mutate `elements`
fn take_screencopy_frames( fn take_screencopy_frames(
output: &Output, output: &Output,
elements: &mut Vec<CosmicElement<GlMultiRenderer>>, elements: &[CosmicElement<GlMultiRenderer>],
has_cursor_mode_none: &mut bool, has_cursor_mode_none: &mut bool,
) -> Vec<( ) -> Vec<(
ScreencopySessionRef, ScreencopySessionRef,
@ -1624,7 +1623,15 @@ fn take_screencopy_frames(
let session_data = session.user_data().get::<SessionData>().unwrap(); let session_data = session.user_data().get::<SessionData>().unwrap();
let mut damage_tracking = session_data.lock().unwrap(); let mut damage_tracking = session_data.lock().unwrap();
let old_len = if !additional_damage.is_empty() { let buffer = frame.buffer();
let age = if matches!(buffer_type(&buffer), Some(BufferType::Shm)) {
// TODO re-use offscreen buffer to damage track screencopy to shm
0
} else {
damage_tracking.age_for_buffer(&buffer)
};
if !additional_damage.is_empty() {
let area = output let area = output
.current_mode() .current_mode()
.unwrap() .unwrap()
@ -1634,41 +1641,26 @@ fn take_screencopy_frames(
.to_buffer(1, Transform::Normal) .to_buffer(1, Transform::Normal)
.to_f64(); .to_f64();
let old_len = elements.len(); let additional_damage_elements: Vec<_> = additional_damage
elements.extend( .into_iter()
additional_damage .map(|rect| {
.into_iter() rect.to_f64()
.map(|rect| { .to_logical(
rect.to_f64() output.current_scale().fractional_scale(),
.to_logical( output.current_transform(),
output.current_scale().fractional_scale(), &area,
output.current_transform(), )
&area, .to_i32_round()
) })
.to_i32_round() .map(DamageElement::new)
}) .collect();
.map(DamageElement::new) let _ = damage_tracking
.map(Into::into), .dt
); .damage_output(age, &additional_damage_elements);
Some(old_len)
} else {
None
}; };
let buffer = frame.buffer();
let age = if matches!(buffer_type(&frame.buffer()), Some(BufferType::Shm)) {
// TODO re-use offscreen buffer to damage track screencopy to shm
0
} else {
damage_tracking.age_for_buffer(&buffer)
};
let res = damage_tracking.dt.damage_output(age, elements); let res = damage_tracking.dt.damage_output(age, elements);
if let Some(old_len) = old_len {
elements.truncate(old_len);
}
if !session.draw_cursor() { if !session.draw_cursor() {
*has_cursor_mode_none = true; *has_cursor_mode_none = true;
} }

26
src/backend/render/element.rs
View file

@ -32,7 +32,6 @@ where
Cursor(RescaleRenderElement<RelocateRenderElement<CursorRenderElement<R>>>), Cursor(RescaleRenderElement<RelocateRenderElement<CursorRenderElement<R>>>),
Dnd(WaylandSurfaceRenderElement<R>), Dnd(WaylandSurfaceRenderElement<R>),
MoveGrab(RescaleRenderElement<CosmicMappedRenderElement<R>>), MoveGrab(RescaleRenderElement<CosmicMappedRenderElement<R>>),
AdditionalDamage(DamageElement),
Postprocess( Postprocess(
CropRenderElement<RelocateRenderElement<RescaleRenderElement<TextureShaderElement>>>, CropRenderElement<RelocateRenderElement<RescaleRenderElement<TextureShaderElement>>>,
), ),
@ -53,7 +52,6 @@ where
CosmicElement::Cursor(elem) => elem.id(), CosmicElement::Cursor(elem) => elem.id(),
CosmicElement::Dnd(elem) => elem.id(), CosmicElement::Dnd(elem) => elem.id(),
CosmicElement::MoveGrab(elem) => elem.id(), CosmicElement::MoveGrab(elem) => elem.id(),
CosmicElement::AdditionalDamage(elem) => elem.id(),
CosmicElement::Postprocess(elem) => elem.id(), CosmicElement::Postprocess(elem) => elem.id(),
CosmicElement::Zoom(elem) => elem.id(), CosmicElement::Zoom(elem) => elem.id(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -67,7 +65,6 @@ where
CosmicElement::Cursor(elem) => elem.current_commit(), CosmicElement::Cursor(elem) => elem.current_commit(),
CosmicElement::Dnd(elem) => elem.current_commit(), CosmicElement::Dnd(elem) => elem.current_commit(),
CosmicElement::MoveGrab(elem) => elem.current_commit(), CosmicElement::MoveGrab(elem) => elem.current_commit(),
CosmicElement::AdditionalDamage(elem) => elem.current_commit(),
CosmicElement::Postprocess(elem) => elem.current_commit(), CosmicElement::Postprocess(elem) => elem.current_commit(),
CosmicElement::Zoom(elem) => elem.current_commit(), CosmicElement::Zoom(elem) => elem.current_commit(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -81,7 +78,6 @@ where
CosmicElement::Cursor(elem) => elem.src(), CosmicElement::Cursor(elem) => elem.src(),
CosmicElement::Dnd(elem) => elem.src(), CosmicElement::Dnd(elem) => elem.src(),
CosmicElement::MoveGrab(elem) => elem.src(), CosmicElement::MoveGrab(elem) => elem.src(),
CosmicElement::AdditionalDamage(elem) => elem.src(),
CosmicElement::Postprocess(elem) => elem.src(), CosmicElement::Postprocess(elem) => elem.src(),
CosmicElement::Zoom(elem) => elem.src(), CosmicElement::Zoom(elem) => elem.src(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -95,7 +91,6 @@ where
CosmicElement::Cursor(elem) => elem.geometry(scale), CosmicElement::Cursor(elem) => elem.geometry(scale),
CosmicElement::Dnd(elem) => elem.geometry(scale), CosmicElement::Dnd(elem) => elem.geometry(scale),
CosmicElement::MoveGrab(elem) => elem.geometry(scale), CosmicElement::MoveGrab(elem) => elem.geometry(scale),
CosmicElement::AdditionalDamage(elem) => elem.geometry(scale),
CosmicElement::Postprocess(elem) => elem.geometry(scale), CosmicElement::Postprocess(elem) => elem.geometry(scale),
CosmicElement::Zoom(elem) => elem.geometry(scale), CosmicElement::Zoom(elem) => elem.geometry(scale),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -109,7 +104,6 @@ where
CosmicElement::Cursor(elem) => elem.location(scale), CosmicElement::Cursor(elem) => elem.location(scale),
CosmicElement::Dnd(elem) => elem.location(scale), CosmicElement::Dnd(elem) => elem.location(scale),
CosmicElement::MoveGrab(elem) => elem.location(scale), CosmicElement::MoveGrab(elem) => elem.location(scale),
CosmicElement::AdditionalDamage(elem) => elem.location(scale),
CosmicElement::Postprocess(elem) => elem.location(scale), CosmicElement::Postprocess(elem) => elem.location(scale),
CosmicElement::Zoom(elem) => elem.location(scale), CosmicElement::Zoom(elem) => elem.location(scale),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -123,7 +117,6 @@ where
CosmicElement::Cursor(elem) => elem.transform(), CosmicElement::Cursor(elem) => elem.transform(),
CosmicElement::Dnd(elem) => elem.transform(), CosmicElement::Dnd(elem) => elem.transform(),
CosmicElement::MoveGrab(elem) => elem.transform(), CosmicElement::MoveGrab(elem) => elem.transform(),
CosmicElement::AdditionalDamage(elem) => elem.transform(),
CosmicElement::Postprocess(elem) => elem.transform(), CosmicElement::Postprocess(elem) => elem.transform(),
CosmicElement::Zoom(elem) => elem.transform(), CosmicElement::Zoom(elem) => elem.transform(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -141,7 +134,6 @@ where
CosmicElement::Cursor(elem) => elem.damage_since(scale, commit), CosmicElement::Cursor(elem) => elem.damage_since(scale, commit),
CosmicElement::Dnd(elem) => elem.damage_since(scale, commit), CosmicElement::Dnd(elem) => elem.damage_since(scale, commit),
CosmicElement::MoveGrab(elem) => elem.damage_since(scale, commit), CosmicElement::MoveGrab(elem) => elem.damage_since(scale, commit),
CosmicElement::AdditionalDamage(elem) => elem.damage_since(scale, commit),
CosmicElement::Postprocess(elem) => elem.damage_since(scale, commit), CosmicElement::Postprocess(elem) => elem.damage_since(scale, commit),
CosmicElement::Zoom(elem) => elem.damage_since(scale, commit), CosmicElement::Zoom(elem) => elem.damage_since(scale, commit),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -155,7 +147,6 @@ where
CosmicElement::Cursor(elem) => elem.opaque_regions(scale), CosmicElement::Cursor(elem) => elem.opaque_regions(scale),
CosmicElement::Dnd(elem) => elem.opaque_regions(scale), CosmicElement::Dnd(elem) => elem.opaque_regions(scale),
CosmicElement::MoveGrab(elem) => elem.opaque_regions(scale), CosmicElement::MoveGrab(elem) => elem.opaque_regions(scale),
CosmicElement::AdditionalDamage(elem) => elem.opaque_regions(scale),
CosmicElement::Postprocess(elem) => elem.opaque_regions(scale), CosmicElement::Postprocess(elem) => elem.opaque_regions(scale),
CosmicElement::Zoom(elem) => elem.opaque_regions(scale), CosmicElement::Zoom(elem) => elem.opaque_regions(scale),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -169,7 +160,6 @@ where
CosmicElement::Cursor(elem) => elem.alpha(), CosmicElement::Cursor(elem) => elem.alpha(),
CosmicElement::Dnd(elem) => elem.alpha(), CosmicElement::Dnd(elem) => elem.alpha(),
CosmicElement::MoveGrab(elem) => elem.alpha(), CosmicElement::MoveGrab(elem) => elem.alpha(),
CosmicElement::AdditionalDamage(elem) => elem.alpha(),
CosmicElement::Postprocess(elem) => elem.alpha(), CosmicElement::Postprocess(elem) => elem.alpha(),
CosmicElement::Zoom(elem) => elem.alpha(), CosmicElement::Zoom(elem) => elem.alpha(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -183,7 +173,6 @@ where
CosmicElement::Cursor(elem) => elem.kind(), CosmicElement::Cursor(elem) => elem.kind(),
CosmicElement::Dnd(elem) => elem.kind(), CosmicElement::Dnd(elem) => elem.kind(),
CosmicElement::MoveGrab(elem) => elem.kind(), CosmicElement::MoveGrab(elem) => elem.kind(),
CosmicElement::AdditionalDamage(elem) => elem.kind(),
CosmicElement::Postprocess(elem) => elem.kind(), CosmicElement::Postprocess(elem) => elem.kind(),
CosmicElement::Zoom(elem) => elem.kind(), CosmicElement::Zoom(elem) => elem.kind(),
#[cfg(feature = "debug")] #[cfg(feature = "debug")]
@ -212,9 +201,6 @@ where
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, opaque_regions), CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage, opaque_regions), CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, opaque_regions), CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
CosmicElement::AdditionalDamage(elem) => {
RenderElement::<R>::draw(elem, frame, src, dst, damage, opaque_regions)
}
CosmicElement::Postprocess(elem) => { CosmicElement::Postprocess(elem) => {
let glow_frame = R::glow_frame_mut(frame); let glow_frame = R::glow_frame_mut(frame);
RenderElement::<GlowRenderer>::draw( RenderElement::<GlowRenderer>::draw(
@ -250,7 +236,6 @@ where
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer), CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
CosmicElement::Dnd(elem) => elem.underlying_storage(renderer), CosmicElement::Dnd(elem) => elem.underlying_storage(renderer),
CosmicElement::MoveGrab(elem) => elem.underlying_storage(renderer), CosmicElement::MoveGrab(elem) => elem.underlying_storage(renderer),
CosmicElement::AdditionalDamage(elem) => elem.underlying_storage(renderer),
CosmicElement::Postprocess(elem) => { CosmicElement::Postprocess(elem) => {
let glow_renderer = renderer.glow_renderer_mut(); let glow_renderer = renderer.glow_renderer_mut();
elem.underlying_storage(glow_renderer) elem.underlying_storage(glow_renderer)
@ -281,17 +266,6 @@ where
} }
} }
impl<R> From<DamageElement> for CosmicElement<R>
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
R::TextureId: 'static,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
fn from(elem: DamageElement) -> Self {
Self::AdditionalDamage(elem)
}
}
impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R> impl<R> From<MemoryRenderBufferRenderElement<R>> for CosmicElement<R>
where where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer, R: Renderer + ImportAll + ImportMem + AsGlowRenderer,

44
src/backend/render/mod.rs
View file

@ -1393,21 +1393,20 @@ where
)?; )?;
let old_len = elements.len(); let old_len = elements.len();
elements.extend( let additional_damage_elements: Vec<_> = additional_damage
additional_damage .into_iter()
.into_iter() .map(|rect| {
.map(|rect| { rect.to_f64()
rect.to_f64() .to_logical(
.to_logical( output.current_scale().fractional_scale(),
output.current_scale().fractional_scale(), output.current_transform(),
output.current_transform(), &area,
&area, )
) .to_i32_round()
.to_i32_round() })
}) .map(DamageElement::new)
.map(DamageElement::new) .collect();
.map(Into::into), dt.damage_output(age, &additional_damage_elements)?;
);
Some(old_len) Some(old_len)
} else { } else {
@ -1513,7 +1512,7 @@ where
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>, WorkspaceRenderElement<R>: RenderElement<R>,
{ {
let mut elements: Vec<CosmicElement<R>> = workspace_elements( let elements: Vec<CosmicElement<R>> = workspace_elements(
gpu, gpu,
renderer, renderer,
shell, shell,
@ -1528,13 +1527,12 @@ where
if let Some(additional_damage) = additional_damage { if let Some(additional_damage) = additional_damage {
let output_geo = output.geometry().to_local(output).as_logical(); let output_geo = output.geometry().to_local(output).as_logical();
elements.extend( let additional_damage_elements: Vec<_> = additional_damage
additional_damage .into_iter()
.into_iter() .filter_map(|rect| rect.intersection(output_geo))
.filter_map(|rect| rect.intersection(output_geo)) .map(DamageElement::new)
.map(DamageElement::new) .collect();
.map(Into::<CosmicElement<R>>::into), damage_tracker.damage_output(age, &additional_damage_elements)?;
);
} }
let res = damage_tracker.render_output( let res = damage_tracker.render_output(

55
src/wayland/handlers/image_copy_capture/render.rs
View file

@ -492,7 +492,6 @@ smithay::render_elements! {
pub WindowCaptureElement<R> where R: ImportAll + ImportMem; pub WindowCaptureElement<R> where R: ImportAll + ImportMem;
WaylandElement=WaylandSurfaceRenderElement<R>, WaylandElement=WaylandSurfaceRenderElement<R>,
CursorElement=RelocateRenderElement<cursor::CursorRenderElement<R>>, CursorElement=RelocateRenderElement<cursor::CursorRenderElement<R>>,
AdditionalDamage=DamageElement,
} }
pub fn render_window_to_buffer( pub fn render_window_to_buffer(
@ -543,22 +542,19 @@ pub fn render_window_to_buffer(
CosmicElement<R>: RenderElement<R>, CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
let mut elements = Vec::new(); let additional_damage_elements: Vec<_> = additional_damage
.into_iter()
elements.extend( .filter_map(|rect| {
additional_damage let logical_rect = rect.to_logical(
.into_iter() 1,
.filter_map(|rect| { Transform::Normal,
let logical_rect = rect.to_logical( &geometry.size.to_buffer(1, Transform::Normal),
1, );
Transform::Normal, logical_rect.intersection(Rectangle::from_size(geometry.size))
&geometry.size.to_buffer(1, Transform::Normal), })
); .map(DamageElement::new)
logical_rect.intersection(Rectangle::from_size(geometry.size)) .collect();
}) dt.damage_output(age, &additional_damage_elements)?;
.map(DamageElement::new)
.map(Into::<WindowCaptureElement<R>>::into),
);
let shell = common.shell.read(); let shell = common.shell.read();
let seat = shell.seats.last_active().clone(); let seat = shell.seats.last_active().clone();
@ -581,6 +577,8 @@ pub fn render_window_to_buffer(
}; };
std::mem::drop(shell); std::mem::drop(shell);
let mut elements = Vec::new();
if let Some(location) = location { if let Some(location) = location {
if draw_cursor { if draw_cursor {
elements.extend( elements.extend(
@ -783,7 +781,17 @@ pub fn render_cursor_to_buffer(
CosmicElement<R>: RenderElement<R>, CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>, CosmicMappedRenderElement<R>: RenderElement<R>,
{ {
let mut elements = cursor::draw_cursor( let additional_damage_elements: Vec<_> = additional_damage
.into_iter()
.filter_map(|rect| {
let logical_rect = rect.to_logical(1, Transform::Normal, &Size::from((64, 64)));
logical_rect.intersection(Rectangle::from_size((64, 64).into()))
})
.map(DamageElement::new)
.collect();
dt.damage_output(age, &additional_damage_elements)?;
let elements = cursor::draw_cursor(
renderer, renderer,
seat, seat,
Point::from((0.0, 0.0)), Point::from((0.0, 0.0)),
@ -797,17 +805,6 @@ pub fn render_cursor_to_buffer(
.map(WindowCaptureElement::from) .map(WindowCaptureElement::from)
.collect::<Vec<_>>(); .collect::<Vec<_>>();
elements.extend(
additional_damage
.into_iter()
.filter_map(|rect| {
let logical_rect = rect.to_logical(1, Transform::Normal, &Size::from((64, 64)));
logical_rect.intersection(Rectangle::from_size((64, 64).into()))
})
.map(DamageElement::new)
.map(Into::<WindowCaptureElement<R>>::into),
);
if let Ok(dmabuf) = get_dmabuf(buffer) { if let Ok(dmabuf) = get_dmabuf(buffer) {
let mut dmabuf_clone = dmabuf.clone(); let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer let mut fb = renderer