Directly pass FrameBuffer to redraw and sync

This avoids creating an intermediate &'static mut [u32] of questionable
soundness and simplifies the code a bit.

graphics/vesad/src/scheme.rs

@@ -27,7 +27,6 @@ pub struct Handle {
 
 pub struct DisplayScheme {
     framebuffers: Vec<FrameBuffer>,
-    onscreens: Vec<&'static mut [u32]>,
     active: VtIndex,
     pub vts: BTreeMap<VtIndex, BTreeMap<ScreenIndex, GraphicScreen>>,
     next_id: usize,
@@ -36,14 +35,9 @@ pub struct DisplayScheme {
 }
 
 impl DisplayScheme {
-    pub fn new(mut framebuffers: Vec<FrameBuffer>, spec: &[()]) -> DisplayScheme {
+    pub fn new(framebuffers: Vec<FrameBuffer>, spec: &[()]) -> DisplayScheme {
         let mut inputd_handle = inputd::Handle::new("vesa").unwrap();
 
-        let mut onscreens = Vec::new();
-        for fb in framebuffers.iter_mut() {
-            onscreens.push(unsafe { &mut *fb.onscreen });
-        }
-
         let mut vts = BTreeMap::<VtIndex, BTreeMap<ScreenIndex, GraphicScreen>>::new();
 
         for &() in spec.iter() {
@@ -57,7 +51,6 @@ impl DisplayScheme {
 
         DisplayScheme {
             framebuffers,
-            onscreens,
             active: VtIndex(1),
             vts,
             next_id: 0,
@@ -96,7 +89,6 @@ impl DisplayScheme {
 
         unsafe {
             self.framebuffers[fb_i].resize(width, height, stride);
-            self.onscreens[fb_i] = &mut *self.framebuffers[fb_i].onscreen;
         }
 
         // Resize screens
@@ -105,7 +97,7 @@ impl DisplayScheme {
                 if screen_i.0 == fb_i {
                     screen.resize(width, height);
                     if *vt_i == self.active {
-                        screen.redraw(self.onscreens[fb_i], self.framebuffers[fb_i].stride);
+                        screen.redraw(&mut self.framebuffers[screen_i.0]);
                     }
                 }
             }
@@ -235,10 +227,7 @@ impl SchemeMut for DisplayScheme {
             if let Some(screens) = self.vts.get_mut(&vt_i) {
                 if let Some(screen) = screens.get_mut(&screen_i) {
                     if vt_i == self.active {
-                        screen.sync(
-                            self.onscreens[screen_i.0],
-                            self.framebuffers[screen_i.0].stride,
-                        );
+                        screen.sync(&mut self.framebuffers[screen_i.0]);
                     }
                     return Ok(0);
                 }
@@ -277,10 +266,7 @@ impl SchemeMut for DisplayScheme {
 
                         if let Some(screens) = self.vts.get_mut(&vt_i) {
                             for (screen_i, screen) in screens.iter_mut() {
-                                screen.redraw(
-                                    self.onscreens[screen_i.0],
-                                    self.framebuffers[screen_i.0].stride,
-                                );
+                                screen.redraw(&mut self.framebuffers[screen_i.0]);
                             }
                         }
 
@@ -308,10 +294,7 @@ impl SchemeMut for DisplayScheme {
                     if let Some(screen) = screens.get_mut(&screen_i) {
                         let count = screen.write(buf)?;
                         if vt_i == self.active {
-                            screen.sync(
-                                self.onscreens[screen_i.0],
-                                self.framebuffers[screen_i.0].stride,
-                            );
+                            screen.sync(&mut self.framebuffers[screen_i.0]);
                         }
                         Ok(count)
                     } else {

graphics/vesad/src/screen.rs

@@ -6,6 +6,7 @@ use orbclient::{Event, ResizeEvent};
 use syscall::error::*;
 
 use crate::display::OffscreenBuffer;
+use crate::framebuffer::FrameBuffer;
 
 // Keep synced with orbital
 #[derive(Clone, Copy)]
@@ -130,7 +131,7 @@ impl GraphicScreen {
         Ok(sync_rects.len() * mem::size_of::<SyncRect>())
     }
 
-    pub fn sync(&mut self, onscreen: &mut [u32], stride: usize) {
+    pub fn sync(&mut self, framebuffer: &mut FrameBuffer) {
         for sync_rect in self.sync_rects.drain(..) {
             let x = sync_rect.x.try_into().unwrap_or(0);
             let y = sync_rect.y.try_into().unwrap_or(0);
@@ -144,24 +145,24 @@ impl GraphicScreen {
             let row_pixel_count = cmp::min(self.width, x + w) - start_x;
 
             let mut offscreen_ptr = self.offscreen.as_mut_ptr();
-            let mut onscreen_ptr = onscreen.as_mut_ptr();
+            let mut onscreen_ptr = framebuffer.onscreen as *mut u32; // FIXME use as_mut_ptr once stable
 
             unsafe {
                 offscreen_ptr = offscreen_ptr.add(y * self.width + start_x);
-                onscreen_ptr = onscreen_ptr.add(y * stride + start_x);
+                onscreen_ptr = onscreen_ptr.add(y * framebuffer.stride + start_x);
 
                 let mut rows = end_y - start_y;
                 while rows > 0 {
                     ptr::copy(offscreen_ptr, onscreen_ptr, row_pixel_count);
                     offscreen_ptr = offscreen_ptr.add(self.width);
-                    onscreen_ptr = onscreen_ptr.add(stride);
+                    onscreen_ptr = onscreen_ptr.add(framebuffer.stride);
                     rows -= 1;
                 }
             }
         }
     }
 
-    pub fn redraw(&mut self, onscreen: &mut [u32], stride: usize) {
+    pub fn redraw(&mut self, framebuffer: &mut FrameBuffer) {
         let width = self.width.try_into().unwrap();
         let height = self.height.try_into().unwrap();
         self.sync_rects.push(SyncRect {
@@ -170,6 +171,6 @@ impl GraphicScreen {
             w: width,
             h: height,
         });
-        self.sync(onscreen, stride);
+        self.sync(framebuffer);
     }
 }