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

chore: smithay update

Browse source
This commit is contained in:
Victoria Brekenfeld 2025-03-11 19:14:49 +01:00 • committed by Victoria Brekenfeld
parent f8fae8a5b0
commit 95b27637ae
23 changed files with 336 additions and 373 deletions
Download patch file Download diff file Expand all files Collapse all files

219
src/wayland/handlers/screencopy/render.rs
View file

@ -57,13 +57,14 @@ use super::super::data_device::get_dnd_icon;
pub fn submit_buffer<R>(
frame: Frame,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
transform: Transform,
damage: Option<&[Rectangle<i32, Physical>]>,
sync: SyncPoint,
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, <R as Renderer>::Error>
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, R::Error>
where
R: ExportMem,
<R as Renderer>::Error: FromGlesError,
R::Error: FromGlesError,
{
let Some(damage) = damage else {
frame.success(
@ -77,7 +78,8 @@ where
};
let buffer = frame.buffer();
if matches!(buffer_type(&buffer), Some(BufferType::Shm)) {
if let Some(fb) = offscreen {
assert!(matches!(buffer_type(&buffer), Some(BufferType::Shm)));
let buffer_size = buffer_dimensions(&buffer).unwrap();
if let Err(err) = with_buffer_contents_mut(&buffer, |ptr, len, data| {
let offset = data.offset;
@ -98,7 +100,8 @@ where
renderer.wait(&sync)?;
let format = get_transparent(format).unwrap_or(format);
let mapping = renderer.copy_framebuffer(Rectangle::from_size(buffer_size), format)?;
let mapping =
renderer.copy_framebuffer(fb, Rectangle::from_size(buffer_size), format)?;
let gl_data = renderer.map_texture(&mapping)?;
assert!((width * height * pixelsize) as usize <= gl_data.len());
@ -113,7 +116,7 @@ where
}
Ok(())
})
.map_err(|err| <R as Renderer>::Error::from_gles_error(GlesError::BufferAccessError(err)))
.map_err(|err| R::Error::from_gles_error(GlesError::BufferAccessError(err)))
.and_then(|x| x)
{
frame.fail(FailureReason::Unknown);
@ -133,31 +136,51 @@ where
)))
}
pub fn render_session<F, R>(
pub fn render_session<F, R, T>(
renderer: &mut R,
session: &SessionData,
frame: Frame,
transform: Transform,
render_fn: F,
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<<R as Renderer>::Error>>
) -> Result<Option<(Frame, Vec<Rectangle<i32, BufferCoords>>)>, DTError<R::Error>>
where
R: ExportMem,
<R as Renderer>::Error: FromGlesError,
F: for<'d> FnOnce(
R: ExportMem + Offscreen<T>,
R::Error: FromGlesError,
F: for<'d, 'f> FnOnce(
&WlBuffer,
&mut R,
Option<&mut R::Framebuffer<'f>>,
&'d mut OutputDamageTracker,
usize,
Vec<Rectangle<i32, BufferCoords>>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>,
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>,
{
let mut session_damage_tracking = session.lock().unwrap();
let buffer = frame.buffer();
let mut offscreen = matches!(buffer_type(&buffer), Some(BufferType::Shm))
.then(|| {
let size = buffer_dimensions(&buffer).ok_or(DTError::OutputNoMode(OutputNoMode))?;
let format = with_buffer_contents(&buffer, |_, _, data| {
shm_format_to_fourcc(data.format)
.expect("We should be able to convert all hardcoded shm screencopy formats")
})
.map_err(|_| DTError::OutputNoMode(OutputNoMode))?;
renderer
.create_buffer(format, size)
.map_err(DTError::Rendering)
})
.transpose()?;
let age = session_damage_tracking.age_for_buffer(&buffer);
let mut fb = offscreen
.as_mut()
.map(|tex| renderer.bind(tex).map_err(DTError::Rendering))
.transpose()?;
let res = render_fn(
&frame.buffer(),
renderer,
fb.as_mut(),
&mut session_damage_tracking.dt,
age,
frame.damage(),
@ -167,6 +190,7 @@ where
Ok(result) => submit_buffer(
frame,
renderer,
fb.as_mut(),
transform,
result.damage.map(|x| x.as_slice()),
result.sync,
@ -217,6 +241,7 @@ pub fn render_workspace_to_buffer(
fn render_fn<'d, R>(
buffer: &WlBuffer,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker,
mut age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>,
@ -224,18 +249,11 @@ pub fn render_workspace_to_buffer(
common: &mut Common,
output: &Output,
handle: (WorkspaceHandle, usize),
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
WorkspaceRenderElement<R>: RenderElement<R>,
@ -273,10 +291,12 @@ pub fn render_workspace_to_buffer(
});
if let Ok(dmabuf) = get_dmabuf(buffer) {
render_workspace::<_, _, GlesRenderbuffer>(
let mut dmabuf = dmabuf.clone();
let mut fb = renderer.bind(&mut dmabuf).map_err(DTError::Rendering)?;
render_workspace(
None,
renderer,
dmabuf.clone(),
&mut fb,
dt,
age,
additional_damage,
@ -291,23 +311,12 @@ pub fn render_workspace_to_buffer(
)
.map(|res| res.0)
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|err| {
DTError::Rendering(<R as Renderer>::Error::from_gles_error(
GlesError::BufferAccessError(err),
))
})?
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
let target = offscreen.expect("shm buffers should have an offscreen target");
age = 0;
render_workspace::<_, _, GlesRenderbuffer>(
render_workspace(
None,
renderer,
render_buffer,
target,
dt,
age,
additional_damage,
@ -359,15 +368,16 @@ pub fn render_workspace_to_buffer(
};
let result = match renderer {
RendererRef::Glow(renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
transform,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -386,15 +396,16 @@ pub fn render_workspace_to_buffer(
}
}
RendererRef::GlMulti(mut renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
&mut renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
transform,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -458,25 +469,19 @@ pub fn render_window_to_buffer(
fn render_fn<'d, R>(
buffer: &WlBuffer,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker,
mut age: usize,
age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>,
draw_cursor: bool,
common: &mut Common,
window: &CosmicSurface,
geometry: Rectangle<i32, Logical>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
@ -557,25 +562,15 @@ pub fn render_window_to_buffer(
}
if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer.bind(dmabuf.clone()).map_err(DTError::Rendering)?;
let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(DTError::Rendering)?;
dt.render_output(renderer, &mut fb, age, &elements, Color32F::TRANSPARENT)
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|err| {
DTError::Rendering(<R as Renderer>::Error::from_gles_error(
GlesError::BufferAccessError(err),
))
})?
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
age = 0;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
let fb = offscreen.expect("shm buffer should have an offscreen target");
dt.render_output(renderer, fb, 0, &elements, Color32F::TRANSPARENT)
}
dt.render_output(renderer, age, &elements, Color32F::TRANSPARENT)
}
let common = &mut state.common;
@ -607,15 +602,16 @@ pub fn render_window_to_buffer(
}
};
let result = match renderer {
RendererRef::Glow(renderer) => match render_session::<_, _>(
RendererRef::Glow(renderer) => match render_session::<_, _, GlesRenderbuffer>(
renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -632,15 +628,16 @@ pub fn render_window_to_buffer(
None
}
},
RendererRef::GlMulti(mut renderer) => match render_session::<_, _>(
RendererRef::GlMulti(mut renderer) => match render_session::<_, _, GlesRenderbuffer>(
&mut renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
@ -697,23 +694,17 @@ pub fn render_cursor_to_buffer(
fn render_fn<'d, R>(
buffer: &WlBuffer,
renderer: &mut R,
offscreen: Option<&mut R::Framebuffer<'_>>,
dt: &'d mut OutputDamageTracker,
mut age: usize,
age: usize,
additional_damage: Vec<Rectangle<i32, BufferCoords>>,
common: &mut Common,
seat: &Seat<State>,
) -> Result<RenderOutputResult<'d>, DTError<<R as Renderer>::Error>>
) -> Result<RenderOutputResult<'d>, DTError<R::Error>>
where
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Send + Clone + 'static,
<R as Renderer>::Error: FromGlesError,
R: Renderer + ImportAll + ImportMem + ExportMem + Bind<Dmabuf> + Blit + AsGlowRenderer,
R::TextureId: Send + Clone + 'static,
R::Error: FromGlesError,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
@ -743,25 +734,15 @@ pub fn render_cursor_to_buffer(
);
if let Ok(dmabuf) = get_dmabuf(buffer) {
renderer.bind(dmabuf.clone()).map_err(DTError::Rendering)?;
let mut dmabuf_clone = dmabuf.clone();
let mut fb = renderer
.bind(&mut dmabuf_clone)
.map_err(DTError::Rendering)?;
dt.render_output(renderer, &mut fb, age, &elements, [0.0, 0.0, 0.0, 0.0])
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|err| {
DTError::Rendering(<R as Renderer>::Error::from_gles_error(
GlesError::BufferAccessError(err),
))
})?
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
age = 0;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
let fb = offscreen.expect("shm buffers should have offscreen target");
dt.render_output(renderer, fb, 0, &elements, [0.0, 0.0, 0.0, 0.0])
}
dt.render_output(renderer, age, &elements, [0.0, 0.0, 0.0, 0.0])
}
let common = &mut state.common;
@ -775,13 +756,22 @@ pub fn render_cursor_to_buffer(
};
let result = match renderer {
RendererRef::Glow(renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
render_fn(buffer, renderer, dt, age, additional_damage, common, seat)
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
common,
seat,
)
},
) {
Ok(frame) => frame,
@ -792,13 +782,22 @@ pub fn render_cursor_to_buffer(
}
}
RendererRef::GlMulti(mut renderer) => {
match render_session::<_, _>(
match render_session::<_, _, GlesRenderbuffer>(
&mut renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
render_fn(buffer, renderer, dt, age, additional_damage, common, seat)
|buffer, renderer, offscreen, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
offscreen,
dt,
age,
additional_damage,
common,
seat,
)
},
) {
Ok(frame) => frame,