monolith

//! Bare metal. A libseat session, udev for the primary GPU and its

//! connectors, libinput for input, and one smithay DRM output per connector,

//! each rendered when its own vblank lands.

use crate::scene::Draw;

use crate::state::{State, now_ns};

use monolith_config::Vrr;

use monolith_layout::{OutputId, Rect};

use smithay::backend::allocator::Fourcc;

use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};

use smithay::backend::drm::VrrSupport;

use smithay::backend::drm::compositor::FrameFlags;

use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;

use smithay::backend::drm::output::{DrmOutput, DrmOutputManager, DrmOutputRenderElements};

use smithay::backend::drm::{

    DrmDevice, DrmDeviceFd, DrmEvent, DrmEventMetadata, DrmEventTime, DrmNode, NodeType,

};

use smithay::backend::input::{

    AbsolutePositionEvent, Axis, AxisSource, Event, InputEvent, KeyboardKeyEvent, PointerAxisEvent,

    PointerButtonEvent, PointerMotionEvent,

};

use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface};

use smithay::backend::session::libseat::LibSeatSession;

use smithay::backend::session::{Event as SessionEvent, Session};

use smithay::backend::udev::{UdevBackend, UdevEvent, all_gpus, primary_gpu};

use smithay::input::pointer::AxisFrame;

use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};

use smithay::reexports::calloop::timer::{TimeoutAction, Timer};

use smithay::reexports::calloop::{EventLoop, LoopHandle, RegistrationToken};

use smithay::reexports::drm::Device as _;

use smithay::reexports::drm::control::{ModeTypeFlags, connector, crtc};

use smithay::reexports::input::Libinput;

use smithay::reexports::rustix::fs::OFlags;

use smithay::utils::{DeviceFd, Point, Transform};

use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};

use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};

use std::collections::{HashMap, VecDeque};

use std::path::{Path, PathBuf};

use std::time::Duration;

const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];

/// Frames that only move the cursor stay at or below 60 Hz under VRR, so the

/// mouse does not override the refresh rate a game is pacing.

const CURSOR_FRAME_NS: u64 = 16_666_667;

type Allocator = GbmAllocator<DrmDeviceFd>;

type Exporter = GbmFramebufferExporter<DrmDeviceFd>;

type Manager = DrmOutputManager<Allocator, Exporter, (), DrmDeviceFd>;

type Out = DrmOutput<Allocator, Exporter, (), DrmDeviceFd>;

pub struct Drm {

    pub session: LibSeatSession,

    libinput: Libinput,

    handle: LoopHandle<'static, State>,

    node: DrmNode,

    manager: Manager,

    scanner: DrmScanner,

    nvidia: bool,

    frame_flags: FrameFlags,

    surfaces: HashMap<crtc::Handle, Surface>,

}

struct Surface {

    output: Output,

    id: OutputId,

    drm: Out,

    /// A frame is on its way to the screen and its vblank has not landed.

    queued: bool,

    redraw: bool,

    last_vblank_ns: Option<u64>,

    refresh_ns: u64,

    /// The pending render, timed to start just in time for `target_ns`.

    scheduled: Option<RegistrationToken>,

    /// The vblank the frame being drawn or queued is meant for.

    target_ns: Option<u64>,

    budget: Budget,

    /// Frames presented since `stats_since`, for the once-a-second debug line.

    presented: u32,

    stats_since: u64,

    vrr_capable: bool,

    vrr_on: bool,

    /// Only the cursor moved, which under VRR is drawn at a capped rate.

    cursor_redraw: bool,

}

impl Surface {

    /// The first vblank a render starting at `now` can still make, and the

    /// latest moment to start it.

    fn next_deadline(&self, now: u64) -> Option<(u64, u64)> {

        let last = self.last_vblank_ns?;

        let refresh = self.refresh_ns;

        if refresh == 0 {

            return None;

        }

        let budget = self.budget.ns().min(refresh);

        let periods = (now + budget).saturating_sub(last).div_ceil(refresh).max(1);

        let vblank = last + periods * refresh;

        Some((vblank, vblank - budget))

    }

}

/// How long before a vblank rendering must start. A high percentile of

/// recent CPU render times covers the CPU side without one spike inflating

/// it, and a slack that grows on every missed vblank and shrinks over seconds

/// while frames land covers GPU time and the commit.

struct Budget {

    renders: VecDeque<u64>,

    slack_ns: u64,

    /// The slack that last proved enough after a miss. Decay stops there

    /// for `floor_frames` frames, so it does not keep rediscovering the same

    /// limit one dropped frame at a time.

    floor_ns: u64,

    floor_frames: u64,

}

impl Budget {

    const KEEP: usize = 32;

    const MIN_SLACK_NS: u64 = 1_000_000;

    const STEP_NS: u64 = 500_000;

    const DECAY_NS: u64 = 1_000;

    const FLOOR_NS: u64 = 30_000_000_000;

    fn new() -> Self {

        Self {

            renders: VecDeque::with_capacity(Self::KEEP),

            slack_ns: 2_000_000,

            floor_ns: 0,

            floor_frames: 0,

        }

    }

    fn ns(&self) -> u64 {

        let mut renders: Vec<u64> = self.renders.iter().copied().collect();

        renders.sort_unstable();

        let p90 = renders

            .get(renders.len().saturating_sub(1) * 9 / 10)

            .copied()

            .unwrap_or(0);

        p90 + self.slack_ns

    }

    fn record(&mut self, render_ns: u64) {

        if self.renders.len() == Self::KEEP {

            self.renders.pop_front();

        }

        self.renders.push_back(render_ns);

    }

    fn missed(&mut self, refresh_ns: u64) {

        self.slack_ns = (self.slack_ns + Self::STEP_NS).min(refresh_ns / 2);

        self.floor_ns = self.slack_ns;

        self.floor_frames = Self::FLOOR_NS / refresh_ns.max(1);

    }

    fn landed(&mut self) {

        self.floor_frames = self.floor_frames.saturating_sub(1);

        let floor = if self.floor_frames > 0 {

            self.floor_ns

        } else {

            Self::MIN_SLACK_NS

        };

        self.slack_ns = self.slack_ns.saturating_sub(Self::DECAY_NS).max(floor);

    }

}

/// The GPU monolith drives on bare metal, the seat's primary or else its

/// first.

pub fn primary() -> Result<PathBuf, Box<dyn std::error::Error>> {

    let seat = std::env::var("XDG_SEAT").unwrap_or_else(|_| "seat0".into());

    Ok(match primary_gpu(&seat)? {

        Some(p) => p,

        None => all_gpus(&seat)?.into_iter().next().ok_or("no GPU found")?,

    })

}

pub fn init(

    event_loop: &mut EventLoop<'static, State>,

    state: &mut State,

    path: &Path,

) -> Result<(), Box<dyn std::error::Error>> {

    let (mut session, notifier) = LibSeatSession::new()?;

    let seat = session.seat();

    let node = DrmNode::from_path(path)?;

    tracing::info!(path = %path.display(), "primary GPU");

    let fd = session.open(

        path,

        OFlags::RDWR | OFlags::CLOEXEC | OFlags::NOCTTY | OFlags::NONBLOCK,

    )?;

    let fd = DrmDeviceFd::new(DeviceFd::from(fd));

    let (device, drm_events) = DrmDevice::new(fd.clone(), true)?;

    let nvidia = device

        .get_driver()

        .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))

        .unwrap_or(false);

    if supports_syncobj_eventfd(&fd) {

        state.syncobj = Some(DrmSyncobjState::new::<State>(&state.display, fd.clone()));

    } else {

        tracing::info!("no syncobj eventfd support, clients stay on implicit sync");

    }

    let gbm = GbmDevice::new(fd)?;

    let render_node = node

        .node_with_type(NodeType::Render)

        .and_then(Result::ok)

        .unwrap_or(node);

    let allocator = GbmAllocator::new(

        gbm.clone(),

        GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,

    );

    let exporter = GbmFramebufferExporter::new(gbm.clone(), render_node.into());

    let render_formats: Vec<_> = state.renderer.render_formats().iter().copied().collect();

    let manager = DrmOutputManager::new(

        device,

        allocator,

        exporter,

        Some(gbm),

        [Fourcc::Xrgb8888, Fourcc::Argb8888],

        render_formats,

    );

    let mut libinput =

        Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());

    libinput

        .udev_assign_seat(&seat)

        .map_err(|()| "libinput could not take the seat")?;

    let handle = event_loop.handle();

    handle.insert_source(

        LibinputInputBackend::new(libinput.clone()),

        |event, _, state| {

            on_input(state, event);

        },

    )?;

    handle.insert_source(notifier, |event, _, state| match event {

        SessionEvent::PauseSession => {

            if let Some(drm) = state.drm.as_mut() {

                drm.libinput.suspend();

                drm.manager.pause();

            }

        }

        SessionEvent::ActivateSession => {

            if let Some(drm) = state.drm.as_mut() {

                if drm.libinput.resume().is_err() {

                    tracing::warn!("libinput did not resume");

                }

                if let Err(e) = drm.manager.lock().activate(false) {

                    tracing::warn!("could not reactivate the GPU: {e}");

                }

                for s in drm.surfaces.values_mut() {

                    s.queued = false;

                    s.redraw = true;

                }

            }

            state.needs_redraw = true;

        }

    })?;

    handle.insert_source(drm_events, |event, meta, state| match event {

        DrmEvent::VBlank(crtc) => on_vblank(state, crtc, meta),

        DrmEvent::Error(e) => tracing::warn!("drm: {e}"),

    })?;

    let udev = UdevBackend::new(&seat)?;

    handle.insert_source(udev, move |event, _, state| {

        if let UdevEvent::Changed { device_id } = event

            && state

                .drm

                .as_ref()

                .is_some_and(|d| d.node.dev_id() == device_id)

        {

            scan(state);

        }

    })?;

    state.drm = Some(Drm {

        session,

        libinput,

        handle,

        node,

        manager,

        scanner: DrmScanner::new(),

        nvidia,

        frame_flags: if std::env::var_os("MONOLITH_NO_SCANOUT").is_some() {

            FrameFlags::empty()

        } else {

            FrameFlags::DEFAULT

        },

        surfaces: HashMap::new(),

    });

    scan(state);

    Ok(())

}

/// Brings outputs in line with what is plugged in.

fn scan(state: &mut State) {

    let Some(drm) = state.drm.as_mut() else {

        return;

    };

    let events: Vec<DrmScanEvent> = match drm.scanner.scan_connectors(drm.manager.device()) {

        Ok(result) => result.into_iter().collect(),

        Err(e) => {

            tracing::warn!("scanning connectors failed: {e}");

            return;

        }

    };

    for event in events {

        match event {

            DrmScanEvent::Connected {

                connector,

                crtc: Some(crtc),

            } => connect(state, connector, crtc),

            DrmScanEvent::Disconnected {

                crtc: Some(crtc), ..

            } => disconnect(state, crtc),

            _ => {}

        }

    }

    state.apply_layout();

}

fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {

    let name = format!(

        "{}-{}",

        connector.interface().as_str(),

        connector.interface_id()

    );

    let Some(&mode) = connector

        .modes()

        .iter()

        .find(|m| m.mode_type().contains(ModeTypeFlags::PREFERRED))

        .or_else(|| connector.modes().first())

    else {

        tracing::warn!(name, "connector has no modes");

        return;

    };

    let State {

        drm: Some(drm),

        renderer,

        layout,

        space,

        display,

        ..

    } = state

    else {

        return;

    };

    let (mm_w, mm_h) = connector.size().unwrap_or((0, 0));

    let output = Output::new(

        name.clone(),

        PhysicalProperties {

            size: (mm_w as i32, mm_h as i32).into(),

            subpixel: Subpixel::Unknown,

            make: "Unknown".into(),

            model: name.clone(),

            serial_number: String::new(),

        },

    );

    let wl_mode = Mode::from(mode);

    let x = layout

        .outputs()

        .map(|(_, o)| o.area.right())

        .fold(0.0, f64::max);

    let position = Point::from((x as i32, 0));

    output.change_current_state(

        Some(wl_mode),

        Some(Transform::Normal),

        Some(Scale::Integer(1)),

        Some(position),

    );

    output.set_preferred(wl_mode);

    output.create_global::<State>(display);

    let mut planes = drm.manager.device().planes(&crtc).ok();

    if drm.nvidia

        && let Some(p) = planes.as_mut()

    {

        // NVIDIA's overlay planes break composition, as anvil also found.

        p.overlay.clear();

    }

    let out = match drm.manager.lock().initialize_output::<_, Draw>(

        crtc,

        mode,

        &[connector.handle()],

        &output,

        planes,

        renderer,

        &DrmOutputRenderElements::default(),

    ) {

        Ok(out) => out,

        Err(e) => {

            tracing::warn!(name, "could not light up the output: {e}");

            return;

        }

    };

    let vrr_capable = matches!(

        out.with_compositor(|c| c.vrr_supported(connector.handle())),

        Ok(VrrSupport::Supported)

    );

    space.map_output(&output, position);

    let (w, h) = mode.size();

    let area = Rect::new(x, 0.0, f64::from(w), f64::from(h));

    let id = layout.add_output(&name, area);

    tracing::info!(

        name,

        w,

        h,

        refresh = mode.vrefresh(),

        vrr_capable,

        "output connected"

    );

    drm.surfaces.insert(

        crtc,

        Surface {

            output,

            id,

            drm: out,

            queued: false,

            redraw: true,

            last_vblank_ns: None,

            scheduled: None,

            target_ns: None,

            budget: Budget::new(),

            presented: 0,

            stats_since: 0,

            vrr_capable,

            vrr_on: false,

            cursor_redraw: false,

            refresh_ns: 1_000_000_000_000 / u64::from(wl_mode.refresh.max(1) as u32),

        },

    );

}

fn disconnect(state: &mut State, crtc: crtc::Handle) {

    let Some(drm) = state.drm.as_mut() else {

        return;

    };

    let Some(surface) = drm.surfaces.remove(&crtc) else {

        return;

    };

    if let Some(token) = surface.scheduled {

        drm.handle.remove(token);

    }

    tracing::info!(name = surface.output.name(), "output disconnected");

    state.space.unmap_output(&surface.output);

    state.layout.remove_output(surface.id);

}

/// The smithay output for a layout output, for protocols that need one.

pub fn output_for(drm: &Drm, id: OutputId) -> Option<Output> {

    drm.surfaces

        .values()

        .find(|s| s.id == id)

        .map(|s| s.output.clone())

}

fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMetadata>) {

    let Some(surface) = state.drm.as_mut().and_then(|d| d.surfaces.get_mut(&crtc)) else {

        return;

    };

    if let Err(e) = surface.drm.frame_submitted() {

        tracing::warn!("frame was not submitted: {e}");

    }

    surface.queued = false;

    if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {

        let t = t.as_nanos() as u64;

        if let Some(target) = surface.target_ns.take() {

            if t > target + surface.refresh_ns / 2 {

                surface.budget.missed(surface.refresh_ns);

                tracing::debug!(

                    output = surface.output.name(),

                    late_ns = t - target,

                    budget_ns = surface.budget.ns(),

                    "frame missed its vblank"

                );

            } else {

                surface.budget.landed();

            }

        }

        surface.last_vblank_ns = Some(t);

        surface.presented += 1;

        let window = t.saturating_sub(surface.stats_since);

        if window >= 1_000_000_000 {

            let vblanks = window / surface.refresh_ns.max(1);