Merge remote-tracking branch 'remotes/jonas/pixel-shifting'

Author: WhatAmISupposedToPutHere

Cargo.lock

@@ -22,3 +22,4 @@ nix = { version = "0.27", features = ["poll"] }
 privdrop = "0.5.3"
 serde = { version = "1", features = ["derive"] }
 toml = "0.8"
+rand = "0.8"

Cargo.toml

@@ -9,3 +9,8 @@ MediaLayerDefault = false
 # Set this to false if you want to hide the button outline,
 # leaving only the text/logo
 ShowButtonOutlines = true
+
+# Set this to true to slowly shift the entire screen contents.
+# In theory this helps with screen longevity, but macos does not bother doint it
+# Disabling ShowButtonOutlines will make this effect less noticeable to the eye
+EnablePixelShift = false

share/tiny-dfr/config.toml

@@ -10,6 +10,11 @@ use input::event::{
 };
 use crate::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;
+
 fn read_attr(path: &Path, attr: &str) -> u32 {
     fs::read_to_string(path.join(attr))
         .expect(&format!("Failed to read {attr}"))
@@ -74,10 +79,10 @@ impl BacklightManager {
         let since_last_active = (Instant::now() - self.last_active).as_millis() as u64;
         let new_bl = if self.lid_state == SwitchState::On {
             0
-        } else if since_last_active < TIMEOUT_MS as u64 {
-            128
-        } else if since_last_active < TIMEOUT_MS as u64 * 2 {
-            1
+        } else if since_last_active < BRIGHTNESS_DIM_TIMEOUT as u64 {
+            DEFAULT_BRIGHTNESS
+        } else if since_last_active < BRIGHTNESS_OFF_TIMEOUT as u64 {
+            DIMMED_BRIGHTNESS
         } else {
             0
         };

src/backlight.rs

@@ -6,6 +6,7 @@ use std::{
     },
     path::Path,
     collections::HashMap,
+    cmp::min
 };
 use std::os::fd::AsFd;
 use cairo::{
@@ -32,26 +33,31 @@ use serde::Deserialize;
 
 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.200;
 const BUTTON_COLOR_ACTIVE: f64 = 0.400;
-const TIMEOUT_MS: i32 = 30 * 1000;
+const TIMEOUT_MS: i32 = 10 * 1000;
 
 #[derive(Deserialize)]
 #[serde(rename_all = "PascalCase")]
 struct ConfigProxy {
     media_layer_default: Option<bool>,
-    show_button_outlines: Option<bool>
+    show_button_outlines: Option<bool>,
+    enable_pixel_shift: Option<bool>
 }
 
 struct Config {
     media_layer_default: bool,
-    show_button_outlines: bool
+    show_button_outlines: bool,
+    enable_pixel_shift: bool
 }
 
 enum ButtonImage {
@@ -76,12 +82,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();
@@ -90,9 +96,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();
             }
         }
@@ -104,21 +111,23 @@ struct FunctionLayer {
 }
 
 impl FunctionLayer {
-    fn draw(&self, config: &Config, surface: &Surface, active_buttons: &[bool]) {
+    fn draw(&self, config: &Config, 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 if config.show_button_outlines {
@@ -163,7 +172,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);
         }
     }
 }
@@ -222,17 +231,20 @@ fn load_config() -> Config {
     if let Ok(user) = user {
         base.media_layer_default = user.media_layer_default.or(base.media_layer_default);
         base.show_button_outlines = user.show_button_outlines.or(base.show_button_outlines);
+        base.enable_pixel_shift = user.enable_pixel_shift.or(base.enable_pixel_shift);
     };
     Config {
         media_layer_default: base.media_layer_default.unwrap(),
-        show_button_outlines: base.show_button_outlines.unwrap()
+        show_button_outlines: base.show_button_outlines.unwrap(),
+        enable_pixel_shift: base.enable_pixel_shift.unwrap(),
     }
 }
 
 fn main() {
     let mut uinput = UInputHandle::new(OpenOptions::new().write(true).open("/dev/uinput").unwrap());
     let mut backlight = BacklightManager::new();
     let config = load_config();
+    let mut pixel_shift = PixelShiftManager::new();
 
     // drop privileges to input and video group
     let groups = ["input", "video"];
@@ -315,14 +327,31 @@ fn main() {
     let mut digitizer: Option<InputDevice> = None;
     let mut touches = HashMap::new();
     loop {
+        let mut next_timeout_ms = TIMEOUT_MS;
+
+        if config.enable_pixel_shift {
+            let (pixel_shift_needs_redraw, pixel_shift_next_timeout_ms) = pixel_shift.update();
+            if pixel_shift_needs_redraw {
+                needs_redraw = true;
+            }
+            next_timeout_ms = min(next_timeout_ms, pixel_shift_next_timeout_ms);
+        }
+
+
         if needs_redraw {
             needs_redraw = false;
-            layers[active_layer].draw(&config, &surface, &button_states[active_layer]);
+            let shift = if config.enable_pixel_shift {
+                pixel_shift.get()
+            } else {
+                (0.0, 0.0)
+            };
+            layers[active_layer].draw(&config, &surface, &button_states[active_layer], shift);
             let data = surface.data().unwrap();
             drm.map().unwrap().as_mut()[..data.len()].copy_from_slice(&data);
             drm.dirty(&[ClipRect::new(0, 0, DFR_HEIGHT as u16, 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,103 @@
+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 * 1; // 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
+
+#[derive(Clone, Copy)]
+enum ShiftState {
+    WaitingAtEnd,
+    ShiftingSubpixel,
+    Normal
+}
+
+pub struct PixelShiftManager {
+    last_active: Instant,
+    y_constant: f64,
+    pixel_progress: u64,
+    subpixel_progress: f64,
+    direction: i64,
+    state: ShiftState
+}
+
+fn wait_for_state(state: ShiftState) -> i32 {
+    match state {
+        ShiftState::ShiftingSubpixel => ANIMATION_INTERVAL_MS,
+        ShiftState::Normal => INTERVAL_MS,
+        ShiftState::WaitingAtEnd => PROLONGED_INTERVAL_MS,
+    }
+}
+
+impl PixelShiftManager {
+    pub fn new() -> PixelShiftManager {
+        let pixel_progress = rand::thread_rng().gen_range(0..PIXEL_SHIFT_WIDTH_PX);
+
+        // 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(),
+            y_constant,
+            state: ShiftState::Normal,
+            pixel_progress,
+            subpixel_progress: 0.0,
+            direction: 1,
+        }
+    }
+
+    pub fn update(&mut self) -> (bool, i32) {
+        let time_now = Instant::now();
+        let since_last_pixel_shift = (time_now - self.last_active).as_millis() as i32;
+
+        if since_last_pixel_shift < wait_for_state(self.state) {
+            return (false, i32::MAX);
+        }
+        self.last_active = time_now;
+
+        match self.state {
+            ShiftState::Normal => {
+                self.state = ShiftState::ShiftingSubpixel;
+                self.subpixel_progress = self.direction as f64;
+            },
+            ShiftState::ShiftingSubpixel => {
+                let shift_by = ANIMATION_INTERVAL_MS as f64 / ANIMATION_DURATION_MS as f64;
+                self.subpixel_progress += shift_by * self.direction as f64;
+                if self.subpixel_progress <= 0.01 || self.subpixel_progress >= 0.99 {
+                    self.pixel_progress = (self.direction + self.pixel_progress as i64) as u64;
+                    self.state = ShiftState::Normal;
+                    self.subpixel_progress = 0.0;
+                }
+                if self.pixel_progress == 0 || self.pixel_progress >= PIXEL_SHIFT_WIDTH_PX {
+                    self.state = ShiftState::WaitingAtEnd;
+                    self.direction = -self.direction;
+                }
+            },
+            ShiftState::WaitingAtEnd => {
+                self.state = ShiftState::Normal;
+            }
+        }
+        (true, wait_for_state(self.state))
+    }
+
+    pub fn get(&self) -> (f64, f64) {
+        let x_progress = self.pixel_progress as f64 + self.subpixel_progress;
+        let y_progress = (x_progress + self.y_constant) % PIXEL_SHIFT_HEIGHT_PX as f64;
+        (x_progress - (PIXEL_SHIFT_WIDTH_PX / 2) as f64, y_progress - (PIXEL_SHIFT_HEIGHT_PX / 2) as f64)
+    }
+}