Introduce automatic pixel shifting

The panel in the touchbar is an OLED screen and pixels on it will suffer
degradation over time. Degradation effects are going to be worst on bright,
white pixels that remain at the same position forever. This applies to the
icons of our buttons.

To lower the possibilty of a burn-in here as much as we can, introduce some
subtle pixel shifting.

Here's how it works:

- Use the existing TIMEOUT_MS poll() timeout and (temporarily) allow smaller
  timeouts for smooth sub-pixel transitions to make the pixel shift completely
  invisible

- We have lots of space in the horizontal direction, so there we shift pixels
  by the whole amount that's necessary to ensure no pixel remains "always on"

- The background boxes around each button are also shifted in horizontal
  direction as otherwise the icons appear off-center horizontally, for this
  the boxes need to be reduced in width a bit so they don't overflow the panel

- In the vertical direction, icons appear off-center on the whole touchbar
  really quickly, so only do very limited movement here, that's not very
  effective but better than nothing

- Hitboxes for touch input remain the same and are not affected by pixel
  shifting

This starts a pixel shift by one full pixel in x and y direction every 10
seconds, transitioning slowly between the states on a sub-pixel level for
4 seconds. Once the pixel shift reaches the final left or right edge of
the shifting area, we'll leave it at that for 50 seconds to reduce stress
on pixels in the center of the shifting area a bit more.

Author: jonas2515

Cargo.lock

@@ -20,3 +20,4 @@ input-linux = "0.6"
 input-linux-sys = "0.8"
 nix = "0.26"
 privdrop = "0.5.3"
+rand = "0.8.5"

Cargo.toml

@@ -10,8 +10,8 @@ use input::event::{
 };
 use crate::TIMEOUT_MS;
 
-const BRIGHTNESS_DIM_TIMEOUT: i32 = TIMEOUT_MS * 1; // should be a multiple of TIMEOUT_MS
-const BRIGHTNESS_OFF_TIMEOUT: i32 = TIMEOUT_MS * 2; // should be a multiple of TIMEOUT_MS
+const BRIGHTNESS_DIM_TIMEOUT: i32 = TIMEOUT_MS * 3; // should be a multiple of TIMEOUT_MS
+const BRIGHTNESS_OFF_TIMEOUT: i32 = TIMEOUT_MS * 6; // should be a multiple of TIMEOUT_MS
 const DEFAULT_BRIGHTNESS: u32 = 128;
 const DIMMED_BRIGHTNESS: u32 = 1;
 

src/backlight.rs

@@ -30,15 +30,18 @@ use privdrop::PrivDrop;
 
 mod backlight;
 mod display;
+mod pixel_shift;
 
 use backlight::BacklightManager;
 use display::DrmBackend;
+use pixel_shift::PixelShiftManager;
+use pixel_shift::PIXEL_SHIFT_WIDTH_PX;
 
 const DFR_WIDTH: i32 = 2008;
 const DFR_HEIGHT: i32 = 64;
 const BUTTON_COLOR_INACTIVE: f64 = 0.0;
 const BUTTON_COLOR_ACTIVE: f64 = 0.400;
-const TIMEOUT_MS: i32 = 30 * 1000;
+const TIMEOUT_MS: i32 = 10 * 1000;
 
 enum ButtonImage {
     Text(&'static str),
@@ -62,12 +65,12 @@ impl Button {
             action, image: ButtonImage::Svg(svg)
         }
     }
-    fn render(&self, c: &Context, left_edge: f64, button_width: f64) {
+    fn render(&self, c: &Context, button_left_edge: f64, button_width: f64, y_shift: f64) {
         match &self.image {
             ButtonImage::Text(text) => {
                 let extents = c.text_extents(text).unwrap();
                 c.move_to(
-                    left_edge + button_width / 2.0 - extents.width() / 2.0,
+                    button_left_edge + button_width / 2.0 - extents.width() / 2.0,
                     DFR_HEIGHT as f64 / 2.0 + extents.height() / 2.0
                 );
                 c.show_text(text).unwrap();
@@ -76,9 +79,10 @@ impl Button {
                 let renderer = CairoRenderer::new(&svg);
                 let y = 0.12 * DFR_HEIGHT as f64;
                 let size = DFR_HEIGHT as f64 - y * 2.0;
-                let x = left_edge + button_width / 2.0 - size / 2.0;
+                let x = button_left_edge + button_width / 2.0 - size / 2.0;
+
                 renderer.render_document(c,
-                    &Rectangle::new(x, y, size, size)
+                    &Rectangle::new(x, y + y_shift, size, size)
                 ).unwrap();
             }
         }
@@ -90,21 +94,23 @@ struct FunctionLayer {
 }
 
 impl FunctionLayer {
-    fn draw(&self, surface: &Surface, active_buttons: &[bool]) {
+    fn draw(&self, surface: &Surface, active_buttons: &[bool], pixel_shift: (f64, f64)) {
         let c = Context::new(&surface).unwrap();
         c.translate(DFR_HEIGHT as f64, 0.0);
         c.rotate((90.0f64).to_radians());
-        let button_width = DFR_WIDTH as f64 / (self.buttons.len() + 1) as f64;
-        let spacing_width = (DFR_WIDTH as f64 - self.buttons.len() as f64 * button_width) / (self.buttons.len() - 1) as f64;
+        let button_width = (DFR_WIDTH as u64 - PIXEL_SHIFT_WIDTH_PX) as f64 / (self.buttons.len() + 1) as f64;
+        let spacing_width = ((DFR_WIDTH as u64 - PIXEL_SHIFT_WIDTH_PX) as f64 - self.buttons.len() as f64 * button_width) / (self.buttons.len() - 1) as f64;
         let radius = 8.0f64;
         let bot = (DFR_HEIGHT as f64) * 0.2;
         let top = (DFR_HEIGHT as f64) * 0.85;
+        let (pixel_shift_x, pixel_shift_y) = pixel_shift;
+
         c.set_source_rgb(0.0, 0.0, 0.0);
         c.paint().unwrap();
         c.select_font_face("sans-serif", FontSlant::Normal, FontWeight::Bold);
         c.set_font_size(32.0);
         for (i, button) in self.buttons.iter().enumerate() {
-            let left_edge = i as f64 * (button_width + spacing_width);
+            let left_edge = i as f64 * (button_width + spacing_width) + pixel_shift_x + (PIXEL_SHIFT_WIDTH_PX / 2) as f64;
             let color = if active_buttons[i] { BUTTON_COLOR_ACTIVE } else { BUTTON_COLOR_INACTIVE };
             c.set_source_rgb(color, color, color);
             // draw box with rounded corners
@@ -143,7 +149,7 @@ impl FunctionLayer {
 
             c.fill().unwrap();
             c.set_source_rgb(1.0, 1.0, 1.0);
-            button.render(&c, left_edge, button_width);
+            button.render(&c, left_edge, button_width, pixel_shift_y);
         }
     }
 }
@@ -198,6 +204,7 @@ fn toggle_key<F>(uinput: &mut UInputHandle<F>, code: Key, value: i32) where F: A
 fn main() {
     let mut uinput = UInputHandle::new(OpenOptions::new().write(true).open("/dev/uinput").unwrap());
     let mut backlight = BacklightManager::new();
+    let mut pixel_shift = PixelShiftManager::new();
 
     // drop privileges to input and video group
     let groups = ["input", "video"];
@@ -280,14 +287,23 @@ fn main() {
     let mut digitizer: Option<InputDevice> = None;
     let mut touches = HashMap::new();
     loop {
+        let mut next_timeout_ms = TIMEOUT_MS;
+
+        let (pixel_shift_needs_redraw, pixel_shift_next_timeout_ms) = pixel_shift.update_pixel_shift();
+        if pixel_shift_needs_redraw {
+            needs_redraw = true; }
+        if pixel_shift_next_timeout_ms != -1 {
+            next_timeout_ms = pixel_shift_next_timeout_ms; }
+
         if needs_redraw {
             needs_redraw = false;
-            layers[active_layer].draw(&surface, &button_states[active_layer]);
+            layers[active_layer].draw(&surface, &button_states[active_layer], pixel_shift.get_pixel_shift());
             let data = surface.data().unwrap();
             drm.map().unwrap().as_mut()[..data.len()].copy_from_slice(&data);
             drm.dirty(&[ClipRect{x1: 0, y1: 0, x2: DFR_HEIGHT as u16, y2: DFR_WIDTH as u16}]).unwrap();
         }
-        poll(&mut [pollfd_tb, pollfd_main], TIMEOUT_MS).unwrap();
+
+        poll(&mut [pollfd_tb, pollfd_main], next_timeout_ms).unwrap();
         input_tb.dispatch().unwrap();
         input_main.dispatch().unwrap();
         for event in &mut input_tb.clone().chain(input_main.clone()) {

src/main.rs

@@ -0,0 +1,117 @@
+use rand::Rng;
+use std::{
+    time::Instant,
+};
+use crate::TIMEOUT_MS;
+
+const INTERVAL_MS: i32 = TIMEOUT_MS * 1; // should be a multiple of TIMEOUT_MS
+const PROLONGED_INTERVAL_MS: i32 = TIMEOUT_MS * 5; // should be a multiple of TIMEOUT_MS and more than INTERVAL_MS
+const ANIMATION_INTERVAL_MS: i32 = 200; // should be less than TIMEOUT_MS
+const ANIMATION_DURATION_MS: i32 = 4000; // should be a multiple of ANIMATION_INTERVAL_MS
+
+// This is the total range on the x-axis that pixels will shift by over time, ie. they will shift by
+// PIXEL_SHIFT_WIDTH_PX / 2 to the right and to the left.
+// To make sure that no pixel ends up being always on, the minimum value to be safe here is the
+// size of the largest continuous colored line in the x-direction. The higher this value, the less
+// strain is put on the panel.
+pub const PIXEL_SHIFT_WIDTH_PX: u64 = 22; // should be divisible by 2
+// in y direction we can't really shift by a lot since icons still need to appear centered,
+// 2 pixels in each direction seems to be the maximum before it gets really visible.
+const PIXEL_SHIFT_HEIGHT_PX: u64 = 4; // should be divisible by 2
+
+fn get_pixel_shift(x_progress: f64, y_constant: f64) -> (f64, f64) {
+    let half_width = (PIXEL_SHIFT_WIDTH_PX / 2) as f64;
+    let half_height = (PIXEL_SHIFT_HEIGHT_PX / 2) as f64;
+    let mut shift_x = x_progress % (PIXEL_SHIFT_WIDTH_PX * 2) as f64;
+    if shift_x <= half_width {
+        shift_x = shift_x;
+    } else if shift_x <= half_width * 2.0 {
+        shift_x = half_width - (shift_x - half_width);
+    } else if shift_x <= half_width * 3.0 {
+        shift_x = 0.0 - (shift_x - half_width * 2.0);
+    } else if shift_x <= half_width * 4.0 {
+        shift_x = -half_width + (shift_x - half_width * 3.0);
+    }
+
+    let mut shift_y = (shift_x.abs() + y_constant) % (PIXEL_SHIFT_HEIGHT_PX * 2) as f64;
+    if shift_y <= half_height {
+        shift_y = shift_y;
+    } else if shift_y <= half_height * 2.0 {
+        shift_y = half_height - (shift_y - half_height);
+    } else if shift_y <= half_height * 3.0 {
+        shift_y = 0.0 - (shift_y - half_height * 2.0);
+    } else if shift_y <= half_height * 4.0 {
+        shift_y = -half_height + (shift_y - half_height * 3.0);
+    }
+
+    (shift_x, shift_y)
+}
+
+pub struct PixelShiftManager {
+    last_active: Instant,
+    x_progress: f64,
+    y_constant: f64,
+    in_animation: bool,
+    in_prolonged_timeout: bool,
+}
+
+impl PixelShiftManager {
+    pub fn new() -> PixelShiftManager {
+        let x_progress: f64 = rand::thread_rng().gen_range(0..PIXEL_SHIFT_WIDTH_PX * 2) as f64;
+
+        // add some randomness to the relationship between shifting on the x and y axis
+        // so that pixel shifting doesn't follow the same 2d pattern every time
+        let y_constant: f64 = rand::thread_rng().gen_range(0..PIXEL_SHIFT_HEIGHT_PX * 2) as f64;
+
+        PixelShiftManager {
+            last_active: Instant::now(),
+            x_progress,
+            y_constant,
+            in_animation: false,
+            in_prolonged_timeout: false
+        }
+    }
+
+    pub fn update_pixel_shift(&mut self) -> (bool, i32) {
+        let mut pixels_changed = false;
+        let mut next_timeout_ms = -1;
+        let time_now = Instant::now();
+        let since_last_pixel_shift = (time_now - self.last_active).as_millis() as i32;
+
+        if (self.in_animation && since_last_pixel_shift >= ANIMATION_INTERVAL_MS) ||
+           (self.in_prolonged_timeout && since_last_pixel_shift >= PROLONGED_INTERVAL_MS) ||
+           (!self.in_animation && !self.in_prolonged_timeout && since_last_pixel_shift >= INTERVAL_MS) {
+            if ANIMATION_INTERVAL_MS == 0 || ANIMATION_DURATION_MS == 0 {
+                self.x_progress += 1.0;
+            } else {
+                self.x_progress += ANIMATION_INTERVAL_MS as f64 / ANIMATION_DURATION_MS as f64;
+            }
+            self.last_active = time_now;
+            pixels_changed = true;
+
+            if (self.x_progress % 1.0).abs() <= 0.01 || (self.x_progress % 1.0).abs() >= 0.99 {
+                self.x_progress = self.x_progress.round();
+                self.in_animation = false;
+                self.in_prolonged_timeout = false;
+                //println!("finished pixel shift, now {:?}", get_pixel_shift(self.x_progress, self.y_constant));
+
+                if self.x_progress as u64 % (PIXEL_SHIFT_WIDTH_PX * 2) == 0 {
+                    self.x_progress = 0.0;
+                } else if self.x_progress as u64 % (PIXEL_SHIFT_WIDTH_PX) == 0 {
+                } else if self.x_progress as u64 % (PIXEL_SHIFT_WIDTH_PX / 2) == 0 {
+                    self.in_prolonged_timeout = true;
+                    //println!("pixel shift reached left or right edge, prolonging timeout");
+                }
+            } else {
+                next_timeout_ms = ANIMATION_INTERVAL_MS;
+                self.in_animation = true;
+            }
+        }
+
+        (pixels_changed, next_timeout_ms)
+    }
+
+    pub fn get_pixel_shift(&self) -> (f64, f64) {
+        get_pixel_shift(self.x_progress, self.y_constant)
+    }
+}