feat(mirada-compositor): backend DRM — fase 2a, pipeline de render

Sobre el bring-up de la fase 1, drm_backend.rs monta ahora el pipeline
gráfico completo y lo prueba:

- elige la salida conectada (conector + CRTC + modo)
- GBM + EGL + GlesRenderer
- GbmAllocator + GbmFramebufferExporter + DrmCompositor para esa salida
- bucle calloop sincronizado al VBlank (DrmDeviceNotifier): pinta la
  pantalla de colores ~6 s y para (con tope de 10 s anti-cuelgue)

Es un test de hardware: si la pantalla cambia de color, EGL, GBM, el
modeset y el page-flip funcionan. Compila y pasa clippy aquí; se
ejecuta y depura en la máquina con GPU por logs. La fase 2b será el
bucle Wayland completo (clientes + libinput + composición de ventanas).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/apps/mirada-compositor/src/drm_backend.rs

@@ -1,120 +1,238 @@
 //! `drm_backend` — el Cuerpo del compositor sobre **DRM/KMS**, sin
-//! sesión gráfica anfitriona: corre directo sobre una TTY, como tu
+//! sesión gráfica anfitriona: corre directo sobre una TTY.
-//! escritorio de verdad.
 //!
-//! Se construye por fases para poder verificarlo en hardware real
+//! Por fases, para verificarlo en hardware real paso a paso:
-//! paso a paso:
 //!
-//! - **Fase 1 — bring-up** (esto): abre la sesión (`libseat`), encuentra
+//! - **Fase 1 — bring-up**: sesión (`libseat`), GPU, dispositivo DRM,
-//!   la GPU, abre el dispositivo DRM y enumera las salidas físicas. No
+//!   enumerar salidas.
-//!   compone nada todavía; sólo comprueba —y registra en el log— que la
+//! - **Fase 2a — pipeline de render** (esto): GBM, EGL y `GlesRenderer`,
-//!   ruta de hardware funciona en tu máquina.
+//!   con un `DrmCompositor` para la salida conectada y un test que pinta
-//! - **Fase 2** (siguiente): GBM + EGL + `GlesRenderer`, un
+//!   la pantalla de colores unos segundos. Confirma que EGL, GBM, el
-//!   `DrmCompositor` por salida, `libinput` para el teclado, y el bucle
+//!   *modeset* y el *page-flip* funcionan.
-//!   `calloop` que compone de verdad.
+//! - **Fase 2b** (siguiente): el bucle Wayland completo — clientes,
+//!   `libinput`, composición real de ventanas.
 //!
-//! Todo va instrumentado con `println!`/`eprintln!` para que, al
+//! Todo con logs para diagnosticar sin el hardware delante.
-//! correrlo, se pueda copiar la salida y diagnosticar sin tener el
-//! hardware delante.
 
 use std::error::Error;
+use std::time::{Duration, Instant};
 
-use smithay::backend::drm::{DrmDevice, DrmDeviceFd};
+use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::drm::compositor::{DrmCompositor, FrameFlags};
+use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;
+use smithay::backend::drm::{DrmDevice, DrmDeviceFd, DrmEvent};
+use smithay::backend::egl::{EGLContext, EGLDisplay};
+use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::backend::renderer::ImportDma;
 use smithay::backend::session::libseat::LibSeatSession;
 use smithay::backend::session::Session;
 use smithay::backend::udev;
+use smithay::output::OutputModeSource;
+use smithay::reexports::calloop::EventLoop;
 use smithay::reexports::drm::control::connector::State as ConnectorState;
 use smithay::reexports::drm::control::Device as ControlDevice;
 use smithay::reexports::rustix::fs::OFlags;
-use smithay::utils::DeviceFd;
+use smithay::utils::{DeviceFd, Scale, Size, Transform};
 
-/// Arranca el Cuerpo sobre DRM/KMS — **fase 1: bring-up**.
+/// El `DrmCompositor` concreto para una salida (un solo GPU, `()` de
-///
+/// datos de usuario por cuadro).
-/// Abre la sesión, localiza la GPU, abre el dispositivo DRM y enumera
+type Compositor =
-/// las salidas, dejando constancia de todo en el log. La composición
+    DrmCompositor<GbmAllocator<DrmDeviceFd>, GbmFramebufferExporter<DrmDeviceFd>, (), DrmDeviceFd>;
-/// real es la fase 2.
+
+/// El estado del test de la fase 2a: lo comparten los callbacks de `calloop`.
+struct TestState {
+    compositor: Compositor,
+    renderer: GlesRenderer,
+    /// Cuántos cuadros se han pintado.
+    frames: u32,
+    /// Inicio del test, para un tope por tiempo (anti-cuelgue).
+    start: Instant,
+}
+
+impl TestState {
+    /// Pinta un cuadro: limpia la pantalla a un color que va cambiando
+    /// (para que siempre haya daño y el *page-flip* no se salte) y lo
+    /// encola para el siguiente VBlank.
+    fn render(&mut self) {
+        // Un ciclo lento por rojo → verde → azul.
+        let phase = (self.frames / 60) % 3;
+        let t = (self.frames % 60) as f32 / 60.0;
+        let color = match phase {
+            0 => [t, 0.0, 1.0 - t, 1.0],
+            1 => [1.0 - t, t, 0.0, 1.0],
+            _ => [0.0, 1.0 - t, t, 1.0],
+        };
+        let elements: Vec<WaylandSurfaceRenderElement<GlesRenderer>> = Vec::new();
+        match self
+            .compositor
+            .render_frame::<_, _>(&mut self.renderer, &elements, color, FrameFlags::DEFAULT)
+        {
+            Ok(result) => {
+                if !result.is_empty {
+                    if let Err(e) = self.compositor.queue_frame(()) {
+                        eprintln!("      error al encolar el cuadro: {e}");
+                    }
+                }
+                self.frames += 1;
+            }
+            Err(e) => eprintln!("      error pintando el cuadro: {e}"),
+        }
+    }
+}
+
+/// Arranca el Cuerpo sobre DRM/KMS — fases 1 y 2a.
 pub fn run() -> Result<(), Box<dyn Error>> {
-    println!("mirada-compositor · backend DRM — fase 1 (bring-up).");
+    println!("mirada-compositor · backend DRM — fases 1 (bring-up) y 2a (render).");
     println!("──────────────────────────────────────────────────");
 
-    // 1 · La sesión. `libseat` nos da acceso a DRM y a los dispositivos
+    // 1 · Sesión.
-    //     de entrada sin ser root — habla con `seatd` o con `logind`.
+    println!("[1/7] abriendo la sesión (libseat) …");
-    println!("[1/4] abriendo la sesión (libseat) …");
     let (mut session, _notifier) = LibSeatSession::new().map_err(|e| {
         format!(
             "no pude abrir la sesión libseat: {e}\n       \
-             ¿estás en una TTY de verdad (Ctrl+Alt+F3), con `seatd` o \
+             ¿estás en una TTY de verdad (Ctrl+Alt+F3), con `seatd` o `logind`?"
-             `logind` corriendo?"
         )
     })?;
     let seat_name = session.seat();
     println!("      sesión abierta · seat «{seat_name}»");
 
-    // 2 · La GPU primaria del seat.
+    // 2 · GPU primaria.
-    println!("[2/4] buscando la GPU primaria …");
+    println!("[2/7] buscando la GPU primaria …");
     let gpu = udev::primary_gpu(&seat_name)
         .map_err(|e| format!("error consultando udev: {e}"))?
         .ok_or("no encontré ninguna GPU — ¿existe algún /dev/dri/card*?")?;
     println!("      GPU primaria: {}", gpu.display());
 
-    // 3 · Abrir el dispositivo DRM a través de la sesión.
+    // 3 · Dispositivo DRM.
-    println!("[3/4] abriendo el dispositivo DRM …");
+    println!("[3/7] abriendo el dispositivo DRM …");
     let fd = session
         .open(&gpu, OFlags::RDWR | OFlags::CLOEXEC | OFlags::NONBLOCK)
         .map_err(|e| format!("no pude abrir {}: {e}", gpu.display()))?;
     let drm_fd = DrmDeviceFd::new(DeviceFd::from(fd));
-    let (drm, _drm_notifier) =
+    let (mut drm, drm_notifier) =
-        DrmDevice::new(drm_fd, true).map_err(|e| format!("DrmDevice::new falló: {e}"))?;
+        DrmDevice::new(drm_fd.clone(), true).map_err(|e| format!("DrmDevice::new falló: {e}"))?;
     println!("      dispositivo DRM listo.");
 
-    // 4 · Enumerar conectores: cada uno conectado es una salida física.
+    // 4 · Elegir la salida conectada: conector + CRTC + modo.
-    println!("[4/4] enumerando salidas …");
+    println!("[4/7] eligiendo salida (conector + CRTC + modo) …");
     let resources = drm
         .resource_handles()
         .map_err(|e| format!("no pude leer los recursos DRM: {e}"))?;
-    let mut connected = 0usize;
+
-    for &handle in resources.connectors() {
+    let mut chosen = None;
-        let info = match drm.get_connector(handle, false) {
+    for &conn_handle in resources.connectors() {
-            Ok(info) => info,
+        let conn = match drm.get_connector(conn_handle, false) {
-            Err(e) => {
+            Ok(c) => c,
-                eprintln!("      conector {handle:?}: error al leerlo: {e}");
+            Err(_) => continue,
-                continue;
-            }
         };
-        let name = format!("{:?}-{}", info.interface(), info.interface_id());
+        if conn.state() != ConnectorState::Connected {
-        match info.state() {
+            continue;
-            ConnectorState::Connected => {
+        }
-                connected += 1;
+        let name = format!("{:?}-{}", conn.interface(), conn.interface_id());
-                match info.modes().first() {
+        let Some(&mode) = conn.modes().first() else {
-                    Some(mode) => {
+            println!("      «{name}» sin modos — la salto");
-                        let (w, h) = mode.size();
+            continue;
-                        println!(
+        };
-                            "      · «{name}» CONECTADA — modo preferido {w}×{h} \
+        // Un CRTC capaz de gobernar este conector, vía sus encoders.
-                             @ {} Hz  ({} modos)",
+        let crtc = conn
-                            mode.vrefresh(),
+            .encoders()
-                            info.modes().len(),
+            .iter()
-                        );
+            .filter_map(|enc| drm.get_encoder(*enc).ok())
-                    }
+            .find_map(|enc| resources.filter_crtcs(enc.possible_crtcs()).into_iter().next());
-                    None => println!("      · «{name}» CONECTADA — sin modos anunciados"),
+        match crtc {
-                }
+            Some(crtc) => {
+                let (w, h) = mode.size();
+                println!("      salida «{name}» · {w}×{h} · CRTC {crtc:?}");
+                chosen = Some((conn_handle, crtc, mode, name));
+                break;
             }
-            ConnectorState::Disconnected => println!("      · «{name}» desconectada"),
+            None => println!("      «{name}» sin CRTC libre — la salto"),
-            other => println!("      · «{name}» — estado {other:?}"),
         }
     }
-    println!("      {connected} salida(s) conectada(s).");
+    let (conn_handle, crtc, mode, out_name) =
+        chosen.ok_or("ninguna salida conectada con CRTC disponible")?;
+
+    // 5 · GBM + EGL + GlesRenderer.
+    println!("[5/7] inicializando GBM + EGL + GlesRenderer …");
+    let gbm = GbmDevice::new(drm_fd.clone()).map_err(|e| format!("GbmDevice::new falló: {e}"))?;
+    let egl_display =
+        unsafe { EGLDisplay::new(gbm.clone()) }.map_err(|e| format!("EGLDisplay::new falló: {e}"))?;
+    let egl_context =
+        EGLContext::new(&egl_display).map_err(|e| format!("EGLContext::new falló: {e}"))?;
+    let renderer =
+        unsafe { GlesRenderer::new(egl_context) }.map_err(|e| format!("GlesRenderer falló: {e}"))?;
+    println!("      renderer GLES listo.");
+
+    // 6 · La superficie DRM y el DrmCompositor de esta salida.
+    println!("[6/7] creando la superficie DRM y el compositor …");
+    let surface = drm
+        .create_surface(crtc, mode, &[conn_handle])
+        .map_err(|e| format!("create_surface falló: {e}"))?;
+    let allocator = GbmAllocator::new(gbm.clone(), GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT);
+    let exporter = GbmFramebufferExporter::new(gbm.clone(), None);
+    let renderer_formats = renderer.dmabuf_formats();
+    let (mw, mh) = mode.size();
+    let mode_source = OutputModeSource::Static {
+        size: Size::from((mw as i32, mh as i32)),
+        scale: Scale::from(1.0),
+        transform: Transform::Normal,
+    };
+    let compositor: Compositor = DrmCompositor::new(
+        mode_source,
+        surface,
+        None,
+        allocator,
+        exporter,
+        [Fourcc::Argb8888, Fourcc::Xrgb8888],
+        renderer_formats,
+        drm.cursor_size(),
+        Some(gbm.clone()),
+    )
+    .map_err(|e| format!("DrmCompositor::new falló: {e}"))?;
+    println!("      compositor de «{out_name}» listo.");
+
+    // 7 · Bucle de prueba: pinta colores ~6 s, sincronizado al VBlank.
+    println!("[7/7] test de pintado — la pantalla debería cambiar de color …");
+    let mut event_loop: EventLoop<TestState> =
+        EventLoop::try_new().map_err(|e| format!("calloop falló: {e}"))?;
+    event_loop
+        .handle()
+        .insert_source(drm_notifier, |event, _meta, state| match event {
+            DrmEvent::VBlank(_crtc) => {
+                if let Err(e) = state.compositor.frame_submitted() {
+                    eprintln!("      frame_submitted error: {e}");
+                }
+                state.render();
+            }
+            DrmEvent::Error(e) => eprintln!("      DRM error: {e}"),
+        })
+        .map_err(|e| format!("no pude registrar el DRM en calloop: {e}"))?;
+
+    let mut state = TestState {
+        compositor,
+        renderer,
+        frames: 0,
+        start: Instant::now(),
+    };
+    // Primer cuadro: arranca la cadena render → VBlank → render.
+    state.render();
+
+    let signal = event_loop.get_signal();
+    event_loop
+        .run(Some(Duration::from_millis(16)), &mut state, |state| {
+            // Tope: ~6 s de cuadros, o 10 s de reloj (anti-cuelgue si no
+            // llegaran los VBlank).
+            if state.frames >= 360 || state.start.elapsed() > Duration::from_secs(10) {
+                signal.stop();
+            }
+        })
+        .map_err(|e| format!("el bucle de eventos falló: {e}"))?;
 
     println!("──────────────────────────────────────────────────");
-    if connected == 0 {
+    println!("mirada-compositor · fase 2a completada — {} cuadros pintados.", state.frames);
-        eprintln!("mirada-compositor · bring-up OK, pero no hay ninguna salida");
+    println!("   Si viste la pantalla cambiar de color, EGL/GBM/modeset/page-flip");
-        eprintln!("   conectada — sin pantalla no hay nada que componer.");
+    println!("   funcionan. Copia estos logs y seguimos con la fase 2b (clientes).");
-    } else {
-        println!("mirada-compositor · bring-up DRM completado correctamente.");
-    }
-    println!(
-        "   La composición sobre DRM es la fase 2. Copia estos logs y\n   \
-         seguimos. Mientras, el backend winit ya funciona dentro de un\n   \
-         escritorio:  mirada-compositor --winit"
-    );
     Ok(())
 }