Optimizations

Author: lainsce

lib/Models/Bin.vala

@@ -32,6 +32,16 @@ public class He.Bin : Gtk.Widget, Gtk.Buildable {
   private bool _content_color_override = false;
   private RGBColor? _content_source_color = null;
 
+  // Cache for expensive color scheme generation
+  private RGBColor? _cached_source_color = null;
+  private bool _cached_is_dark = false;
+  private double _cached_contrast = -1.0;
+
+  // Static cache shared across all Bin instances for identical color configurations
+  private static Gee.HashMap<string, string>? _css_cache = null;
+  private static ContentScheme? _shared_content_scheme = null;
+  private static StyleManager? _shared_style_manager = null;
+
   private Gtk.Widget? _child;
   public Gtk.Widget child {
     get {
@@ -170,6 +180,7 @@ public class He.Bin : Gtk.Widget, Gtk.Buildable {
     if (!_content_color_override || _content_source_color == null) {
       remove_color_provider ();
       cached_css = null;
+      _cached_source_color = null;
       notify_children_color_changed ();
       return;
     }
@@ -179,16 +190,30 @@ public class He.Bin : Gtk.Widget, Gtk.Buildable {
     bool is_dark = get_is_dark_theme ();
     double contrast = get_contrast_level ();
 
+    // Check if we can skip regeneration - color, theme, and contrast unchanged
+    if (_cached_source_color != null &&
+        colors_are_equal (_cached_source_color, source_argb) &&
+        _cached_is_dark == is_dark &&
+        Math.fabs (_cached_contrast - contrast) < 0.001) {
+      // Nothing changed, skip expensive regeneration
+      return;
+    }
+
     string css = build_content_css (source_argb, is_dark, contrast);
 
     if (css == "") {
       remove_color_provider ();
       cached_css = null;
+      _cached_source_color = null;
       notify_children_color_changed ();
       return;
     }
 
     if (cached_css != null && cached_css == css) {
+      // Update cache state even if CSS matches
+      _cached_source_color = source_argb;
+      _cached_is_dark = is_dark;
+      _cached_contrast = contrast;
       return;
     }
 
@@ -198,10 +223,21 @@ public class He.Bin : Gtk.Widget, Gtk.Buildable {
     apply_color_provider_recursive (this, (!) color_provider);
 
     cached_css = css;
+    _cached_source_color = source_argb;
+    _cached_is_dark = is_dark;
+    _cached_contrast = contrast;
     notify_children_color_changed ();
     queue_draw ();
   }
 
+  private bool colors_are_equal (RGBColor? a, RGBColor b) {
+    if (a == null) return false;
+    // Compare with small epsilon for floating point
+    return Math.fabs (a.r - b.r) < 0.001 &&
+           Math.fabs (a.g - b.g) < 0.001 &&
+           Math.fabs (a.b - b.b) < 0.001;
+  }
+
   private void notify_children_color_changed () {
     notify_widget_tree_color_changed (this);
   }
@@ -288,15 +324,40 @@ public class He.Bin : Gtk.Widget, Gtk.Buildable {
   }
 
   private string build_content_css (RGBColor source_color, bool is_dark, double contrast) {
-    var source_hct = hct_from_int (rgb_to_argb_int (source_color));
+    // Generate cache key from color + theme + contrast
+    int argb = rgb_to_argb_int (source_color);
+    string cache_key = "%d_%s_%.2f".printf (argb, is_dark ? "dark" : "light", contrast);
+
+    // Initialize static cache if needed
+    if (_css_cache == null) {
+      _css_cache = new Gee.HashMap<string, string> ();
+    }
 
-    // Use ContentScheme to generate a full scheme from the source color
-    var content_scheme = new ContentScheme ();
-    var scheme = content_scheme.generate (source_hct, is_dark, contrast);
+    // Check cache first
+    if (_css_cache.has_key (cache_key)) {
+      return _css_cache.get (cache_key);
+    }
+
+    var source_hct = hct_from_int (argb);
+
+    // Reuse shared instances to avoid allocation overhead
+    if (_shared_content_scheme == null) {
+      _shared_content_scheme = new ContentScheme ();
+    }
+    if (_shared_style_manager == null) {
+      _shared_style_manager = new StyleManager ();
+    }
+
+    var scheme = _shared_content_scheme.generate (source_hct, is_dark, contrast);
+    string css = _shared_style_manager.style_refresh (scheme);
+    string result = extract_content_color_definitions (css);
+
+    // Cache the result (limit cache size to prevent memory bloat)
+    if (_css_cache.size < 50) {
+      _css_cache.set (cache_key, result);
+    }
 
-    var manager = new StyleManager ();
-    string css = manager.style_refresh (scheme);
-    return extract_content_color_definitions (css);
+    return result;
   }
 
   private string extract_content_color_definitions (string css) {
@@ -412,4 +473,4 @@ public class He.Bin : Gtk.Widget, Gtk.Buildable {
 
     this.unparent ();
   }
-}
+}

lib/Utils/Ensor/Ensor.vala

@@ -19,15 +19,25 @@
 [CCode (gir_namespace = "He", gir_version = "1", cheader_filename = "libhelium-1.h")]
 namespace He.Ensor {
     // Maximum number of pixel samples to collect for quantization
-    private const int MAX_SAMPLES = 128;
+    // Reduced from 128 - fewer samples means faster quantization with minimal quality loss
+    private const int MAX_SAMPLES = 64;
+
+    // Maximum colors for quantization - reduced from 128 for significant speedup
+    // 32 colors is sufficient for accent extraction since we only need top 4
+    private const int MAX_QUANTIZE_COLORS = 32;
 
     private GLib.Array<int> accent_from_pixels (uint8[] pixels, bool alpha) {
         // First pass: collect filtered pixels
         int[] filtered_pixels = pixels_to_argb_array (pixels, alpha);
 
-        // Second pass: cluster to 128 colors using quantizer
+        // Early exit if no valid pixels
+        if (filtered_pixels.length == 0) {
+            return new GLib.Array<int> ();
+        }
+
+        // Second pass: cluster to reduced color count using quantizer
         var celebi = new He.QuantizerCelebi ();
-        var result = celebi.quantize (filtered_pixels, 128);
+        var result = celebi.quantize (filtered_pixels, MAX_QUANTIZE_COLORS);
 
         var score = new He.Score ();
         return score.score (result, 4); // We only need 4.
@@ -44,14 +54,16 @@ namespace He.Ensor {
         int total_pixels = (int) pixels.length / factor;
 
         // Calculate skip factor to sample approximately MAX_SAMPLES pixels
+        // Use a larger skip to reduce processing time
         int skip = int.max (1, total_pixels / MAX_SAMPLES);
 
         // Pre-calculate expected number of samples for array pre-allocation
-        // This avoids O(n²) reallocation with dynamic array growth
         int expected_samples = (total_pixels + skip - 1) / skip;
 
-        // Use GLib.Array with pre-allocated capacity for efficient appending
-        var list = new GLib.Array<int>.sized (false, false, sizeof (int), expected_samples);
+        // Pre-allocate result array with estimated size
+        // Using a simple dynamic array approach with capacity
+        int[] temp_result = new int[expected_samples];
+        int result_count = 0;
 
         int i = 0;
         while (i < total_pixels) {
@@ -76,32 +88,38 @@ namespace He.Ensor {
             }
 
             // Skip very dark pixels (likely shadows/borders)
-            if (red < 8 && green < 8 && blue < 8) {
+            // Slightly relaxed threshold for speed
+            if (red < 10 && green < 10 && blue < 10) {
                 i += skip;
                 continue;
             }
 
             // Skip very light pixels (likely highlights/glare)
-            if (red > 247 && green > 247 && blue > 247) {
+            // Slightly relaxed threshold for speed
+            if (red > 245 && green > 245 && blue > 245) {
                 i += skip;
                 continue;
             }
 
             int argb = argb_from_rgb_int (red, green, blue);
-            list.append_val (argb);
+
+            // Append to result
+            if (result_count < expected_samples) {
+                temp_result[result_count] = argb;
+                result_count++;
+            }
 
             i += skip;
         }
 
-        // Convert GLib.Array to int[] for the quantizer
-        // This is a single copy at the end, much better than per-element reallocs
-        if (list.length == 0) {
+        // Return only the filled portion
+        if (result_count == 0) {
             return new int[0];
         }
 
-        int[] result = new int[list.length];
-        for (uint j = 0; j < list.length; j++) {
-            result[j] = list.index (j);
+        int[] result = new int[result_count];
+        for (int j = 0; j < result_count; j++) {
+            result[j] = temp_result[j];
         }
 
         return result;