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

wip: screencopy

Browse source
This commit is contained in:
Victoria Brekenfeld 2022-11-03 18:51:27 +01:00
parent dd100d65e4
commit 5a4df346a8
26 changed files with 2046 additions and 327 deletions
Download patch file Download diff file Expand all files Collapse all files

72
src/backend/kms/mod.rs
View file

@ -9,18 +9,23 @@ use crate::{
shell::Shell,
state::{BackendData, ClientState, Common, Data},
utils::prelude::*,
wayland::{
handlers::screencopy::UserdataExt,
protocols::screencopy::{BufferParams, Session as ScreencopySession},
},
};
use anyhow::{Context, Result};
use smithay::{
backend::{
allocator::{dmabuf::Dmabuf, gbm::GbmDevice, Format},
drm::{DrmDevice, DrmEvent, DrmEventTime, DrmNode, GbmBufferedSurface, NodeType},
drm::{DrmDevice, DrmEvent, DrmNode, GbmBufferedSurface, NodeType},
egl::{EGLContext, EGLDevice, EGLDisplay},
input::InputEvent,
libinput::{LibinputInputBackend, LibinputSessionInterface},
renderer::{
damage::DamageTrackedRenderer,
element::RenderElementStates,
gles2::{Gles2Renderbuffer, Gles2Renderer},
multigpu::{egl::EglGlesBackend, GpuManager},
Bind,
@ -61,7 +66,7 @@ mod socket;
use session_fd::*;
use socket::*;
use super::render::GlMultiRenderer;
use super::render::{CursorMode, GlMultiRenderer};
pub struct KmsState {
devices: HashMap<DrmNode, Device>,
@ -89,7 +94,7 @@ pub struct Surface {
damage_tracker: DamageTrackedRenderer,
connector: connector::Handle,
output: Output,
last_submit: Option<DrmEventTime>,
last_submit: Option<RenderElementStates>,
refresh_rate: u32,
vrr: bool,
pending: bool,
@ -123,12 +128,11 @@ pub fn init_backend(
}
data.state.process_input_event(event);
for output in data.state.common.shell.outputs() {
if let Err(err) = data
.state
.backend
.kms()
.schedule_render(&data.state.common.event_loop_handle, output)
{
if let Err(err) = data.state.backend.kms().schedule_render(
&data.state.common.event_loop_handle,
output,
None,
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
output.name(),
@ -267,12 +271,16 @@ pub fn init_backend(
surface.pending = false;
}
for output in data.state.common.shell.outputs() {
if let Err(err) = data
.state
.backend
.kms()
.schedule_render(&data.state.common.event_loop_handle, output)
{
let sessions = output.pending_buffers().collect::<Vec<_>>();
if let Err(err) = data.state.backend.kms().schedule_render(
&data.state.common.event_loop_handle,
output,
if !sessions.is_empty() {
Some(sessions)
} else {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
output.name(),
@ -372,9 +380,12 @@ impl State {
if let Some(surface) = device.surfaces.get_mut(&crtc) {
match surface.surface.as_mut().map(|x| x.frame_submitted()) {
Some(Ok(_)) => {
surface.last_submit = metadata.take().map(|data| data.time);
let _submit_time = metadata.take().map(|data| data.time);
surface.pending = false;
data.state.common.send_frames(&surface.output);
data.state.common.send_frames(
&surface.output,
&surface.last_submit.take().unwrap(),
);
}
Some(Err(err)) => {
slog_scope::warn!("Failed to submit frame: {}", err)
@ -749,6 +760,7 @@ impl Surface {
api: &mut GpuManager<EglGlesBackend<Gles2Renderer>>,
target_node: &DrmNode,
state: &mut Common,
screencopy: Option<&[(ScreencopySession, BufferParams)]>,
) -> Result<()> {
if self.surface.is_none() {
return Ok(());
@ -766,18 +778,20 @@ impl Surface {
.bind(buffer.clone())
.with_context(|| "Failed to bind buffer")?;
match render::render_output(
match render::render_output::<_, Gles2Renderbuffer, _>(
Some(&render_node),
&mut renderer,
&mut self.damage_tracker,
age as usize,
state,
&self.output,
false,
CursorMode::All,
screencopy.map(|sessions| (buffer, sessions)),
#[cfg(feature = "debug")]
Some(&mut self.fps),
) {
Ok(_) => {
Ok((_damage, states)) => {
self.last_submit = Some(states);
surface
.queue_buffer()
.with_context(|| "Failed to submit buffer for display")?;
@ -893,7 +907,16 @@ impl KmsState {
shell.refresh_outputs();
if recreated {
if let Err(err) = self.schedule_render(loop_handle, output) {
let sessions = output.pending_buffers().collect::<Vec<_>>();
if let Err(err) = self.schedule_render(
loop_handle,
output,
if !sessions.is_empty() {
Some(sessions)
} else {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
output.name(),
@ -956,6 +979,7 @@ impl KmsState {
&mut self,
loop_handle: &LoopHandle<'_, Data>,
output: &Output,
mut screencopy_sessions: Option<Vec<(ScreencopySession, BufferParams)>>,
) -> Result<(), InsertError<Timer>> {
if let Some((device, crtc, surface)) = self
.devices
@ -1001,7 +1025,13 @@ impl KmsState {
&mut backend.api,
&device.render_node,
&mut data.state.common,
screencopy_sessions.as_deref(),
) {
if let Some(sessions) = screencopy_sessions.as_mut() {
for (session, params) in sessions.drain(..) {
data.state.common.still_pending(session, params);
}
}
if backend.session.is_active() {
slog_scope::error!("Error rendering: {}", err);
return TimeoutAction::ToDuration(Duration::from_secs_f64(

6
src/backend/render/cursor.rs
View file

@ -172,8 +172,8 @@ pub fn draw_dnd_icon<R: Renderer + ImportAll>(
)
}
struct CursorState {
cursor: Cursor,
pub struct CursorState {
pub cursor: Cursor,
current_image: RefCell<Option<Image>>,
image_cache: RefCell<HashMap<(TypeId, usize), Vec<(Image, Box<dyn Any + 'static>)>>>,
}
@ -219,7 +219,7 @@ where
if let CursorImageStatus::Surface(ref wl_surface) = cursor_status {
return draw_surface_cursor(wl_surface, location.to_i32_round(), scale);
} else if draw_default {
} else if draw_default && CursorImageStatus::Default == cursor_status {
let integer_scale = scale.x.max(scale.y).ceil() as u32;
let seat_userdata = seat.user_data();

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

@ -11,19 +11,28 @@ use crate::{
layout::floating::SeatMoveGrabState, CosmicMappedRenderElement, WorkspaceRenderElement,
},
state::Common,
wayland::handlers::data_device::get_dnd_icon,
wayland::{
handlers::{data_device::get_dnd_icon, screencopy::render_to_buffer},
protocols::{
screencopy::{BufferParams, Session as ScreencopySession},
workspace::WorkspaceHandle,
},
},
};
use cosmic_protocols::screencopy::v1::server::zcosmic_screencopy_session_v1::FailureReason;
use smithay::{
backend::{
allocator::dmabuf::Dmabuf,
drm::DrmNode,
renderer::{
damage::{
DamageTrackedRenderer, DamageTrackedRendererError as RenderError, OutputNoMode,
},
element::RenderElementStates,
gles2::{Gles2Renderbuffer, Gles2Renderer},
multigpu::{egl::EglGlesBackend, MultiFrame, MultiRenderer},
ImportAll, ImportMem, Renderer,
Bind, Blit, ExportMem, ImportAll, ImportMem, Offscreen, Renderer, TextureFilter,
},
},
output::Output,
@ -42,7 +51,7 @@ pub type GlMultiRenderer<'a> = MultiRenderer<
>;
pub type GlMultiFrame = MultiFrame<EglGlesBackend<Gles2Renderer>, EglGlesBackend<Gles2Renderer>>;
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];
smithay::render_elements! {
pub CosmicElement<R> where R: ImportAll;
@ -53,11 +62,18 @@ smithay::render_elements! {
//EguiFrame=EguiFrame,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CursorMode {
None,
NotDefault,
All,
}
pub fn cursor_elements<E, R>(
renderer: &mut R,
state: &Common,
output: &Output,
hardware_cursor: bool,
mode: CursorMode,
) -> Vec<E>
where
R: Renderer + ImportAll + ImportMem,
@ -76,18 +92,20 @@ where
.shell
.map_global_to_space(pointer.current_location().to_i32_round(), output);
elements.extend(
cursor::draw_cursor(
renderer,
seat,
location,
scale.into(),
&state.start_time,
!hardware_cursor,
)
.into_iter()
.map(E::from),
);
if mode != CursorMode::None {
elements.extend(
cursor::draw_cursor(
renderer,
seat,
location,
scale.into(),
&state.start_time,
mode != CursorMode::NotDefault,
)
.into_iter()
.map(E::from),
);
}
if let Some(wl_surface) = get_dnd_icon(seat) {
elements.extend(
@ -112,21 +130,30 @@ where
elements
}
pub fn render_output<R>(
pub fn render_output<R, Target, Source>(
gpu: Option<&DrmNode>,
renderer: &mut R,
damage_tracker: &mut DamageTrackedRenderer,
age: usize,
state: &mut Common,
output: &Output,
hardware_cursor: bool,
cursor_mode: CursorMode,
screencopy: Option<(Source, &[(ScreencopySession, BufferParams)])>,
#[cfg(feature = "debug")] mut fps: Option<&mut Fps>,
) -> Result<Option<Vec<Rectangle<i32, Physical>>>, RenderError<R>>
) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), RenderError<R>>
where
R: Renderer + ImportAll + ImportMem,
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<Target>
+ Bind<Source>
+ Blit<Source>,
<R as Renderer>::TextureId: Clone + 'static,
Source: Clone,
{
let idx = state.shell.workspaces.active_num(output);
let handle = state.shell.workspaces.active(output).handle;
render_workspace(
gpu,
renderer,
@ -134,24 +161,34 @@ where
age,
state,
output,
idx,
hardware_cursor,
&handle,
cursor_mode,
screencopy,
)
}
pub fn render_workspace<R>(
_gpu: Option<&DrmNode>,
pub fn render_workspace<R, Target, Source>(
gpu: Option<&DrmNode>,
renderer: &mut R,
damage_tracker: &mut DamageTrackedRenderer,
age: usize,
state: &mut Common,
output: &Output,
idx: usize,
hardware_cursor: bool,
handle: &WorkspaceHandle,
cursor_mode: CursorMode,
screencopy: Option<(Source, &[(ScreencopySession, BufferParams)])>,
#[cfg(feature = "debug")] mut fps: Option<&mut Fps>,
) -> Result<Option<Vec<Rectangle<i32, Physical>>>, RenderError<R>>
) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), RenderError<R>>
where
R: Renderer + ImportAll + ImportMem,
R: Renderer
+ ImportAll
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<Target>
+ Bind<Source>
+ Blit<Source>,
Source: Clone,
<R as Renderer>::TextureId: Clone + 'static,
{
#[cfg(feature = "debug")]
@ -159,14 +196,9 @@ where
fps.start();
}
let workspace = &state
.shell
.workspaces
.get(idx, output)
.ok_or(OutputNoMode)?;
let workspace = state.shell.space_for_handle(&handle).ok_or(OutputNoMode)?;
let mut elements: Vec<CosmicElement<R>> =
cursor_elements(renderer, state, output, hardware_cursor);
let mut elements: Vec<CosmicElement<R>> = cursor_elements(renderer, state, output, cursor_mode);
#[cfg(feature = "debug")]
{
@ -219,5 +251,39 @@ where
fps.end();
}
if let Some((source, buffers)) = screencopy {
if res.is_ok() {
for (session, params) in buffers {
match render_to_buffer(
gpu.cloned(),
renderer,
&session,
params,
output.current_transform(),
|_node, renderer, dtr, age| {
let res = dtr.damage_output(age, &elements, slog_scope::logger())?;
if let (Some(ref damage), _) = &res {
for rect in damage {
renderer
.blit_from(source.clone(), *rect, *rect, TextureFilter::Nearest)
.map_err(RenderError::Rendering)?;
}
}
Ok(res)
},
) {
Ok(true) => {} // success
Ok(false) => state.still_pending(session.clone(), params.clone()),
Err(err) => {
slog_scope::warn!("Error rendering to screencopy session: {}", err);
session.failed(FailureReason::Unspec);
}
}
}
}
}
res
}

33
src/backend/winit.rs
View file

@ -6,11 +6,12 @@ use crate::{
input::Devices,
state::{BackendData, Common, Data},
utils::prelude::*,
wayland::protocols::screencopy::{BufferParams, Session as ScreencopySession},
};
use anyhow::{anyhow, Context, Result};
use smithay::{
backend::{
renderer::{damage::DamageTrackedRenderer, ImportDma, ImportEgl},
renderer::{damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, ImportDma, ImportEgl},
winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice},
},
desktop::layer_map_for_output,
@ -26,11 +27,14 @@ use std::cell::RefCell;
#[cfg(feature = "debug")]
use crate::state::Fps;
use super::render::CursorMode;
pub struct WinitState {
// The winit backend currently has no notion of multiple windows
pub backend: WinitGraphicsBackend,
output: Output,
damage_tracker: DamageTrackedRenderer,
screencopy: Vec<(ScreencopySession, BufferParams)>,
#[cfg(feature = "debug")]
fps: Fps,
}
@ -42,24 +46,34 @@ impl WinitState {
.with_context(|| "Failed to bind buffer")?;
let age = self.backend.buffer_age().unwrap_or(0);
match render::render_output(
let surface = self.backend.egl_surface();
match render::render_output::<_, Gles2Renderbuffer, _>(
None,
self.backend.renderer(),
&mut self.damage_tracker,
age,
state,
&self.output,
true,
CursorMode::NotDefault,
if !self.screencopy.is_empty() {
Some((surface, &self.screencopy))
} else {
None
},
#[cfg(feature = "debug")]
Some(&mut self.fps),
) {
Ok(damage) => {
state.send_frames(&self.output);
Ok((damage, states)) => {
self.screencopy.clear();
self.backend
.submit(damage.as_ref().map(|x| &**x))
.submit(damage.as_deref())
.with_context(|| "Failed to submit buffer for display")?;
state.send_frames(&self.output, &states);
}
Err(err) => {
for (session, params) in self.screencopy.drain(..) {
state.still_pending(session, params)
}
anyhow::bail!("Rendering failed: {}", err);
}
};
@ -92,6 +106,12 @@ impl WinitState {
Ok(())
}
}
pub fn pending_screencopy(&mut self, new: Option<Vec<(ScreencopySession, BufferParams)>>) {
if let Some(sessions) = new {
self.screencopy.extend(sessions);
}
}
}
pub fn init_backend(
@ -186,6 +206,7 @@ pub fn init_backend(
backend,
output: output.clone(),
damage_tracker: DamageTrackedRenderer::from_output(&output),
screencopy: Vec::new(),
#[cfg(feature = "debug")]
fps: Fps::default(),
});

38
src/backend/x11.rs
View file

@ -6,6 +6,7 @@ use crate::{
input::Devices,
state::{BackendData, Common, Data},
utils::prelude::*,
wayland::protocols::screencopy::{BufferParams, Session as ScreencopySession},
};
use anyhow::{Context, Result};
use smithay::{
@ -14,7 +15,9 @@ use smithay::{
egl::{EGLContext, EGLDisplay},
input::{Event, InputEvent},
renderer::{
damage::DamageTrackedRenderer, gles2::Gles2Renderer, Bind, ImportDma, ImportEgl,
damage::DamageTrackedRenderer,
gles2::{Gles2Renderbuffer, Gles2Renderer},
Bind, ImportDma, ImportEgl,
},
x11::{Window, WindowBuilder, X11Backend, X11Event, X11Handle, X11Input, X11Surface},
},
@ -121,6 +124,7 @@ impl X11State {
render: ping.clone(),
dirty: false,
pending: true,
screencopy: Vec::new(),
#[cfg(feature = "debug")]
fps: Fps::default(),
});
@ -130,9 +134,16 @@ impl X11State {
Ok(output)
}
pub fn schedule_render(&mut self, output: &Output) {
pub fn schedule_render(
&mut self,
output: &Output,
screencopy: Option<Vec<(ScreencopySession, BufferParams)>>,
) {
if let Some(surface) = self.surfaces.iter_mut().find(|s| s.output == *output) {
surface.dirty = true;
if let Some(sessions) = screencopy {
surface.screencopy.extend(sessions);
}
if !surface.pending {
surface.render.ping();
}
@ -172,6 +183,7 @@ impl X11State {
pub struct Surface {
window: Window,
damage_tracker: DamageTrackedRenderer,
screencopy: Vec<(ScreencopySession, BufferParams)>,
surface: X11Surface,
output: Output,
render: ping::Ping,
@ -192,27 +204,36 @@ impl Surface {
.buffer()
.with_context(|| "Failed to allocate buffer")?;
renderer
.bind(buffer)
.bind(buffer.clone())
.with_context(|| "Failed to bind buffer")?;
match render::render_output(
match render::render_output::<_, Gles2Renderbuffer, _>(
None,
renderer,
&mut self.damage_tracker,
age as usize,
state,
&self.output,
true,
render::CursorMode::NotDefault,
if !self.screencopy.is_empty() {
Some((buffer, &self.screencopy))
} else {
None
},
#[cfg(feature = "debug")]
Some(&mut self.fps),
) {
Ok(_) => {
state.send_frames(&self.output);
Ok((_damage, states)) => {
self.screencopy.clear();
self.surface
.submit()
.with_context(|| "Failed to submit buffer for display")?;
state.send_frames(&self.output, &states);
}
Err(err) => {
for (session, params) in self.screencopy.drain(..) {
state.still_pending(session, params)
}
self.surface.reset_buffers();
anyhow::bail!("Rendering failed: {}", err);
}
@ -417,8 +438,7 @@ impl State {
self.process_input_event(event);
// TODO actually figure out the output
for output in self.common.shell.outputs() {
self.backend
.schedule_render(&self.common.event_loop_handle, output);
self.backend.x11().schedule_render(output, None);
}
}
}