Add --auto-exit mode: converge & stop instead of running forever

Adaptive convergence algorithm: after warmup, monitors brightness and
volume deltas against targets. When both are within 1% for 3 consecutive
frames, exits cleanly. Typical convergence: ~23s.

Also fixes pre-existing bug: audio warmup counter stopped incrementing
after brightness warmup ended (frame 20), so audio warmup (needs frame
40) never completed. Counter now increments while either warmup is active.

Python: --auto-exit flag, convergence tracking in run() loop
Rust: --auto-exit flag, convergence tracking in tick() → returns bool,
      Cargo.toml version bumped 0.1.0 → 1.2.0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: RMANOV

adaptive-rust/Cargo.toml

@@ -7,7 +7,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.1.0"
+version = "1.2.0"
 edition = "2021"
 authors = ["Adaptive Brightness Controller"]
 license = "MIT"

adaptive-rust/crates/bin/src/controller.rs

@@ -29,6 +29,7 @@ pub struct ControllerConfig {
     pub volume_smoothing: f32,
     pub update_interval: Duration,
     pub warmup_frames: u32,
+    pub auto_exit: bool,
 }
 
 impl Default for ControllerConfig {
@@ -42,6 +43,7 @@ impl Default for ControllerConfig {
             volume_smoothing: 0.2,
             update_interval: Duration::from_millis(500),
             warmup_frames: 20,
+            auto_exit: false,
         }
     }
 }
@@ -89,6 +91,12 @@ pub struct Controller {
     // Timing
     last_update: Instant,
     last_perf_report: Instant,
+    start_time: Instant,
+
+    // Auto-exit convergence tracking
+    last_target_brightness: Option<f32>,
+    last_target_volume: Option<f32>,
+    converge_count: u32,
 }
 
 impl Controller {
@@ -140,17 +148,21 @@ impl Controller {
             volume_control,
             last_update: Instant::now(),
             last_perf_report: Instant::now(),
+            start_time: Instant::now(),
+            last_target_brightness: None,
+            last_target_volume: None,
+            converge_count: 0,
         })
     }
 
-    /// Process one tick of the controller
-    pub fn tick(&mut self) -> Result<()> {
+    /// Process one tick. Returns true if converged (auto-exit).
+    pub fn tick(&mut self) -> Result<bool> {
         let now = Instant::now();
 
         // Check update interval
         if now.duration_since(self.last_update) < self.config.update_interval {
             thread::sleep(Duration::from_millis(10));
-            return Ok(());
+            return Ok(false);
         }
         self.last_update = now;
 
@@ -160,13 +172,32 @@ impl Controller {
         // Process audio data
         self.process_audio()?;
 
+        // Auto-exit convergence check (after warmup)
+        if self.config.auto_exit && self.warmup_frame >= self.config.warmup_frames {
+            let b_ok = self.last_target_brightness
+                .map_or(false, |t| (self.smoothed_brightness - t).abs() < 1.0);
+            let v_ok = self.last_target_volume
+                .map_or(true, |t| (self.smoothed_volume - t).abs() < 1.0);
+            if b_ok && v_ok {
+                self.converge_count += 1;
+            } else {
+                self.converge_count = 0;
+            }
+            if self.converge_count >= 3 {
+                let elapsed = self.start_time.elapsed().as_secs_f32();
+                info!("Converged in {:.1}s — brightness: {:.1}%, volume: {:.1}%",
+                    elapsed, self.smoothed_brightness, self.smoothed_volume);
+                return Ok(true);
+            }
+        }
+
         // Periodic performance report
         if now.duration_since(self.last_perf_report) > Duration::from_secs(30) {
             self.print_performance_stats();
             self.last_perf_report = now;
         }
 
-        Ok(())
+        Ok(false)
     }
 
     fn process_brightness(&mut self) -> Result<()> {
@@ -204,6 +235,8 @@ impl Controller {
                 self.config.max_brightness,
             );
 
+            self.last_target_brightness = Some(target);
+
             // Determine smoothing factor
             let time_since_change = self.last_significant_change.elapsed().as_secs_f32();
             let smooth_factor = if self.warmup_frame < self.config.warmup_frames {
@@ -260,6 +293,8 @@ impl Controller {
                 self.config.max_volume,
             );
 
+            self.last_target_volume = Some(target);
+
             // Apply smoothing
             self.smoothed_volume = smooth_transition(
                 self.smoothed_volume,

adaptive-rust/crates/bin/src/main.rs

@@ -40,20 +40,28 @@ fn main() -> Result<()> {
     }
 
     // Create and run controller
-    let config = controller::ControllerConfig::default();
+    let auto_exit = std::env::args().any(|a| a == "--auto-exit");
+    let mut config = controller::ControllerConfig::default();
+    config.auto_exit = auto_exit;
     let mut controller = controller::Controller::new(config)?;
 
     info!("Controller initialized, entering main loop");
-    info!("Press Ctrl+C to stop");
+    if auto_exit {
+        info!("Mode: auto-exit (converge & stop)");
+    } else {
+        info!("Press Ctrl+C to stop");
+    }
 
     // Main loop
     while !SHUTDOWN.load(Ordering::SeqCst) {
-        if let Err(e) = controller.tick() {
-            tracing::error!("Controller error: {}", e);
+        match controller.tick() {
+            Ok(true) => break,  // Converged
+            Ok(false) => {}
+            Err(e) => tracing::error!("Controller error: {}", e),
         }
     }
 
-    info!("Shutdown signal received, cleaning up...");
+    info!("Cleaning up...");
     controller.cleanup();
     info!("Cleanup complete, exiting");
 

adaptive_brightness_volume.py

@@ -231,7 +231,8 @@ class AdaptiveBrightnessVolumeController:
     def __init__(self, camera_index: int = 0,
                  lock_exposure: bool = True,
                  brightness_range: Tuple[int, int] = (5, 45),
-                 volume_range: Tuple[int, int] = (3, 35)):
+                 volume_range: Tuple[int, int] = (3, 35),
+                 auto_exit: bool = False):
         self.system = platform.system().lower()
         if self.system not in ["linux", "windows"]:
             print(f"Currently only Linux and Windows are supported. Detected: {self.system}")
@@ -263,6 +264,9 @@ def __init__(self, camera_index: int = 0,
                     self.volume_tool = tool
                     break
 
+        # Auto-exit: stop once brightness & volume converge
+        self.auto_exit: bool = auto_exit
+
         # Configuration
         self.camera_index: int = camera_index
         self.lock_exposure: bool = lock_exposure
@@ -1079,6 +1083,7 @@ def process_frames(self, frame_queue: Queue, brightness_queue: Queue) -> None:
                 time.sleep(self.inactivity_check_interval)
 
     def run(self) -> None:
+        start_time = time.time()
         self.frame_queue = Queue(maxsize=10)
         self.brightness_queue = Queue(maxsize=10)
 
@@ -1092,6 +1097,13 @@ def run(self) -> None:
         last_perf_report_time = time.time()
         perf_report_interval = 30.0
 
+        # Auto-exit convergence tracking
+        _converge_count = 0
+        _converge_threshold = 1.0  # % delta to consider "stable"
+        _converge_required = 3     # consecutive stable frames to confirm
+        _last_target_brightness = None
+        _last_target_volume = None
+
         try:
             while not self.stop_event.is_set():
                 current_time = time.time()
@@ -1156,8 +1168,9 @@ def run(self) -> None:
                         if SCREEN_CAPTURE_AVAILABLE:
                             target_brightness = target_brightness * self.screen_brightness_factor
 
-                        if self.is_in_warmup:
+                        if self.is_in_warmup or self.is_audio_in_warmup:
                             self.current_warmup_frame += 1
+                        if self.is_in_warmup:
                             if self.initial_brightness is None:
                                 try:
                                     self.initial_brightness = self.get_brightness()
@@ -1269,6 +1282,27 @@ def run(self) -> None:
                         except Exception as e:
                             print(f"Volume setting error: {e}")
 
+                    # Auto-exit: check convergence after warmup
+                    if self.auto_exit and not self.is_in_warmup:
+                        b_stable = (_last_target_brightness is not None and
+                                    abs(self.smoothed_brightness - _last_target_brightness) < _converge_threshold)
+                        v_stable = (not AUDIO_AVAILABLE or not self.is_audio_in_warmup) and (
+                            not AUDIO_AVAILABLE or (
+                                _last_target_volume is not None and
+                                abs(self.smoothed_volume - _last_target_volume) < _converge_threshold))
+                        if b_stable and v_stable:
+                            _converge_count += 1
+                        else:
+                            _converge_count = 0
+                        _last_target_brightness = target_brightness if camera_brightness is not None else _last_target_brightness
+                        _last_target_volume = target_volume if AUDIO_AVAILABLE else _last_target_volume
+                        if _converge_count >= _converge_required:
+                            elapsed = time.time() - start_time
+                            print(f"\nConverged in {elapsed:.1f}s — "
+                                  f"brightness: {self.smoothed_brightness:.1f}%, "
+                                  f"volume: {self.smoothed_volume:.1f}%")
+                            break
+
                     if current_time - last_brightness_change_time > 10:
                         update_interval = min(update_interval * 1.2, 2.0)
                     else:
@@ -1322,10 +1356,13 @@ def run(self) -> None:
         print("  pip install pillow --user     # Alternative method")
         print("\nContinuing without screen content analysis...\n")
 
+    auto_exit = "--auto-exit" in sys.argv
+
     try:
-        controller = AdaptiveBrightnessVolumeController()
+        controller = AdaptiveBrightnessVolumeController(auto_exit=auto_exit)
         print("\nStarting adaptive brightness and volume controller...")
         print(f"Platform: {platform.system()}")
+        print(f"Mode: {'auto-exit (converge & stop)' if auto_exit else 'continuous'}")
         print(f"Brightness range: {controller.min_brightness}% - {controller.max_brightness}%")
         print(f"Volume range: {controller.min_volume}% - {controller.max_volume}%")
         print(f"Brightness control method: {controller.brightness_method}")
@@ -1336,7 +1373,8 @@ def run(self) -> None:
             print(f"Audio control: Enabled ({AUDIO_METHOD})")
         else:
             print("Audio control: Disabled")
-        print("\nPress Ctrl+C to stop")
+        if not auto_exit:
+            print("\nPress Ctrl+C to stop")
         controller.run()
     except KeyboardInterrupt:
         print("\nStopping controller...")