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

Define a RendererRef enum, referencing multi or glow renderer

Browse source 
Avoids a little duplication (matching two variants, instead of three
backends).

The behavior, including errors and panics, should be unchanged for now.
Performance should also not be impacted.

This should help for adding llvmpipe rendering without a device node on
the kms backend, or for adding a variant for pixman.
This commit is contained in:
Ian Douglas Scott 2024-08-05 10:18:42 -07:00 • committed by Ian Douglas Scott
parent 4748916ff9
commit 87020c79ba
5 changed files with 215 additions and 233 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -53,6 +53,7 @@ use smithay::{
element::PixelShaderElement, GlesError, GlesPixelProgram, GlesRenderer, Uniform, element::PixelShaderElement, GlesError, GlesPixelProgram, GlesRenderer, Uniform,
UniformName, UniformType, UniformName, UniformType,
}, },
glow::GlowRenderer,
multigpu::{Error as MultiError, MultiFrame, MultiRenderer}, multigpu::{Error as MultiError, MultiFrame, MultiRenderer},
sync::SyncPoint, sync::SyncPoint,
Bind, Blit, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, TextureFilter, Bind, Blit, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, TextureFilter,
@ -86,6 +87,29 @@ pub type GlMultiFrame<'a, 'frame> =
MultiFrame<'a, 'a, 'frame, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>; MultiFrame<'a, 'a, 'frame, GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub type GlMultiError = MultiError<GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>; pub type GlMultiError = MultiError<GbmGlowBackend<DrmDeviceFd>, GbmGlowBackend<DrmDeviceFd>>;
pub enum RendererRef<'a> {
Glow(&'a mut GlowRenderer),
GlMulti(GlMultiRenderer<'a>),
}
impl<'a> AsRef<GlowRenderer> for RendererRef<'a> {
fn as_ref(&self) -> &GlowRenderer {
match self {
Self::Glow(renderer) => renderer,
Self::GlMulti(renderer) => renderer.as_ref(),
}
}
}
impl<'a> AsMut<GlowRenderer> for RendererRef<'a> {
fn as_mut(&mut self) -> &mut GlowRenderer {
match self {
Self::Glow(renderer) => renderer,
Self::GlMulti(renderer) => renderer.as_mut(),
}
}
}
pub static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0]; pub static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0];
pub static OUTLINE_SHADER: &str = include_str!("./shaders/rounded_outline.frag"); pub static OUTLINE_SHADER: &str = include_str!("./shaders/rounded_outline.frag");
pub static RECTANGLE_SHADER: &str = include_str!("./shaders/rounded_rectangle.frag"); pub static RECTANGLE_SHADER: &str = include_str!("./shaders/rounded_rectangle.frag");

53
src/state.rs
View file

@ -1,7 +1,12 @@
// SPDX-License-Identifier: GPL-3.0-only // SPDX-License-Identifier: GPL-3.0-only
use crate::{ use crate::{
backend::{kms::KmsState, winit::WinitState, x11::X11State}, backend::{
kms::KmsState,
render::{GlMultiError, RendererRef},
winit::WinitState,
x11::X11State,
},
config::{Config, OutputConfig, OutputState}, config::{Config, OutputConfig, OutputState},
input::gestures::GestureState, input::gestures::GestureState,
shell::{grabs::SeatMoveGrabState, CosmicSurface, SeatExt, Shell}, shell::{grabs::SeatMoveGrabState, CosmicSurface, SeatExt, Shell},
@ -26,7 +31,7 @@ use once_cell::sync::Lazy;
use rust_embed::RustEmbed; use rust_embed::RustEmbed;
use smithay::{ use smithay::{
backend::{ backend::{
allocator::dmabuf::Dmabuf, allocator::{dmabuf::Dmabuf, Fourcc},
drm::DrmNode, drm::DrmNode,
renderer::{ renderer::{
element::{ element::{
@ -380,6 +385,50 @@ impl BackendData {
}; };
Ok(None) Ok(None)
} }
/// Get an offscreen renderer for screen capture / screenshot rendering
///
/// `kms_node_cb` callback use used to determine nodes to render with when using kms backend.
/// Panics if this returns `None`.
pub fn offscreen_renderer<N: Into<KmsNodes>, F: FnOnce(&mut KmsState) -> Option<N>>(
&mut self,
kms_node_cb: F,
) -> Result<RendererRef, GlMultiError> {
match self {
BackendData::Kms(kms) => {
let KmsNodes {
render_node,
target_node,
copy_format,
} = kms_node_cb(kms).expect("No Software Rendering").into();
Ok(RendererRef::GlMulti(kms.api.renderer(
&render_node,
&target_node,
copy_format,
)?))
}
BackendData::Winit(winit) => Ok(RendererRef::Glow(winit.backend.renderer())),
BackendData::X11(x11) => Ok(RendererRef::Glow(&mut x11.renderer)),
_ => unreachable!("No backend set when getting offscreen renderer"),
}
}
}
pub struct KmsNodes {
pub render_node: DrmNode,
pub target_node: DrmNode,
pub copy_format: Fourcc,
}
impl From<DrmNode> for KmsNodes {
fn from(node: DrmNode) -> Self {
KmsNodes {
render_node: node,
target_node: node,
// Ignored if render == target
copy_format: Fourcc::Abgr8888,
}
}
} }
pub fn client_has_no_security_context(client: &Client) -> bool { pub fn client_has_no_security_context(client: &Client) -> bool {

39
src/utils/screenshot.rs
View file

@ -16,8 +16,9 @@ use smithay::{
use tracing::warn; use tracing::warn;
use crate::{ use crate::{
backend::render::RendererRef,
shell::element::CosmicSurface, shell::element::CosmicSurface,
state::{advertised_node_for_surface, BackendData, State}, state::{advertised_node_for_surface, State},
}; };
pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) { pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) {
@ -96,27 +97,21 @@ pub fn screenshot_window(state: &mut State, surface: &CosmicSurface) {
} }
if let Some(wl_surface) = surface.wl_surface() { if let Some(wl_surface) = surface.wl_surface() {
let res = match &mut state.backend { let res = state
BackendData::Kms(kms) => { .backend
let node = advertised_node_for_surface(&wl_surface, &state.common.display_handle) .offscreen_renderer(|kms| {
.unwrap_or(kms.primary_node.expect("No Software Rendering")); advertised_node_for_surface(&wl_surface, &state.common.display_handle)
kms.api .or(kms.primary_node)
.single_renderer(&node) })
.with_context(|| "Failed to get renderer for screenshot") .with_context(|| "Failed to get renderer for screenshot")
.and_then(|mut multirenderer| { .and_then(|renderer| match renderer {
render_window(&mut multirenderer, surface, &state.common.local_offset) RendererRef::Glow(renderer) => {
}) render_window(renderer, surface, &state.common.local_offset)
} }
BackendData::Winit(winit) => render_window( RendererRef::GlMulti(mut renderer) => {
winit.backend.renderer(), render_window(&mut renderer, surface, &state.common.local_offset)
surface, }
&state.common.local_offset, });
),
BackendData::X11(x11) => {
render_window(&mut x11.renderer, surface, &state.common.local_offset)
}
BackendData::Unset => unreachable!(),
};
if let Err(err) = res { if let Err(err) = res {
warn!(?err, "Failed to take screenshot") warn!(?err, "Failed to take screenshot")
} }

37
src/wayland/handlers/screencopy/mod.rs
View file

@ -351,21 +351,10 @@ fn constraints_for_output(output: &Output, backend: &mut BackendData) -> Option<
} }
}; };
let mut _kms_renderer = None; let mut renderer = backend
let renderer = match backend { .offscreen_renderer(|kms| kms.target_node_for_output(&output).or(kms.primary_node))
BackendData::Kms(ref mut kms) => { .unwrap();
let node = kms Some(constraints_for_renderer(mode, renderer.as_mut()))
.target_node_for_output(&output)
.unwrap_or(kms.primary_node.expect("No Software Rendering"));
_kms_renderer = Some(kms.api.single_renderer(&node).unwrap());
_kms_renderer.as_mut().unwrap().as_mut()
}
BackendData::Winit(ref mut winit) => winit.backend.renderer(),
BackendData::X11(ref mut x11) => &mut x11.renderer,
_ => unreachable!(),
};
Some(constraints_for_renderer(mode, renderer))
} }
fn constraints_for_toplevel( fn constraints_for_toplevel(
@ -375,9 +364,8 @@ fn constraints_for_toplevel(
let size = surface.geometry().size.to_buffer(1, Transform::Normal); let size = surface.geometry().size.to_buffer(1, Transform::Normal);
let wl_surface = surface.wl_surface()?; let wl_surface = surface.wl_surface()?;
let mut _kms_renderer = None; let mut renderer = backend
let renderer = match backend { .offscreen_renderer(|kms| {
BackendData::Kms(ref mut kms) => {
let dma_node = with_renderer_surface_state(&wl_surface, |state| { let dma_node = with_renderer_surface_state(&wl_surface, |state| {
let buffer = state.buffer()?; let buffer = state.buffer()?;
let dmabuf = get_dmabuf(&*buffer).ok()?; let dmabuf = get_dmabuf(&*buffer).ok()?;
@ -385,16 +373,11 @@ fn constraints_for_toplevel(
}) })
.flatten(); .flatten();
let node = dma_node.unwrap_or(kms.primary_node.expect("No Software Rendering")); dma_node.or(kms.primary_node)
_kms_renderer = Some(kms.api.single_renderer(&node).unwrap()); })
_kms_renderer.as_mut().unwrap().as_mut() .unwrap();
}
BackendData::Winit(ref mut winit) => winit.backend.renderer(),
BackendData::X11(ref mut x11) => &mut x11.renderer,
_ => unreachable!(),
};
Some(constraints_for_renderer(size, renderer)) Some(constraints_for_renderer(size, renderer.as_mut()))
} }
fn constraints_for_renderer( fn constraints_for_renderer(

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

@ -36,10 +36,10 @@ use crate::{
backend::render::{ backend::render::{
cursor, cursor,
element::{AsGlowRenderer, CosmicElement, DamageElement, FromGlesError}, element::{AsGlowRenderer, CosmicElement, DamageElement, FromGlesError},
render_workspace, CursorMode, ElementFilter, CLEAR_COLOR, render_workspace, CursorMode, ElementFilter, RendererRef, CLEAR_COLOR,
}, },
shell::{CosmicMappedRenderElement, CosmicSurface, WorkspaceRenderElement}, shell::{CosmicMappedRenderElement, CosmicSurface, WorkspaceRenderElement},
state::{BackendData, Common, State}, state::{Common, KmsNodes, State},
utils::prelude::SeatExt, utils::prelude::SeatExt,
wayland::{ wayland::{
handlers::screencopy::{ handlers::screencopy::{
@ -326,39 +326,39 @@ pub fn render_workspace_to_buffer(
let transform = output.current_transform(); let transform = output.current_transform();
let common = &mut state.common; let common = &mut state.common;
let result = match &mut state.backend { let renderer = match state.backend.offscreen_renderer(|kms| {
BackendData::Kms(kms) => { let render_node = kms.target_node_for_output(&output).or(kms.primary_node)?;
let render_node = kms let target_node = get_dmabuf(&buffer)
.target_node_for_output(&output) .ok()
.unwrap_or(kms.primary_node.expect("No Software Rendering")); .and_then(|dma| dma.node())
let target_node = get_dmabuf(&buffer) .unwrap_or(render_node);
.ok()
.and_then(|dma| dma.node())
.unwrap_or(render_node);
let buffer_format = match buffer_type(&buffer) { let buffer_format = match buffer_type(&buffer) {
Some(BufferType::Dma) => Some(get_dmabuf(&buffer).unwrap().format().code), Some(BufferType::Dma) => Some(get_dmabuf(&buffer).unwrap().format().code),
Some(BufferType::Shm) => { Some(BufferType::Shm) => {
with_buffer_contents(&buffer, |_, _, data| shm_format_to_fourcc(data.format)) with_buffer_contents(&buffer, |_, _, data| shm_format_to_fourcc(data.format))
.unwrap() .unwrap()
} }
_ => None, _ => None,
}; };
let mut multirenderer = match kms.api.renderer(
&render_node,
&target_node,
buffer_format.unwrap_or(Fourcc::Abgr8888),
) {
Ok(renderer) => renderer,
Err(err) => {
warn!(?err, "Couldn't use nodes for screencopy");
frame.fail(FailureReason::Unknown);
return;
}
};
Some(KmsNodes {
render_node,
target_node,
copy_format: buffer_format.unwrap_or(Fourcc::Abgr8888),
})
}) {
Ok(renderer) => renderer,
Err(err) => {
warn!(?err, "Couldn't use node for screencopy");
frame.fail(FailureReason::Unknown);
return;
}
};
let result = match renderer {
RendererRef::Glow(renderer) => {
match render_session::<_, _>( match render_session::<_, _>(
&mut multirenderer, renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
transform, transform,
@ -383,57 +383,33 @@ pub fn render_workspace_to_buffer(
} }
} }
} }
BackendData::Winit(winit) => match render_session::<_, _>( RendererRef::GlMulti(mut renderer) => {
winit.backend.renderer(), match render_session::<_, _>(
session.user_data().get::<SessionData>().unwrap(), &mut renderer,
frame, session.user_data().get::<SessionData>().unwrap(),
transform, frame,
|buffer, renderer, dt, age, additional_damage| { transform,
render_fn( |buffer, renderer, dt, age, additional_damage| {
buffer, render_fn(
renderer, buffer,
dt, renderer,
age, dt,
additional_damage, age,
draw_cursor, additional_damage,
common, draw_cursor,
&output, common,
(handle, idx), &output,
) (handle, idx),
}, )
) { },
Ok(frame) => frame, ) {
Err(err) => { Ok(frame) => frame,
tracing::warn!(?err, "Failed to render to screencopy buffer"); Err(err) => {
None tracing::warn!(?err, "Failed to render to screencopy buffer");
None
}
} }
}, }
BackendData::X11(x11) => match render_session::<_, _>(
&mut x11.renderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
transform,
|buffer, renderer, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
dt,
age,
additional_damage,
draw_cursor,
common,
&output,
(handle, idx),
)
},
) {
Ok(frame) => frame,
Err(err) => {
tracing::warn!(?err, "Failed to render to screencopy buffer");
None
}
},
_ => unreachable!(),
}; };
if let Some((frame, damage)) = result { if let Some((frame, damage)) = result {
@ -601,61 +577,34 @@ pub fn render_window_to_buffer(
let common = &mut state.common; let common = &mut state.common;
let draw_cursor = session.draw_cursor(); let draw_cursor = session.draw_cursor();
let result = match &mut state.backend { let renderer = match state.backend.offscreen_renderer(|kms| {
BackendData::Kms(kms) => { get_dmabuf(&buffer)
let node = get_dmabuf(&buffer) .ok()
.ok() .and_then(|dmabuf| dmabuf.node())
.and_then(|dmabuf| dmabuf.node()) .or_else(|| {
.or_else(|| { toplevel
toplevel .wl_surface()
.wl_surface() .and_then(|wl_surface| {
.and_then(|wl_surface| { with_renderer_surface_state(&wl_surface, |state| {
with_renderer_surface_state(&wl_surface, |state| { let buffer = state.buffer()?;
let buffer = state.buffer()?; let dmabuf = get_dmabuf(&*buffer).ok()?;
let dmabuf = get_dmabuf(&*buffer).ok()?; dmabuf.node()
dmabuf.node()
})
}) })
.flatten() })
}) .flatten()
.unwrap_or(kms.primary_node.expect("No Software Rendering")); })
.or(kms.primary_node)
let mut multirenderer = match kms.api.single_renderer(&node) { }) {
Ok(renderer) => renderer, Ok(renderer) => renderer,
Err(err) => { Err(err) => {
warn!(?err, "Couldn't use node for screencopy"); warn!(?err, "Couldn't use node for screencopy");
frame.fail(FailureReason::Unknown); frame.fail(FailureReason::Unknown);
return; return;
}
};
match render_session::<_, _>(
&mut multirenderer,
session.user_data().get::<SessionData>().unwrap(),
frame,
Transform::Normal,
|buffer, renderer, dt, age, additional_damage| {
render_fn(
buffer,
renderer,
dt,
age,
additional_damage,
draw_cursor,
common,
toplevel,
geometry,
)
},
) {
Ok(frame) => frame,
Err(err) => {
tracing::warn!(?err, "Failed to render to screencopy buffer");
None
}
}
} }
BackendData::Winit(winit) => match render_session::<_, _>( };
winit.backend.renderer(), let result = match renderer {
RendererRef::Glow(renderer) => match render_session::<_, _>(
renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
@ -679,8 +628,8 @@ pub fn render_window_to_buffer(
None None
} }
}, },
BackendData::X11(x11) => match render_session::<_, _>( RendererRef::GlMulti(mut renderer) => match render_session::<_, _>(
&mut x11.renderer, &mut renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
@ -704,7 +653,6 @@ pub fn render_window_to_buffer(
None None
} }
}, },
_ => unreachable!(),
}; };
if let Some((frame, damage)) = result { if let Some((frame, damage)) = result {
@ -811,21 +759,18 @@ pub fn render_cursor_to_buffer(
} }
let common = &mut state.common; let common = &mut state.common;
let result = match &mut state.backend { let renderer = match state.backend.offscreen_renderer(|kms| kms.primary_node) {
BackendData::Kms(kms) => { Ok(renderer) => renderer,
let mut multirenderer = match kms Err(err) => {
.api warn!(?err, "Couldn't use node for screencopy");
.single_renderer(&kms.primary_node.expect("No Software Rendering")) frame.fail(FailureReason::Unknown);
{ return;
Ok(renderer) => renderer, }
Err(err) => { };
warn!(?err, "Couldn't use node for screencopy"); let result = match renderer {
frame.fail(FailureReason::Unknown); RendererRef::Glow(renderer) => {
return;
}
};
match render_session::<_, _>( match render_session::<_, _>(
&mut multirenderer, renderer,
session.user_data().get::<SessionData>().unwrap(), session.user_data().get::<SessionData>().unwrap(),
frame, frame,
Transform::Normal, Transform::Normal,
@ -840,37 +785,23 @@ pub fn render_cursor_to_buffer(
} }
} }
} }
BackendData::Winit(winit) => match render_session::<_, _>( RendererRef::GlMulti(mut renderer) => {
winit.backend.renderer(), match render_session::<_, _>(
session.user_data().get::<SessionData>().unwrap(), &mut renderer,
frame, session.user_data().get::<SessionData>().unwrap(),
Transform::Normal, frame,
|buffer, renderer, dt, age, additional_damage| { Transform::Normal,
render_fn(buffer, renderer, dt, age, additional_damage, common, seat) |buffer, renderer, dt, age, additional_damage| {
}, render_fn(buffer, renderer, dt, age, additional_damage, common, seat)
) { },
Ok(frame) => frame, ) {
Err(err) => { Ok(frame) => frame,
tracing::warn!(?err, "Failed to render to screencopy buffer"); Err(err) => {
None tracing::warn!(?err, "Failed to render to screencopy buffer");
None
}
} }
}, }
BackendData::X11(x11) => match render_session::<_, _>(
&mut x11.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)
},
) {
Ok(frame) => frame,
Err(err) => {
tracing::warn!(?err, "Failed to render to screencopy buffer");
None
}
},
_ => unreachable!(),
}; };
if let Some((frame, damage)) = result { if let Some((frame, damage)) = result {