autocommit 2022-03-11 18:15:21 CET

src/backends/metal/video.rs

@@ -0,0 +1,615 @@
+use crate::backend::{BackendEvent, Output, OutputId};
+use crate::drm::drm::{
+    ConnectorStatus, ConnectorType, DrmBlob, DrmConnector, DrmCrtc, DrmEncoder, DrmError, DrmFb,
+    DrmFramebuffer, DrmMaster, DrmModeInfo, DrmObject, DrmPlane, DrmProperty,
+    DrmPropertyDefinition, DrmPropertyType, PropBlob, DRM_CLIENT_CAP_ATOMIC,
+    DRM_MODE_ATOMIC_ALLOW_MODESET,
+};
+use crate::drm::gbm::{GbmDevice, GBM_BO_USE_RENDERING, GBM_BO_USE_SCANOUT};
+use crate::drm::{ModifiedFormat, INVALID_MODIFIER};
+use crate::format::{Format, XRGB8888};
+use crate::metal::{DrmId, MetalBackend, MetalError};
+use crate::render::{Framebuffer, RenderContext};
+use crate::utils::bitflags::BitflagsExt;
+use crate::{CloneCell, ErrorFmt, State};
+use ahash::AHashMap;
+use bstr::{BString, ByteSlice};
+use std::cell::Cell;
+use std::ffi::CString;
+use std::fmt::{Debug, Formatter};
+use std::rc::Rc;
+use uapi::c;
+
+pub struct PendingDrmDevice {
+    pub id: DrmId,
+    pub devnum: c::dev_t,
+    pub devnode: CString,
+}
+
+#[derive(Debug)]
+pub struct MetalDrmDeviceStatic {
+    pub id: DrmId,
+    pub devnum: c::dev_t,
+    pub devnode: CString,
+    pub master: Rc<DrmMaster>,
+    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+    pub encoders: AHashMap<DrmEncoder, Rc<MetalEncoder>>,
+    pub planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
+    pub min_width: u32,
+    pub max_width: u32,
+    pub min_height: u32,
+    pub max_height: u32,
+    pub gbm: GbmDevice,
+    pub egl: Rc<RenderContext>,
+}
+
+#[derive(Debug)]
+pub struct MetalDrmDevice {
+    pub dev: Rc<MetalDrmDeviceStatic>,
+    pub connectors: AHashMap<DrmConnector, Rc<MetalConnector>>,
+}
+
+#[derive(Debug)]
+pub struct MetalConnector {
+    pub id: DrmConnector,
+    pub master: Rc<DrmMaster>,
+
+    pub output_id: OutputId,
+
+    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+    pub modes: Vec<DrmModeInfo>,
+    pub mode: CloneCell<Option<Rc<DrmModeInfo>>>,
+
+    pub connector_type: ConnectorType,
+    pub connector_type_id: u32,
+
+    pub connection: ConnectorStatus,
+    pub mm_width: u32,
+    pub mm_height: u32,
+    pub subpixel: u32,
+
+    pub crtc_id: MutableProperty<DrmCrtc>,
+
+    pub egl_fb: CloneCell<Option<Rc<Framebuffer>>>,
+
+    pub on_change: OnChange,
+}
+
+#[derive(Default)]
+pub struct OnChange {
+    pub on_change: CloneCell<Option<Rc<dyn Fn()>>>,
+}
+
+impl Debug for OnChange {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self.on_change.get() {
+            None => f.write_str("None"),
+            Some(_) => f.write_str("Some"),
+        }
+    }
+}
+
+impl Output for MetalConnector {
+    fn id(&self) -> OutputId {
+        self.output_id
+    }
+
+    fn removed(&self) -> bool {
+        false
+    }
+
+    fn width(&self) -> i32 {
+        match self.mode.get() {
+            Some(m) => m.hdisplay as _,
+            _ => 0,
+        }
+    }
+
+    fn height(&self) -> i32 {
+        match self.mode.get() {
+            Some(m) => m.vdisplay as _,
+            _ => 0,
+        }
+    }
+
+    fn on_change(&self, cb: Rc<dyn Fn()>) {
+        self.on_change.on_change.set(Some(cb));
+    }
+}
+
+#[derive(Debug)]
+pub struct MetalCrtc {
+    pub id: DrmCrtc,
+    pub idx: usize,
+    pub master: Rc<DrmMaster>,
+
+    pub possible_planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
+
+    pub connector: Cell<DrmConnector>,
+
+    pub primary_plane: Cell<DrmPlane>,
+    pub cursor_plane: Cell<DrmPlane>,
+
+    pub active: MutableProperty<bool>,
+    pub mode_id: MutableProperty<DrmBlob>,
+
+    pub mode_blob: CloneCell<Option<Rc<PropBlob>>>,
+}
+
+#[derive(Debug)]
+pub struct MetalEncoder {
+    pub id: DrmEncoder,
+    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum PlaneType {
+    Overlay,
+    Primary,
+    Cursor,
+}
+
+#[derive(Debug)]
+pub struct MetalPlane {
+    pub id: DrmPlane,
+    pub master: Rc<DrmMaster>,
+
+    pub ty: PlaneType,
+
+    pub possible_crtcs: u32,
+    pub formats: AHashMap<u32, &'static Format>,
+
+    pub fb: CloneCell<Option<Rc<DrmFramebuffer>>>,
+
+    pub fb_id: MutableProperty<DrmFb>,
+    pub crtc_id: MutableProperty<DrmCrtc>,
+    pub crtc_x: MutableProperty<i32>,
+    pub crtc_y: MutableProperty<i32>,
+    pub crtc_w: MutableProperty<i32>,
+    pub crtc_h: MutableProperty<i32>,
+    pub src_x: MutableProperty<u32>,
+    pub src_y: MutableProperty<u32>,
+    pub src_w: MutableProperty<u32>,
+    pub src_h: MutableProperty<u32>,
+}
+
+impl MetalDrmDevice {}
+
+fn get_connectors(
+    state: &State,
+    dev: &MetalDrmDeviceStatic,
+    ids: &[DrmConnector],
+) -> Result<AHashMap<DrmConnector, Rc<MetalConnector>>, DrmError> {
+    let mut connectors = AHashMap::new();
+    for connector in ids {
+        match create_connector(state, *connector, dev) {
+            Ok(e) => {
+                connectors.insert(e.id, Rc::new(e));
+            }
+            Err(e) => return Err(DrmError::CreateConnector(Box::new(e))),
+        }
+    }
+    Ok(connectors)
+}
+
+fn create_connector(
+    state: &State,
+    connector: DrmConnector,
+    dev: &MetalDrmDeviceStatic,
+) -> Result<MetalConnector, DrmError> {
+    let info = dev.master.get_connector_info(connector, true)?;
+    let mut crtcs = AHashMap::new();
+    for encoder in info.encoders {
+        if let Some(encoder) = dev.encoders.get(&encoder) {
+            for (_, crtc) in &encoder.crtcs {
+                crtcs.insert(crtc.id, crtc.clone());
+            }
+        }
+    }
+    let props = collect_properties(&dev.master, connector)?;
+    Ok(MetalConnector {
+        id: connector,
+        master: dev.master.clone(),
+        output_id: state.output_ids.next(),
+        crtcs,
+        modes: info.modes,
+        mode: Default::default(),
+        connector_type: info.connector_type.into(),
+        connector_type_id: info.connector_type_id,
+        connection: info.connection.into(),
+        mm_width: info.mm_width,
+        mm_height: info.mm_height,
+        subpixel: info.subpixel,
+        crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
+        egl_fb: Default::default(),
+        on_change: Default::default(),
+    })
+}
+
+fn create_encoder(
+    encoder: DrmEncoder,
+    master: &Rc<DrmMaster>,
+    crtcs: &AHashMap<DrmCrtc, Rc<MetalCrtc>>,
+) -> Result<MetalEncoder, DrmError> {
+    let info = master.get_encoder_info(encoder)?;
+    let mut possible = AHashMap::new();
+    for crtc in crtcs.values() {
+        if info.possible_crtcs.contains(1 << crtc.idx) {
+            possible.insert(crtc.id, crtc.clone());
+        }
+    }
+    Ok(MetalEncoder {
+        id: encoder,
+        crtcs: possible,
+    })
+}
+
+fn create_crtc(
+    crtc: DrmCrtc,
+    idx: usize,
+    master: &Rc<DrmMaster>,
+    planes: &AHashMap<DrmPlane, Rc<MetalPlane>>,
+) -> Result<MetalCrtc, DrmError> {
+    let mask = 1 << idx;
+    let mut possible_planes = AHashMap::new();
+    for plane in planes.values() {
+        if plane.possible_crtcs.contains(mask) {
+            possible_planes.insert(plane.id, plane.clone());
+        }
+    }
+    let props = collect_properties(master, crtc)?;
+    Ok(MetalCrtc {
+        id: crtc,
+        idx,
+        master: master.clone(),
+        possible_planes,
+        connector: Cell::new(DrmConnector::NONE),
+        primary_plane: Cell::new(DrmPlane::NONE),
+        cursor_plane: Cell::new(DrmPlane::NONE),
+        active: props.get("ACTIVE")?.map(|v| v == 1),
+        mode_id: props.get("MODE_ID")?.map(|v| DrmBlob(v as u32)),
+        mode_blob: Default::default(),
+    })
+}
+
+fn create_plane(plane: DrmPlane, master: &Rc<DrmMaster>) -> Result<MetalPlane, DrmError> {
+    let info = master.get_plane_info(plane)?;
+    let mut formats = AHashMap::new();
+    for format in info.format_types {
+        if let Some(f) = crate::format::formats().get(&format) {
+            formats.insert(format, *f);
+        } else {
+            // log::warn!(
+            //     "{:?} supports unknown format '{:?}'",
+            //     plane,
+            //     crate::format::debug(format)
+            // );
+        }
+    }
+    let props = collect_properties(master, plane)?;
+    let ty = match props.props.get(b"type".as_bstr()) {
+        Some((def, val)) => match &def.ty {
+            DrmPropertyType::Enum { values, .. } => 'ty: {
+                for v in values {
+                    if v.value == *val {
+                        match v.name.as_bytes() {
+                            b"Overlay" => break 'ty PlaneType::Overlay,
+                            b"Primary" => break 'ty PlaneType::Primary,
+                            b"Cursor" => break 'ty PlaneType::Cursor,
+                            _ => return Err(DrmError::UnknownPlaneType(v.name.to_owned())),
+                        }
+                    }
+                }
+                return Err(DrmError::InvalidPlaneType(*val));
+            }
+            _ => return Err(DrmError::InvalidPlaneTypeProperty),
+        },
+        _ => {
+            return Err(DrmError::MissingProperty(
+                "type".to_string().into_boxed_str(),
+            ))
+        }
+    };
+    Ok(MetalPlane {
+        id: plane,
+        master: master.clone(),
+        ty,
+        possible_crtcs: info.possible_crtcs,
+        formats,
+        fb: Default::default(),
+        fb_id: props.get("FB_ID")?.map(|v| DrmFb(v as _)),
+        crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
+        crtc_x: props.get("CRTC_X")?.map(|v| v as i32),
+        crtc_y: props.get("CRTC_Y")?.map(|v| v as i32),
+        crtc_w: props.get("CRTC_W")?.map(|v| v as i32),
+        crtc_h: props.get("CRTC_H")?.map(|v| v as i32),
+        src_x: props.get("SRC_X")?.map(|v| v as u32),
+        src_y: props.get("SRC_Y")?.map(|v| v as u32),
+        src_w: props.get("SRC_W")?.map(|v| v as u32),
+        src_h: props.get("SRC_H")?.map(|v| v as u32),
+    })
+}
+
+fn collect_properties<T: DrmObject>(
+    master: &Rc<DrmMaster>,
+    t: T,
+) -> Result<CollectedProperties, DrmError> {
+    let mut props = AHashMap::new();
+    for prop in master.get_properties(t)? {
+        let def = master.get_property(prop.id)?;
+        props.insert(def.name.clone(), (def, prop.value));
+    }
+    Ok(CollectedProperties { props })
+}
+
+struct CollectedProperties {
+    props: AHashMap<BString, (DrmPropertyDefinition, u64)>,
+}
+
+impl CollectedProperties {
+    fn get(&self, name: &str) -> Result<MutableProperty<u64>, DrmError> {
+        match self.props.get(name.as_bytes().as_bstr()) {
+            Some((def, value)) => Ok(MutableProperty {
+                id: def.id,
+                value: Cell::new(*value),
+            }),
+            _ => Err(DrmError::MissingProperty(name.to_string().into_boxed_str())),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MutableProperty<T: Copy> {
+    pub id: DrmProperty,
+    pub value: Cell<T>,
+}
+
+impl<T: Copy> MutableProperty<T> {
+    fn map<U: Copy, F>(self, f: F) -> MutableProperty<U>
+    where
+        F: FnOnce(T) -> U,
+    {
+        MutableProperty {
+            id: self.id,
+            value: Cell::new(f(self.value.into_inner())),
+        }
+    }
+}
+
+impl MetalBackend {
+    pub fn creat_drm_device(
+        &self,
+        pending: PendingDrmDevice,
+        master: &Rc<DrmMaster>,
+    ) -> Result<MetalDrmDevice, MetalError> {
+        if let Err(e) = master.set_client_cap(DRM_CLIENT_CAP_ATOMIC, 2) {
+            return Err(MetalError::AtomicModesetting(e));
+        }
+        let resources = master.get_resources()?;
+
+        let mut planes = AHashMap::new();
+        for plane in master.get_planes()? {
+            match create_plane(plane, master) {
+                Ok(p) => {
+                    planes.insert(p.id, Rc::new(p));
+                }
+                Err(e) => return Err(MetalError::CreatePlane(e)),
+            }
+        }
+
+        let mut crtcs = AHashMap::new();
+        for (idx, crtc) in resources.crtcs.iter().copied().enumerate() {
+            match create_crtc(crtc, idx, master, &planes) {
+                Ok(c) => {
+                    crtcs.insert(c.id, Rc::new(c));
+                }
+                Err(e) => return Err(MetalError::CreateCrtc(e)),
+            }
+        }
+
+        let mut encoders = AHashMap::new();
+        for encoder in resources.encoders {
+            match create_encoder(encoder, master, &crtcs) {
+                Ok(e) => {
+                    encoders.insert(e.id, Rc::new(e));
+                }
+                Err(e) => return Err(MetalError::CreateEncoder(e)),
+            }
+        }
+
+        let gbm = match GbmDevice::new(master) {
+            Ok(g) => g,
+            Err(e) => return Err(MetalError::GbmDevice(e)),
+        };
+        let egl = match RenderContext::from_drm_device(master) {
+            Ok(r) => Rc::new(r),
+            Err(e) => return Err(MetalError::CreateRenderContex(e)),
+        };
+
+        let dev = MetalDrmDeviceStatic {
+            id: pending.id,
+            devnum: pending.devnum,
+            devnode: pending.devnode,
+            master: master.clone(),
+            crtcs,
+            encoders,
+            planes,
+            min_width: resources.min_width,
+            max_width: resources.max_width,
+            min_height: resources.min_height,
+            max_height: resources.max_height,
+            gbm,
+            egl,
+        };
+
+        let connectors = get_connectors(&self.state, &dev, &resources.connectors)?;
+
+        let slf = MetalDrmDevice {
+            dev: Rc::new(dev),
+            connectors,
+        };
+
+        self.reset_drm_device(&slf)?;
+
+        Ok(slf)
+    }
+
+    pub fn refresh_drm_device(&self, dev: MetalDrmDevice) -> Result<MetalDrmDevice, DrmError> {
+        let resources = dev.dev.master.get_resources()?;
+        let connectors = get_connectors(&self.state, &dev.dev, &resources.connectors)?;
+        Ok(MetalDrmDevice {
+            dev: dev.dev.clone(),
+            connectors,
+        })
+    }
+
+    fn reset_drm_device(&self, dev: &MetalDrmDevice) -> Result<(), DrmError> {
+        let mut changes = dev.dev.master.change(DRM_MODE_ATOMIC_ALLOW_MODESET);
+        for connector in dev.connectors.values() {
+            if connector.crtc_id.value.take().is_some() {
+                changes.change_object(connector.id, |c| {
+                    c.change(connector.crtc_id.id, 0);
+                })
+            }
+        }
+        for plane in dev.dev.planes.values() {
+            changes.change_object(plane.id, |c| {
+                if plane.crtc_id.value.take().is_some() {
+                    c.change(plane.crtc_id.id, 0);
+                }
+                if plane.fb_id.value.take().is_some() {
+                    c.change(plane.fb_id.id, 0);
+                }
+            })
+        }
+        for crtc in dev.dev.crtcs.values() {
+            changes.change_object(crtc.id, |c| {
+                if crtc.active.value.take() {
+                    c.change(crtc.active.id, 0);
+                }
+                if crtc.mode_id.value.take().is_some() {
+                    c.change(crtc.mode_id.id, 0);
+                }
+            })
+        }
+        if let Err(e) = changes.commit(0) {
+            return Err(DrmError::ResetFailed(Box::new(e)));
+        }
+        Ok(())
+    }
+
+    pub fn init_drm_device(&self, dev: &Rc<MetalDrmDevice>) {
+        for connector in dev.connectors.values() {
+            if let Err(e) = self.init_drm_connector(dev, connector) {
+                log::error!("Could not initialize drm connector: {}", ErrorFmt(e));
+            }
+        }
+    }
+
+    fn init_drm_connector(
+        &self,
+        dev: &Rc<MetalDrmDevice>,
+        connector: &Rc<MetalConnector>,
+    ) -> Result<(), MetalError> {
+        if connector.connection != ConnectorStatus::Connected {
+            return Ok(());
+        }
+        let crtc = 'crtc: {
+            for crtc in connector.crtcs.values() {
+                if crtc.connector.get().is_none() {
+                    break 'crtc crtc.clone();
+                }
+            }
+            return Err(MetalError::NoCrtcForConnector);
+        };
+        let primary_plane = '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)
+                {
+                    break 'plane plane.clone();
+                }
+            }
+            return Err(MetalError::NoPrimaryPlaneForConnector);
+        };
+        let mode = match connector.modes.first() {
+            Some(m) => m,
+            _ => return Err(MetalError::NoModeForConnector),
+        };
+        let mode_blob = mode.create_blob(&connector.master)?;
+        let format = ModifiedFormat {
+            format: XRGB8888,
+            modifier: INVALID_MODIFIER,
+        };
+        let bo = dev.dev.gbm.create_bo(
+            mode.hdisplay as i32,
+            mode.vdisplay as i32,
+            &format,
+            GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT,
+        );
+        let bo = match bo {
+            Ok(b) => b,
+            Err(e) => return Err(MetalError::ScanoutBuffer(e)),
+        };
+        let drm_fb = match connector.master.add_fb(&bo) {
+            Ok(fb) => Rc::new(fb),
+            Err(e) => return Err(MetalError::Framebuffer(e)),
+        };
+        let egl_fb = match dev.dev.egl.dmabuf_fb(&bo.dma()) {
+            Ok(fb) => fb,
+            Err(e) => return Err(MetalError::ImportFb(e)),
+        };
+        let mut changes = connector.master.change(DRM_MODE_ATOMIC_ALLOW_MODESET);
+        changes.change_object(connector.id, |c| {
+            c.change(connector.crtc_id.id, crtc.id.0 as _);
+        });
+        changes.change_object(crtc.id, |c| {
+            c.change(crtc.active.id, 1);
+            c.change(crtc.mode_id.id, mode_blob.id().0 as _);
+        });
+        changes.change_object(primary_plane.id, |c| {
+            c.change(primary_plane.fb_id.id, drm_fb.id().0 as _);
+            c.change(primary_plane.crtc_id.id, crtc.id.0 as _);
+            c.change(primary_plane.crtc_x.id, 0);
+            c.change(primary_plane.crtc_y.id, 0);
+            c.change(primary_plane.crtc_w.id, mode.hdisplay as _);
+            c.change(primary_plane.crtc_h.id, mode.vdisplay as _);
+            c.change(primary_plane.src_x.id, 0);
+            c.change(primary_plane.src_y.id, 0);
+            c.change(primary_plane.src_w.id, (mode.hdisplay as u64) << 16);
+            c.change(primary_plane.src_h.id, (mode.vdisplay as u64) << 16);
+        });
+        if let Err(e) = changes.commit(0) {
+            return Err(MetalError::Configure(e));
+        }
+        connector.crtc_id.value.set(crtc.id);
+        connector.egl_fb.set(Some(egl_fb));
+        connector.mode.set(Some(Rc::new(mode.clone())));
+        crtc.connector.set(connector.id);
+        crtc.active.value.set(true);
+        crtc.mode_id.value.set(mode_blob.id());
+        crtc.mode_blob.set(Some(Rc::new(mode_blob)));
+        primary_plane.fb_id.value.set(drm_fb.id());
+        primary_plane.fb.set(Some(drm_fb));
+        primary_plane.crtc_id.value.set(crtc.id);
+        primary_plane.crtc_x.value.set(0);
+        primary_plane.crtc_y.value.set(0);
+        primary_plane.crtc_w.value.set(mode.hdisplay as _);
+        primary_plane.crtc_h.value.set(mode.vdisplay as _);
+        primary_plane.src_x.value.set(0);
+        primary_plane.src_y.value.set(0);
+        primary_plane.src_w.value.set((mode.hdisplay as u32) << 16);
+        primary_plane.src_h.value.set((mode.vdisplay as u32) << 16);
+        self.state
+            .backend_events
+            .push(BackendEvent::NewOutput(connector.clone()));
+        log::info!(
+            "Initialized connector {}-{} with mode {:?}",
+            connector.connector_type,
+            connector.connector_type_id,
+            mode
+        );
+        Ok(())
+    }
+}