Implement #1

Author: suchmememanyskill

Cargo.lock

@@ -18,6 +18,7 @@ image = { version = "0", default-features = false, features = ["png"] }
 [target.'cfg(unix)'.dependencies]
 evdev = "0"
 linuxfb = "0"
+memmap = "0"
 
 [build-dependencies]
 slint-build = "1.12.1"

Cargo.toml

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 pub struct DisplayFramebufferConfig {
     pub fb_path: String,
     pub event_path: Option<String>,
+    pub buffering: Option<String>,
 }
 
 impl DisplayInit for DisplayFramebufferConfig {
@@ -23,13 +24,20 @@ impl DisplayInit for DisplayFramebufferConfig {
             }
         };
 
+        let double_buffering = match self.buffering.clone().unwrap_or(String::from("double")).to_lowercase().as_str()
+        {
+            "double" => true,
+            "single" => false,
+            _ => panic!("Config value {:?} is unsupported for buffering. Supported is \"Single\" or \"Double\"", self.buffering)
+        };
+
         let mut touch_device = None;
 
         if let Some(event_path) = &self.event_path {
             touch_device = Some(Device::open(event_path)?);
         }
 
-        slint::platform::set_platform(Box::new(FramebufferPlatform::new(fb, touch_device)))
+        slint::platform::set_platform(Box::new(FramebufferPlatform::new(fb, touch_device, double_buffering)))
             .expect("set platform");
 
         let ui = AppWindow::new()?;

src/config/display_fb.rs

@@ -2,6 +2,7 @@
 
 use evdev::Device;
 use linuxfb::{double::Buffer, Framebuffer};
+use memmap::MmapMut;
 use slint::{
     platform::{
         software_renderer::{
@@ -14,21 +15,78 @@ use slint::{
 };
 use std::{
     cell::RefCell,
-    collections::VecDeque,
     rc::Rc,
-    sync::{Arc, Mutex},
     time::{Duration, Instant},
 };
 
 use crate::hardware::EvdevMtTouchPlatform;
 
+trait FramebufferHandler
+{
+    fn as_mut_slice(&mut self) -> &mut [u8];
+    fn flip(&mut self) -> Result<(), linuxfb::Error>;
+}
+
+struct SingleBufferFramebuffer
+{
+    fb: Framebuffer,
+    map: MmapMut,
+}
+
+impl SingleBufferFramebuffer
+{
+    fn new(fb : Framebuffer) -> Result<SingleBufferFramebuffer, linuxfb::Error>
+    {
+        let map = fb.map()?;
+        Ok(SingleBufferFramebuffer { fb: fb, map: map })
+    }
+}
+
+impl FramebufferHandler for SingleBufferFramebuffer
+{
+    fn as_mut_slice(&mut self) -> &mut [u8]
+    {
+        &mut self.map[..]
+    }
+
+    fn flip(&mut self) -> Result<(), linuxfb::Error> {
+        // Do nothing
+        Ok(())
+    }
+}
+
+struct DoubleBufferFramebuffer
+{
+    buffer: Buffer,
+}
+
+impl DoubleBufferFramebuffer
+{
+    fn new(fb : Framebuffer) -> Result<DoubleBufferFramebuffer, linuxfb::Error>
+    {
+        let buffer = Buffer::new(fb)?;
+        Ok(DoubleBufferFramebuffer { buffer: buffer })
+    }
+}
+
+impl FramebufferHandler for DoubleBufferFramebuffer
+{
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.buffer.as_mut_slice()
+    }
+
+    fn flip(&mut self) -> Result<(), linuxfb::Error> {
+        self.buffer.flip()
+    }
+}
+
 pub trait TouchPlatform {
     fn process_touch_events(&self) -> Vec<WindowEvent>;
 }
 
 pub struct FramebufferPlatform {
     window: Rc<MinimalSoftwareWindow>,
-    fb: RefCell<Buffer>,
+    fb: RefCell<Box<dyn FramebufferHandler>>,
     width: usize,
     height: usize,
     stride: usize,
@@ -38,7 +96,7 @@ pub struct FramebufferPlatform {
 }
 
 impl FramebufferPlatform {
-    pub fn new(fb: Framebuffer, touch_device: Option<Device>) -> Self {
+    pub fn new(fb: Framebuffer, touch_device: Option<Device>, double_buffering: bool) -> Self {
         let size = fb.get_size();
         let bytes_per_pixel = fb.get_bytes_per_pixel();
         let physical_size = fb.get_physical_size();
@@ -60,12 +118,19 @@ impl FramebufferPlatform {
             println!("No input device configured");
         }
 
-        let window = MinimalSoftwareWindow::new(RepaintBufferType::SwappedBuffers);
+        let window = MinimalSoftwareWindow::new(if double_buffering { RepaintBufferType::SwappedBuffers } else { RepaintBufferType::ReusedBuffer });
         window.set_size(PhysicalSize::new(size.0, size.1));
 
+        let framebuffer_handler: Box<dyn FramebufferHandler> = match double_buffering
+        {
+            true => Box::new(DoubleBufferFramebuffer::new(fb).expect("Failed to initialise double buffer")),
+            false => Box::new(SingleBufferFramebuffer::new(fb).expect("Failed to initialise single buffer"))
+        };
+
+
         Self {
             window,
-            fb: RefCell::new(Buffer::new(fb).unwrap()),
+            fb: RefCell::new(framebuffer_handler),
             width: size.0 as usize,
             height: size.1 as usize,
             stride: size.0 as usize,
@@ -158,7 +223,7 @@ impl Platform for FramebufferPlatform {
             }
 
             self.window.draw_if_needed(|renderer| {
-                let frame: &mut [u8] = fb.as_mut_slice();
+                let frame = fb.as_mut_slice();
                 if self.bytes_per_pixel == 2 {
                     let (_, pixels, _) = unsafe { frame.align_to_mut::<Rgb565Pixel>() };
                     renderer.render(pixels, self.stride);