wayland: implement linux-drm-syncobj-v1
This commit is contained in:
Julian Orth
parent
816315170f
commit
aaf73d6fdc
29 changed files with 1507 additions and 35 deletions
295
src/ifs/wl_surface/commit_timeline.rs
Normal file
295
src/ifs/wl_surface/commit_timeline.rs
Normal file
|
|
@ -0,0 +1,295 @@
|
|||
use {
|
||||
crate::{
|
||||
ifs::wl_surface::{PendingState, WlSurface, WlSurfaceError},
|
||||
utils::{
|
||||
clonecell::CloneCell,
|
||||
copyhashmap::CopyHashMap,
|
||||
linkedlist::{LinkedList, LinkedNode, NodeRef},
|
||||
numcell::NumCell,
|
||||
},
|
||||
video::drm::{
|
||||
sync_obj::{SyncObj, SyncObjPoint},
|
||||
wait_for_sync_obj::{SyncObjWaiter, WaitForSyncObj, WaitForSyncObjHandle},
|
||||
DrmError,
|
||||
},
|
||||
},
|
||||
isnt::std_1::primitive::IsntSliceExt,
|
||||
smallvec::SmallVec,
|
||||
std::{
|
||||
cell::{Cell, RefCell},
|
||||
mem,
|
||||
ops::{Deref, DerefMut},
|
||||
rc::Rc,
|
||||
},
|
||||
thiserror::Error,
|
||||
};
|
||||
|
||||
const MAX_TIMELINE_DEPTH: usize = 256;
|
||||
|
||||
linear_ids!(CommitTimelineIds, CommitTimelineId, u64);
|
||||
|
||||
pub struct CommitTimelines {
|
||||
next_id: CommitTimelineIds,
|
||||
wfs: Rc<WaitForSyncObj>,
|
||||
depth: NumCell<usize>,
|
||||
gc: CopyHashMap<CommitTimelineId, LinkedList<Entry>>,
|
||||
}
|
||||
|
||||
pub struct CommitTimeline {
|
||||
shared: Rc<CommitTimelines>,
|
||||
own_timeline: Rc<Inner>,
|
||||
effective_timeline: CloneCell<Rc<Inner>>,
|
||||
effective_timeline_id: Cell<CommitTimelineId>,
|
||||
}
|
||||
|
||||
struct Inner {
|
||||
id: CommitTimelineId,
|
||||
entries: LinkedList<Entry>,
|
||||
}
|
||||
|
||||
fn add_entry(
|
||||
list: &LinkedList<Entry>,
|
||||
shared: &Rc<CommitTimelines>,
|
||||
kind: EntryKind,
|
||||
) -> NodeRef<Entry> {
|
||||
shared.depth.fetch_add(1);
|
||||
let link = list.add_last(Entry {
|
||||
link: Cell::new(None),
|
||||
shared: shared.clone(),
|
||||
kind,
|
||||
});
|
||||
let noderef = link.to_ref();
|
||||
noderef.link.set(Some(link));
|
||||
noderef
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum CommitTimelineError {
|
||||
#[error(transparent)]
|
||||
ImmediateCommit(WlSurfaceError),
|
||||
#[error("Could not apply a delayed commit")]
|
||||
DelayedCommit(#[source] WlSurfaceError),
|
||||
#[error("Could not register a wait")]
|
||||
RegisterWait(#[source] DrmError),
|
||||
#[error("Syncobj wait failed")]
|
||||
Wait(#[source] DrmError),
|
||||
#[error("The client has too many pending commits")]
|
||||
Depth,
|
||||
}
|
||||
|
||||
impl CommitTimelines {
|
||||
pub fn new(wfs: &Rc<WaitForSyncObj>) -> Self {
|
||||
Self {
|
||||
next_id: Default::default(),
|
||||
depth: NumCell::new(0),
|
||||
wfs: wfs.clone(),
|
||||
gc: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_timeline(self: &Rc<Self>) -> CommitTimeline {
|
||||
let id = self.next_id.next();
|
||||
let timeline = Rc::new(Inner {
|
||||
id,
|
||||
entries: Default::default(),
|
||||
});
|
||||
CommitTimeline {
|
||||
shared: self.clone(),
|
||||
own_timeline: timeline.clone(),
|
||||
effective_timeline: CloneCell::new(timeline),
|
||||
effective_timeline_id: Cell::new(id),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn clear(&self) {
|
||||
for (_, list) in self.gc.lock().drain() {
|
||||
break_loops(&list);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub enum ClearReason {
|
||||
BreakLoops,
|
||||
Destroy,
|
||||
}
|
||||
|
||||
fn break_loops(list: &LinkedList<Entry>) {
|
||||
for entry in list.iter() {
|
||||
entry.link.take();
|
||||
}
|
||||
}
|
||||
|
||||
impl CommitTimeline {
|
||||
pub fn clear(&self, reason: ClearReason) {
|
||||
match reason {
|
||||
ClearReason::BreakLoops => break_loops(&self.own_timeline.entries),
|
||||
ClearReason::Destroy => {
|
||||
if self.own_timeline.entries.is_not_empty() {
|
||||
let list = LinkedList::new();
|
||||
list.append_all(&self.own_timeline.entries);
|
||||
add_entry(&list, &self.shared, EntryKind::Gc(self.own_timeline.id));
|
||||
self.shared.gc.set(self.own_timeline.id, list);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn commit(
|
||||
&self,
|
||||
surface: &Rc<WlSurface>,
|
||||
pending: &mut Box<PendingState>,
|
||||
) -> Result<(), CommitTimelineError> {
|
||||
let mut points = SmallVec::new();
|
||||
consume_acquire_points(pending, &mut points);
|
||||
if points.is_empty() && self.own_timeline.entries.is_empty() {
|
||||
return surface
|
||||
.apply_state(pending)
|
||||
.map_err(CommitTimelineError::ImmediateCommit);
|
||||
}
|
||||
if self.shared.depth.get() >= MAX_TIMELINE_DEPTH {
|
||||
return Err(CommitTimelineError::Depth);
|
||||
}
|
||||
set_effective_timeline(self, pending, &self.own_timeline);
|
||||
let noderef = add_entry(
|
||||
&self.own_timeline.entries,
|
||||
&self.shared,
|
||||
EntryKind::Commit(Commit {
|
||||
surface: surface.clone(),
|
||||
pending: RefCell::new(mem::take(pending)),
|
||||
sync_obj: NumCell::new(points.len()),
|
||||
wait_handles: Cell::new(Default::default()),
|
||||
}),
|
||||
);
|
||||
if points.is_not_empty() {
|
||||
let mut wait_handles = SmallVec::new();
|
||||
let noderef = Rc::new(noderef);
|
||||
for (sync_obj, point) in points {
|
||||
let handle = self
|
||||
.shared
|
||||
.wfs
|
||||
.wait(&sync_obj, point, true, noderef.clone())
|
||||
.map_err(CommitTimelineError::RegisterWait)?;
|
||||
wait_handles.push(handle);
|
||||
}
|
||||
let EntryKind::Commit(commit) = &noderef.kind else {
|
||||
unreachable!();
|
||||
};
|
||||
commit.wait_handles.set(wait_handles);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl SyncObjWaiter for NodeRef<Entry> {
|
||||
fn done(self: Rc<Self>, result: Result<(), DrmError>) {
|
||||
let EntryKind::Commit(commit) = &self.kind else {
|
||||
unreachable!();
|
||||
};
|
||||
if let Err(e) = result {
|
||||
commit.surface.client.error(CommitTimelineError::Wait(e));
|
||||
return;
|
||||
}
|
||||
commit.sync_obj.fetch_sub(1);
|
||||
if let Err(e) = flush_from(self.deref().clone()) {
|
||||
commit
|
||||
.surface
|
||||
.client
|
||||
.error(CommitTimelineError::DelayedCommit(e));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Entry {
|
||||
link: Cell<Option<LinkedNode<Entry>>>,
|
||||
shared: Rc<CommitTimelines>,
|
||||
kind: EntryKind,
|
||||
}
|
||||
|
||||
enum EntryKind {
|
||||
Commit(Commit),
|
||||
Wait(Cell<bool>),
|
||||
Signal(NodeRef<Entry>),
|
||||
Gc(CommitTimelineId),
|
||||
}
|
||||
|
||||
struct Commit {
|
||||
surface: Rc<WlSurface>,
|
||||
pending: RefCell<Box<PendingState>>,
|
||||
sync_obj: NumCell<usize>,
|
||||
wait_handles: Cell<SmallVec<[WaitForSyncObjHandle; 1]>>,
|
||||
}
|
||||
|
||||
fn flush_from(mut point: NodeRef<Entry>) -> Result<(), WlSurfaceError> {
|
||||
let mut gc_list = None;
|
||||
while point.maybe_apply(&mut gc_list)? {
|
||||
point.shared.depth.fetch_sub(1);
|
||||
let _link = point.link.take();
|
||||
match point.next() {
|
||||
None => break,
|
||||
Some(n) => point = n,
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
impl NodeRef<Entry> {
|
||||
fn maybe_apply(&self, gc_list: &mut Option<LinkedList<Entry>>) -> Result<bool, WlSurfaceError> {
|
||||
if self.prev().is_some() {
|
||||
return Ok(false);
|
||||
}
|
||||
match &self.kind {
|
||||
EntryKind::Commit(c) => {
|
||||
if c.sync_obj.get() > 0 {
|
||||
return Ok(false);
|
||||
}
|
||||
c.surface.apply_state(c.pending.borrow_mut().deref_mut())?;
|
||||
Ok(true)
|
||||
}
|
||||
EntryKind::Wait(signaled) => Ok(signaled.get()),
|
||||
EntryKind::Signal(s) => match &s.kind {
|
||||
EntryKind::Wait(signaled) => {
|
||||
signaled.set(true);
|
||||
flush_from(s.clone())?;
|
||||
Ok(true)
|
||||
}
|
||||
_ => unreachable!(),
|
||||
},
|
||||
EntryKind::Gc(id) => {
|
||||
*gc_list = self.shared.gc.remove(id);
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Point = (Rc<SyncObj>, SyncObjPoint);
|
||||
|
||||
fn consume_acquire_points(pending: &mut PendingState, points: &mut SmallVec<[Point; 1]>) {
|
||||
if let Some(point) = pending.acquire_point.take() {
|
||||
points.push(point);
|
||||
}
|
||||
for ss in pending.subsurfaces.values_mut() {
|
||||
consume_acquire_points(&mut ss.state, points);
|
||||
}
|
||||
}
|
||||
|
||||
fn set_effective_timeline(
|
||||
timeline: &CommitTimeline,
|
||||
pending: &PendingState,
|
||||
effective: &Rc<Inner>,
|
||||
) {
|
||||
if timeline.effective_timeline_id.replace(effective.id) != effective.id {
|
||||
let prev = timeline.effective_timeline.set(effective.clone());
|
||||
if prev.entries.is_not_empty() {
|
||||
let noderef = add_entry(
|
||||
&effective.entries,
|
||||
&timeline.shared,
|
||||
EntryKind::Wait(Cell::new(false)),
|
||||
);
|
||||
add_entry(&prev.entries, &timeline.shared, EntryKind::Signal(noderef));
|
||||
}
|
||||
}
|
||||
for ss in pending.subsurfaces.values() {
|
||||
set_effective_timeline(&ss.subsurface.surface.commit_timeline, &ss.state, effective);
|
||||
}
|
||||
}
|
||||
|
|
@ -313,7 +313,7 @@ impl Object for WlSubsurface {
|
|||
simple_add_obj!(WlSubsurface);
|
||||
|
||||
impl SurfaceExt for WlSubsurface {
|
||||
fn commit_requested(self: Rc<Self>, pending: &mut PendingState) -> CommitAction {
|
||||
fn commit_requested(self: Rc<Self>, pending: &mut Box<PendingState>) -> CommitAction {
|
||||
if self.sync() {
|
||||
let mut parent_pending = self.parent.pending.borrow_mut();
|
||||
match parent_pending.subsurfaces.entry(self.unique_id) {
|
||||
|
|
|
|||
103
src/ifs/wl_surface/wp_linux_drm_syncobj_surface_v1.rs
Normal file
103
src/ifs/wl_surface/wp_linux_drm_syncobj_surface_v1.rs
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
use {
|
||||
crate::{
|
||||
client::{Client, ClientError},
|
||||
ifs::wl_surface::WlSurface,
|
||||
leaks::Tracker,
|
||||
object::Object,
|
||||
utils::buffd::{MsgParser, MsgParserError},
|
||||
video::drm::sync_obj::SyncObjPoint,
|
||||
wire::{wp_linux_drm_syncobj_surface_v1::*, WpLinuxDrmSyncobjSurfaceV1Id},
|
||||
},
|
||||
std::rc::Rc,
|
||||
thiserror::Error,
|
||||
};
|
||||
|
||||
pub struct WpLinuxDrmSyncobjSurfaceV1 {
|
||||
id: WpLinuxDrmSyncobjSurfaceV1Id,
|
||||
client: Rc<Client>,
|
||||
surface: Rc<WlSurface>,
|
||||
pub tracker: Tracker<Self>,
|
||||
}
|
||||
|
||||
impl WpLinuxDrmSyncobjSurfaceV1 {
|
||||
pub fn new(
|
||||
id: WpLinuxDrmSyncobjSurfaceV1Id,
|
||||
client: &Rc<Client>,
|
||||
surface: &Rc<WlSurface>,
|
||||
) -> Self {
|
||||
Self {
|
||||
id,
|
||||
client: client.clone(),
|
||||
tracker: Default::default(),
|
||||
surface: surface.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn install(self: &Rc<Self>) -> Result<(), WpLinuxDrmSyncobjSurfaceV1Error> {
|
||||
if self.surface.sync_obj_surface.is_some() {
|
||||
return Err(WpLinuxDrmSyncobjSurfaceV1Error::Exists);
|
||||
}
|
||||
self.surface.sync_obj_surface.set(Some(self.clone()));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), WpLinuxDrmSyncobjSurfaceV1Error> {
|
||||
let _req: Destroy = self.client.parse(self, parser)?;
|
||||
self.surface.sync_obj_surface.take();
|
||||
let pending = &mut *self.surface.pending.borrow_mut();
|
||||
pending.release_point.take();
|
||||
pending.acquire_point.take();
|
||||
self.client.remove_obj(self)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_acquire_point(
|
||||
&self,
|
||||
parser: MsgParser<'_, '_>,
|
||||
) -> Result<(), WpLinuxDrmSyncobjSurfaceV1Error> {
|
||||
let req: SetAcquirePoint = self.client.parse(self, parser)?;
|
||||
let point = point(req.point_hi, req.point_lo);
|
||||
let timeline = self.client.lookup(req.timeline)?;
|
||||
self.surface.pending.borrow_mut().acquire_point = Some((timeline.sync_obj.clone(), point));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_release_point(
|
||||
&self,
|
||||
parser: MsgParser<'_, '_>,
|
||||
) -> Result<(), WpLinuxDrmSyncobjSurfaceV1Error> {
|
||||
let req: SetReleasePoint = self.client.parse(self, parser)?;
|
||||
let point = point(req.point_hi, req.point_lo);
|
||||
let timeline = self.client.lookup(req.timeline)?;
|
||||
self.surface.pending.borrow_mut().release_point = Some((timeline.sync_obj.clone(), point));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn point(hi: u32, lo: u32) -> SyncObjPoint {
|
||||
SyncObjPoint((hi as u64) << 32 | (lo as u64))
|
||||
}
|
||||
|
||||
object_base! {
|
||||
self = WpLinuxDrmSyncobjSurfaceV1;
|
||||
|
||||
DESTROY => destroy,
|
||||
SET_ACQUIRE_POINT => set_acquire_point,
|
||||
SET_RELEASE_POINT => set_release_point,
|
||||
}
|
||||
|
||||
impl Object for WpLinuxDrmSyncobjSurfaceV1 {}
|
||||
|
||||
simple_add_obj!(WpLinuxDrmSyncobjSurfaceV1);
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum WpLinuxDrmSyncobjSurfaceV1Error {
|
||||
#[error("Parsing failed")]
|
||||
MsgParserError(#[source] Box<MsgParserError>),
|
||||
#[error(transparent)]
|
||||
ClientError(Box<ClientError>),
|
||||
#[error("The surface already has a syncobj extension attached")]
|
||||
Exists,
|
||||
}
|
||||
efrom!(WpLinuxDrmSyncobjSurfaceV1Error, MsgParserError);
|
||||
efrom!(WpLinuxDrmSyncobjSurfaceV1Error, ClientError);
|
||||
Loading…
Add table
Add a link
Reference in a new issue