kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

autocommit 2022-03-13 19:41:04 CET

Browse source
This commit is contained in:
Julian Orth 2022-03-13 19:41:04 +01:00
parent e18be65210
commit 156bd5b042
8 changed files with 171 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/backends/metal/monitor.rs
View file

@ -85,20 +85,22 @@ impl MetalBackend {
fn handle_drm_device_resume(self: &Rc<Self>, dev: &Rc<MetalDrmDevice>, _fd: Rc<OwnedFd>) {
log::info!("Device resumed: {}", dev.dev.devnode.to_bytes().as_bstr());
let start = Instant::now();
if let Err(e) = self.resume_drm_device(dev) {
log::error!("Could not resume drm device: {}", ErrorFmt(e));
}
log::info!("resume took {:?}", start.elapsed());
}
fn handle_input_device_resume(self: &Rc<Self>, dev: &Rc<MetalInputDevice>, fd: Rc<OwnedFd>) {
let start = Instant::now();
log::info!("Device resumed: {}", dev.devnode.to_bytes().as_bstr());
dev.fd.set(Some(fd));
if let Some(old) = dev.fd.set(Some(fd)) {
self.state.fdcloser.close(old);
}
let inputdev = match self.libinput.open(dev.devnode.as_c_str()) {
Ok(d) => d,
Err(_) => return,
};
log::info!("took {:?}", start.elapsed());
inputdev.device().set_slot(dev.slot);
dev.inputdev.set(Some(inputdev));
}

113
src/backends/metal/video.rs
View file

@ -20,7 +20,6 @@ use std::cell::Cell;
use std::ffi::CString;
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use std::time::Instant;
use uapi::c;
pub struct PendingDrmDevice {
@ -69,8 +68,6 @@ pub struct MetalConnector {
pub id: DrmConnector,
pub master: Rc<DrmMaster>,
pub active: Cell<bool>,
pub output_id: OutputId,
pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
@ -226,7 +223,6 @@ fn create_connector(
Ok(MetalConnector {
id: connector,
master: dev.master.clone(),
active: Cell::new(false),
output_id: state.output_ids.next(),
crtcs,
mode: CloneCell::new(info.modes.first().cloned().map(|m| Rc::new(m))),
@ -593,56 +589,8 @@ impl MetalBackend {
self.present(&connector);
}
fn reuse_primary_planes(&self, dev: &MetalDrmDevice) -> AHashSet<DrmPlane> {
let mut crtc_primary_planes = AHashMap::new();
for connector in dev.connectors.values() {
connector.active.set(false);
connector.primary_plane.set(None);
if let Some(crtc) = connector.crtc.get() {
crtc_primary_planes.insert(crtc.id, vec![]);
}
}
fn reset_planes(&self, dev: &MetalDrmDevice, changes: &mut Change) {
for plane in dev.dev.planes.values() {
if plane.ty == PlaneType::Primary {
if let Some(ncp) = crtc_primary_planes.get_mut(&plane.crtc_id.value.get()) {
ncp.push(plane.clone());
}
}
}
let mut reuse_possible = true;
for planes in crtc_primary_planes.values() {
if planes.len() > 1 {
reuse_possible = false;
break;
}
if let Some(plane) = planes.first() {
if !plane.formats.contains_key(&XRGB8888.drm) {
reuse_possible = false;
break;
}
}
}
let mut preserve = AHashSet::new();
if !reuse_possible {
log::warn!("Not reusing primary planes");
return preserve;
}
for connector in dev.connectors.values() {
if let Some(planes) = crtc_primary_planes.get(&connector.crtc_id.value.get()) {
if let Some(plane) = planes.first() {
connector.primary_plane.set(Some(plane.clone()));
preserve.insert(plane.id);
}
}
}
preserve
}
fn reset_planes(&self, dev: &MetalDrmDevice, changes: &mut Change, preserve: &AHashSet<DrmPlane>) {
for plane in dev.dev.planes.values() {
if preserve.contains(&plane.id) {
continue;
}
plane.crtc_id.value.set(DrmCrtc::NONE);
changes.change_object(plane.id, |c| {
c.change(plane.crtc_id.id, 0);
@ -686,33 +634,15 @@ impl MetalBackend {
}
}
}
let preserve = self.reuse_primary_planes(dev);
self.reset_planes(dev, &mut changes, &preserve);
{
let mut connector: Vec<_> = dev.connectors.values().collect();
connector.sort_by_key(|k| {
if k.primary_plane.get().is_some() {
0
} else {
1
}
});
for connector in connector {
if let Err(e) = self.assign_connector_plane(dev, connector, &mut changes) {
log::error!("Could not assign a plane: {}", ErrorFmt(e));
}
}
}
self.reset_planes(dev, &mut changes);
for connector in dev.connectors.values() {
if !connector.active.get() {
connector.primary_plane.set(None);
if let Err(e) = self.assign_connector_plane(dev, connector, &mut changes) {
log::error!("Could not assign a plane: {}", ErrorFmt(e));
}
}
let mut start = Instant::now();
if let Err(e) = changes.commit(flags, 0) {
return Err(MetalError::Modeset(e));
}
log::info!("commit 2: {:?}", start.elapsed());
Ok(())
}
@ -892,34 +822,32 @@ impl MetalBackend {
return Ok(());
}
};
let mut primary_plane = connector.primary_plane.get();
if primary_plane.is_none() {
let primary_plane = 'primary_plane: {
for plane in crtc.possible_planes.values() {
if plane.ty == PlaneType::Primary
&& plane.crtc_id.value.get().is_none()
&& plane.formats.contains_key(&XRGB8888.drm)
{
primary_plane = Some(plane.clone());
break;
break 'primary_plane plane.clone();
}
}
}
let primary_plane = match primary_plane {
Some(p) => p,
_ => return Err(MetalError::NoPrimaryPlaneForConnector),
};
let format = ModifiedFormat {
format: XRGB8888,
modifier: INVALID_MODIFIER,
return Err(MetalError::NoPrimaryPlaneForConnector);
};
connector.buffers.set(None);
let buffers = match connector.buffers.get() {
Some(b) => b,
None => Rc::new(self.create_scanout_buffers(
dev,
&format,
mode.hdisplay as _,
mode.vdisplay as _,
)?),
None => {
let format = ModifiedFormat {
format: XRGB8888,
modifier: INVALID_MODIFIER,
};
Rc::new(self.create_scanout_buffers(
dev,
&format,
mode.hdisplay as _,
mode.vdisplay as _,
)?)
},
};
changes.change_object(primary_plane.id, |c| {
c.change(primary_plane.fb_id, buffers[0].drm.id().0 as _);
@ -944,7 +872,6 @@ impl MetalBackend {
primary_plane.src_h.value.set((mode.vdisplay as u32) << 16);
connector.buffers.set(Some(buffers));
connector.primary_plane.set(Some(primary_plane.clone()));
connector.active.set(true);
Ok(())
}

3
src/main.rs
View file

@ -55,6 +55,7 @@ use std::ops::Deref;
use std::rc::Rc;
use thiserror::Error;
use wheel::Wheel;
use crate::utils::fdcloser::FdCloser;
#[macro_use]
mod macros;
@ -101,6 +102,7 @@ mod xwayland;
fn main() {
env_logger::builder()
.format_timestamp_millis()
.filter_level(LevelFilter::Info)
.filter_level(LevelFilter::Debug)
// .filter_level(LevelFilter::Trace)
@ -178,6 +180,7 @@ fn main_() -> Result<(), MainError> {
pending_float_layout: Default::default(),
pending_float_titles: Default::default(),
dbus: Dbus::new(&engine, &run_toplevel),
fdcloser: FdCloser::new(),
});
forker.install(&state);
let config = config::ConfigProxy::default(&state);

3
src/state.rs
View file

@ -28,6 +28,8 @@ use crate::{ErrorFmt, Wheel, XkbContext};
use ahash::AHashMap;
use std::cell::{Cell, RefCell};
use std::rc::Rc;
use std::sync::Arc;
use crate::utils::fdcloser::FdCloser;
pub struct State {
pub xkb_ctx: XkbContext,
@ -61,6 +63,7 @@ pub struct State {
pub pending_float_layout: AsyncQueue<Rc<FloatNode>>,
pub pending_float_titles: AsyncQueue<Rc<FloatNode>>,
pub dbus: Dbus,
pub fdcloser: Arc<FdCloser>,
}
pub struct InputDeviceData {

47
src/utils/fdcloser.rs Normal file
View file

@ -0,0 +1,47 @@
use std::mem;
use std::rc::Rc;
use std::sync::Arc;
use parking_lot::{Condvar, Mutex};
use uapi::OwnedFd;
pub struct FdCloser {
fds: Mutex<Vec<OwnedFd>>,
cv: Condvar,
}
impl FdCloser {
pub fn new() -> Arc<Self> {
let slf = Arc::new(Self {
fds: Mutex::new(Vec::new()),
cv: Condvar::new(),
});
let slf2 = slf.clone();
std::thread::spawn(move || {
let mut fds = vec![];
let mut lock = slf2.fds.lock();
loop {
mem::swap(&mut *lock, &mut fds);
if fds.len() > 0 {
drop(lock);
fds.clear();
lock = slf2.fds.lock();
} else {
slf2.cv.wait(&mut lock);
}
}
});
slf
}
pub fn close(&self, fd: Rc<OwnedFd>) {
match Rc::try_unwrap(fd) {
Ok(fd) => {
self.fds.lock().push(fd);
self.cv.notify_all();
},
Err(_e) => {
log::warn!("Could not close file descriptor in separate thread. There are still references.");
}
}
}
}

1
src/utils/mod.rs
View file

@ -22,3 +22,4 @@ pub mod tri;
pub mod vasprintf;
pub mod vec_ext;
pub mod vecstorage;
pub mod fdcloser;